Integrate your AI agent

If you don’t have an Adaline account yet, you can create one by signing up at app.adaline.ai. After creating an account, you will notice the following:

A Shared teamspace containing workspace-wide public projects and other entities.
A Private teamspace with a sample project, prompt and dataset.

2. Set up your workspace API key

Create an API key that your application will use to authenticate with Adaline.

In the sidebar, click Settings → API keys.
Click on Create API key.

Rename the API key to something meaningful.
Click on the generated API key to copy and paste in a secure location. It will not be visible again.
Click on Create key.

3. Integrate your AI agent

Choose the integration method that best fits your workflow.

Using coding agents
Adaline Proxy
SDK or API

Let an AI coding agent do it for you

If you use an AI coding agent such as Cursor, Windsurf, Cline, or any other agent that accepts context — you can hand it all the information it needs to integrate Adaline into your codebase automatically.Open the full integration context document below, then use the Copy page button (top-right of the page) or the ChatGPT / Claude buttons to send it directly to your AI agent.

TypeScript SDK Integration Context

Python SDK Integration Context

REST API Integration Context

MCP servers coming soon — We are building dedicated MCP (Model Context Protocol) servers that will allow AI coding agents to query Adaline’s documentation and APIs directly, making this integration even more seamless.

Zero-code integration via the Adaline Proxy

The fastest way to start sending data to Adaline. Instead of calling your AI provider directly, you route requests through Adaline’s gateway by changing the base URL. Adaline transparently forwards the request to your provider while recording the full trace — no SDK or additional instrumentation required.

Get your Project and Prompt IDs

Before writing any code, grab the identifiers that link your application’s traffic to the correct project and prompt in Adaline.

Copy your Project ID

In the sidebar, select your project.
On the top bar, click on Monitor
On the top right, click on Copy Project ID.

Copy your Prompt ID(s)

In the sidebar, select your prompt.
On the top bar, click on Monitor
On the top right, click on Copy Prompt ID.

Repeat this for each prompt you want to monitor.

Supported providers

Change your base URL to the corresponding Adaline gateway endpoint for your provider:

Provider	Base URL
OpenAI	`https://gateway.adaline.ai/v1/openai/`
Anthropic	`https://gateway.adaline.ai/v1/anthropic/`
Google	`https://gateway.adaline.ai/v1/google`
Azure	`https://gateway.adaline.ai/v1/azure/`
Amazon Bedrock	`https://gateway.adaline.ai/v1/bedrock/`
Groq	`https://gateway.adaline.ai/v1/groq/`
Open Router	`https://gateway.adaline.ai/v1/open-router/`
Together AI	`https://gateway.adaline.ai/v1/together-ai/`
xAI	`https://gateway.adaline.ai/v1/xai/`
Vertex AI	`https://gateway.adaline.ai/v1/vertex`

Code examples

Below are minimal examples showing how to route requests through the proxy. Replace the placeholder values with your actual credentials and IDs.

TypeScript (OpenAI)
Python (OpenAI)
Python (Anthropic)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: "https://gateway.adaline.ai/v1/openai/",
  defaultHeaders: {
    "adaline-api-key": process.env.ADALINE_API_KEY,
    "adaline-project-id": process.env.ADALINE_PROJECT_ID,
    "adaline-prompt-id": process.env.ADALINE_PROMPT_ID,
  },
});

// First prompt — classify intent
const classification = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [
    {
      role: "system",
      content:
        "Classify the user's intent as one of: greeting, question, complaint, feedback.",
    },
    { role: "user", content: "My order hasn't arrived in three days." },
  ],
});

console.log("Intent:", classification.choices[0].message.content);

// Second prompt — generate reply
const reply = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [
    {
      role: "system",
      content: `You are a support assistant. The user's intent is: ${classification.choices[0].message.content}. Respond helpfully.`,
    },
    { role: "user", content: "My order hasn't arrived in three days." },
  ],
});

console.log("Reply:", reply.choices[0].message.content);

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url="https://gateway.adaline.ai/v1/openai/",
)

headers = {
    "adaline-api-key": os.getenv("ADALINE_API_KEY"),
    "adaline-project-id": os.getenv("ADALINE_PROJECT_ID"),
    "adaline-prompt-id": os.getenv("ADALINE_PROMPT_ID"),
}

# First prompt — classify intent
classification = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "Classify the user's intent as one of: greeting, question, complaint, feedback.",
        },
        {"role": "user", "content": "My order hasn't arrived in three days."},
    ],
    extra_headers=headers,
)

intent = classification.choices[0].message.content
print("Intent:", intent)

# Second prompt — generate reply
reply = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": f"You are a support assistant. The user's intent is: {intent}. Respond helpfully.",
        },
        {"role": "user", "content": "My order hasn't arrived in three days."},
    ],
    extra_headers=headers,
)

print("Reply:", reply.choices[0].message.content)

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    base_url="https://gateway.adaline.ai/v1/anthropic/",
    default_headers={
        "adaline-api-key": os.getenv("ADALINE_API_KEY"),
        "adaline-project-id": os.getenv("ADALINE_PROJECT_ID"),
        "adaline-prompt-id": os.getenv("ADALINE_PROMPT_ID"),
    },
)

# First prompt — classify intent
classification = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=256,
    messages=[
        {"role": "user", "content": "Classify this intent as greeting, question, complaint, or feedback: 'My order hasn't arrived in three days.'"},
    ],
)

intent = classification.content[0].text
print("Intent:", intent)

# Second prompt — generate reply
reply = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": f"You are a support assistant. The user's intent is: {intent}. Respond helpfully to: 'My order hasn't arrived in three days.'"},
    ],
)

print("Reply:", reply.content[0].text)

Run your application. Both requests are automatically routed through Adaline’s gateway, and traces appear in the dashboard within seconds.

Full control via SDK or API

Use the Adaline SDK (TypeScript or Python) or the REST API directly for complete control over how traces and spans are structured. This approach lets you capture any operation — LLM calls, tool executions, retrievals, and custom functions.

Get your Project and Prompt IDs

Copy your Project ID

In the sidebar, select your project.
On the top bar, click on Monitor
On the top right, click on Copy Project ID.

Copy your Prompt ID(s)

In the sidebar, select your prompt.
On the top bar, click on Monitor
On the top right, click on Copy Prompt ID.

Repeat this for each prompt you want to monitor.

Install

TypeScript
Python

npm install @adaline/client

pip install adaline-client

Create a trace and log spans

The following example creates a trace with two spans — simulating a simple AI application that classifies a user’s intent and then generates a reply.

TypeScript
Python
REST API

import { Adaline } from "@adaline/client";
import OpenAI from "openai";

const adaline = new Adaline({ apiKey: process.env.ADALINE_API_KEY });
const monitor = adaline.initMonitor({ projectId: "your-project-id" });
const openai = new OpenAI();

// Start a trace for this request
const trace = monitor.logTrace({ name: "support-request" });

// Span 1 — classify intent
const classifySpan = trace.logSpan({
  name: "classify-intent",
  promptId: "your-classify-prompt-id",
});

const classification = await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [
    { role: "system", content: "Classify the intent as: greeting, question, complaint, feedback." },
    { role: "user", content: "My order hasn't arrived in three days." },
  ],
});

classifySpan.update({
  status: "success",
  content: {
    type: "Model",
    provider: "openai",
    model: "gpt-4o-mini",
    input: JSON.stringify({ messages: [{ role: "user", content: "My order hasn't arrived in three days." }] }),
    output: JSON.stringify(classification),
  },
});
classifySpan.end();

// Span 2 — generate reply
const replySpan = trace.logSpan({
  name: "generate-reply",
  promptId: "your-reply-prompt-id",
});

const reply = await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [
    { role: "system", content: `You are a support assistant. Intent: ${classification.choices[0].message.content}` },
    { role: "user", content: "My order hasn't arrived in three days." },
  ],
});

replySpan.update({
  status: "success",
  content: {
    type: "Model",
    provider: "openai",
    model: "gpt-4o-mini",
    input: JSON.stringify({ messages: [{ role: "user", content: "My order hasn't arrived in three days." }] }),
    output: JSON.stringify(reply),
  },
});
replySpan.end();

// End the trace and flush
trace.update({ status: "success" });
trace.end();
await monitor.flush();
monitor.stop();

import os, json, asyncio
from adaline.main import Adaline
from openai import AsyncOpenAI
from adaline_api.models.log_span_content import LogSpanContent
from adaline_api.models.log_span_model_content import LogSpanModelContent

adaline = Adaline(api_key=os.getenv("ADALINE_API_KEY"))
monitor = adaline.init_monitor(project_id="your-project-id")
openai_client = AsyncOpenAI()

# Start a trace for this request
trace = monitor.log_trace(name="support-request")

# Span 1 — classify intent
classify_span = trace.log_span(
    name="classify-intent",
    prompt_id="your-classify-prompt-id",
)

classification = await openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Classify the intent as: greeting, question, complaint, feedback."},
        {"role": "user", "content": "My order hasn't arrived in three days."},
    ],
)

classify_span.update({
    "status": "success",
    "content": LogSpanContent(
        actual_instance=LogSpanModelContent(
            type="Model",
            provider="openai",
            model="gpt-4o-mini",
            input=json.dumps({"messages": [{"role": "user", "content": "My order hasn't arrived in three days."}]}),
            output=json.dumps(classification.model_dump()),
        )
    ),
})
classify_span.end()

# Span 2 — generate reply
reply_span = trace.log_span(
    name="generate-reply",
    prompt_id="your-reply-prompt-id",
)

intent = classification.choices[0].message.content
reply = await openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": f"You are a support assistant. Intent: {intent}"},
        {"role": "user", "content": "My order hasn't arrived in three days."},
    ],
)

reply_span.update({
    "status": "success",
    "content": LogSpanContent(
        actual_instance=LogSpanModelContent(
            type="Model",
            provider="openai",
            model="gpt-4o-mini",
            input=json.dumps({"messages": [{"role": "user", "content": "My order hasn't arrived in three days."}]}),
            output=json.dumps(reply.model_dump()),
        )
    ),
})
reply_span.end()

# End the trace and flush
trace.update({"status": "success"})
trace.end()
await monitor.flush()
monitor.stop()

# Create a trace
curl -X POST https://api.adaline.ai/v2/logs/trace \
  -H "Authorization: Bearer $ADALINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "your-project-id",
    "name": "support-request",
    "status": "success"
  }'

# Create a span within the trace
curl -X POST https://api.adaline.ai/v2/logs/span \
  -H "Authorization: Bearer $ADALINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "traceId": "<TRACE_ID_FROM_ABOVE>",
    "promptId": "your-prompt-id",
    "name": "classify-intent",
    "status": "success",
    "content": {
      "type": "Model",
      "provider": "openai",
      "model": "gpt-4o-mini",
      "input": "{\"messages\":[{\"role\":\"user\",\"content\":\"My order hasn't arrived.\"}]}",
      "output": "{\"choices\":[{\"message\":{\"content\":\"complaint\"}}]}"
    }
  }'

Run your application. Each trace and its spans will appear in the Adaline dashboard within seconds.

4. View your traces

Regardless of which integration method you chose, the dashboard experience is the same.

Select your Project from the sidebar, then navigate to the Monitor tab from the top bar. You will see a list of traces — one for each request your application made.

Click on any trace to expand it. Each trace contains one or more spans representing individual operations (e.g., an LLM call, a tool invocation, a retrieval operation, etc).

By default, the trace view is in a tree view. You can switch to a waterfall view by clicking the Waterfall button (top right).

5. View your spans

Each span represents an individual operation (e.g., an LLM call, a tool invocation) within a trace. Span provides a detailed view of each operation, including the request and response payloads, latency metrics, and cost and token usage. Select your Prompt from the sidebar, then navigate to the Monitor tab from the top bar. You will see a list of spans — one for each invocation of the step in your application. Click on any span to open its detailed view.

You will see the full request and response payloads (including the system prompt, user message, and the model’s output), latency metrics (time-to-first-token and total response time), and cost and token usage (input tokens, output tokens, and total cost) — all in one place. Adaline automatically calculates the cost of each request based on the model’s token pricing.

6. View aggregated charts

Charts provide aggregated, time-series views of your AI agent’s performance. They are automatically generated from the traces and spans flowing into Adaline, giving you a high-level operational dashboard without any additional configuration. Use charts to spot trends, detect anomalies, and then drill down into the underlying traces and spans for root cause analysis. Select your Project from the sidebar, then navigate to the Overview tab from the top bar.

You will see a dashboard of metric charts, showing a time-series view of volume, latency, input tokens, output tokens, cost, and evaluation score. Together, these give you a complete picture of your AI agent’s behavior in production — from the structure of every request, to its cost and speed — all in one place. Congratulations! You have successfully integrated your AI agent with Adaline. Read more about monitoring and observability

Get started

Instrument

Monitor

Iterate

Evaluate

Deploy

Admin

Others

Integrate your AI agent

2. Set up your workspace API key

3. Integrate your AI agent

Let an AI coding agent do it for you

TypeScript SDK Integration Context

Python SDK Integration Context

REST API Integration Context

Zero-code integration via the Adaline Proxy

Get your Project and Prompt IDs

Supported providers

Code examples

Full control via SDK or API

Get your Project and Prompt IDs

Install

Create a trace and log spans

4. View your traces

5. View your spans

6. View aggregated charts

Get started

Instrument

Monitor

Iterate

Evaluate

Deploy

Admin

Others

Documentation Index

​1. Sign up

​2. Set up your workspace API key

​3. Integrate your AI agent

​Let an AI coding agent do it for you

TypeScript SDK Integration Context

Python SDK Integration Context

REST API Integration Context

​Zero-code integration via the Adaline Proxy

​Get your Project and Prompt IDs

​Supported providers

​Code examples

​Full control via SDK or API

​Get your Project and Prompt IDs

​Install

​Create a trace and log spans

​4. View your traces

​5. View your spans

​6. View aggregated charts

1. Sign up

2. Set up your workspace API key

3. Integrate your AI agent

Let an AI coding agent do it for you

Zero-code integration via the Adaline Proxy

Get your Project and Prompt IDs

Supported providers

Code examples

Full control via SDK or API

Get your Project and Prompt IDs

Install

Create a trace and log spans

4. View your traces

5. View your spans

6. View aggregated charts