Log traces

LLM applications are complex systems that do more than just call an LLM API, they will often involve retrieval, pre-processing and post-processing steps. Tracing is a tool that helps you understand the flow of your application and identify specific points in your application that may be causing issues.

Opik's tracing functionality allows you to track not just all the LLM calls made by your application but also any of the other steps involved.

Opik supports agent observability using our Typescript SDK, Python SDK, first class OpenTelemetry support and our REST API.

We won't be covering how to track chat conversations in this guide, you can learn more about this in the Logging conversations guide.

Before adding observability to your application, you will first need to install and configure the Opik SDK.

npm install opik

# Set OPIK_API_KEY and OPIK_WORKSPACE in your .env file
OPIK_API_KEY=your_api_key_here
OPIK_WORKSPACE=your_workspace_name

# Optional if you are using Opik Cloud:
OPIK_URL_OVERRIDE=https://www.comet.com/opik/api

# Install the SDK
pip install opik

export OTEL_EXPORTER_OTLP_ENDPOINT=https://www.comet.com/opik/api/v1/private/otel
export OTEL_EXPORTER_OTLP_HEADERS='Authorization=<your-api-key>,Comet-Workspace=default'

# If you are using self-hosted instance:
# export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:5173/api/v1/private/otel

:::

Once you have installed and configured the Opik SDK, you can start using it to track your agent calls:

export OPIK_API_KEY="<your-api-key>" # Only required if you are using the Opik Cloud version
export OPIK_URL_OVERRIDE="https://www.comet.com/opik/api" # Cloud version
# export OPIK_URL_OVERRIDE="http://localhost:5173/api" # Self-hosting

import OpenAI from "openai";
import { trackOpenAI } from "opik-openai";

// Initialize the original OpenAI client
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// Wrap the client with Opik tracking
const trackedOpenAI = trackOpenAI(openai);

// Use the tracked client just like the original
const completion = await trackedOpenAI.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Hello, how can you help me today?" }],
});
console.log(completion.choices[0].message.content);

// Ensure all traces are sent before your app terminates
await trackedOpenAI.flush();

::: :::

opik configure

from opik.integrations.openai import track_openai
from openai import OpenAI

# Wrap your OpenAI client
openai_client = OpenAI()
openai_client = track_openai(openai_client)

::: :::

export OPIK_API_KEY="<your-api-key>"
export OPIK_URL_OVERRIDE="https://www.comet.com/opik/api" # Cloud version
# export OPIK_URL_OVERRIDE="http://localhost:5173/api" # Self-hosting

import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";
import { NodeSDK } from "@opentelemetry/sdk-node";
import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
import { OpikExporter } from "opik-vercel";

// Set up OpenTelemetry with Opik
const sdk = new NodeSDK({
  traceExporter: new OpikExporter(),
  instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();

// Your AI SDK calls with telemetry enabled
const result = await generateText({
  model: openai("gpt-4o"),
  prompt: "What is love?",
  experimental_telemetry: { isEnabled: true },
});

console.log(result.text);

::: :::

opik configure

from opik.integrations.adk import OpikTracer, track_adk_agent_recursive

opik_tracer = OpikTracer()

# Define your ADK agent

# Wrap your ADK agent with the OpikTracer
track_adk_agent_recursive(agent, opik_tracer)

::: :::

opik configure

from opik.integrations.langchain import OpikTracer

# Create your LangGraph graph
graph = ...
app = graph.compile(...)

# Wrap your LangGraph graph with the OpikTracer
opik_tracer = OpikTracer(graph=app.get_graph(xray=True))

# Pass the OpikTracer callback to the invoke functions
result = app.invoke({"messages": [HumanMessage(content = "How to use LangGraph ?")]},
              config={"callbacks": [opik_tracer]})

::: :::

opik configure

from opik import track

@track
def my_function(input: str) -> str:
    return input

::: :::

  Open in Cursor



The pre-built prompt will guide you through the integration process, install the Opik SDK and
instrument your code. It supports both Python and TypeScript codebases, if you are using
another language just let us know and we can help you out.

Once the integration is complete, simply run your application and you will start seeing traces
in your Opik dashboard.

:::

If you would like more control over the logging process, you can use the low-level SDKs to log your traces and spans.

Now that you have observability enabled for your agents, you can start to review and analyze the agent calls in Opik. In the Opik UI, you can review each agent call, see the agent graph and review all the tool calls made by the agent.

Function decorators are a great way to add Opik logging to your existing application. When you add the @track decorator to a function, Opik will create a span for that function call and log the input parameters and function output for that function. If we detect that a decorated function is being called within another decorated function, we will create a nested span for the inner function.

While decorators are most popular in Python, we also support them in our Typescript SDK:

```typescript maxLines=100
import { track } from "opik";

class TranslationService {
    @track({ type: "llm" })
    async generateText() {
        // Your LLM call here
        return "Generated text";
    }

    @track({ name: "translate" })
    async translate(text: string) {
        // Your translation logic here
        return `Translated: ${text}`;
    }

    @track({ name: "process", projectName: "translation-service" })
    async process() {
        const text = await this.generateText();
        return this.translate(text);
    }
}

:::callout{intent="info"}
You can also specify custom `tags`, `metadata`, and/or a `thread_id` for each trace and/or
span logged for the decorated function. For more information, see
[Logging additional data using the opik_args parameter](#logging-additional-data)

:::

import opik
import openai

client = openai.OpenAI()

@opik.track
def retrieve_context(input_text):
    # Your retrieval logic here, here we are just returning a
    # hardcoded list of strings
    context =[
        "What specific information are you looking for?",
        "How can I assist you with your interests today?",
        "Are there any topics you'd like to explore?",
    ]
    return context

@opik.track
def generate_response(input_text, context):
    full_prompt = (
        f" If the user asks a non-specific question, use the context to provide a relevant response.\n"
        f"Context: {', '.join(context)}\n"
        f"User: {input_text}\n"
        f"AI:"
    )

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": full_prompt}]
    )
    return response.choices[0].message.content

@opik.track(name="my_llm_application")
def llm_chain(input_text):
    context = retrieve_context(input_text)
    response = generate_response(input_text, context)

    return response

# Use the LLM chain
result = llm_chain("Hello, how are you?")
print(result)

import opik

@opik.track
def llm_chain(text: str) -> str:
    opik_context.update_current_trace(
        tags=["llm_chatbot"],
        metadata={"version": "1.0", "method": "simple"},
        thread_id="conversation-123",
        feedback_scores=[
            {
                "name": "user_feedback",
                "value": 1
            }
        ],
    )
    opik_context.update_current_span(
        metadata={"model": "gpt-4o"},
    )
    return f"Processed: {text}"

import opik

@opik.track
def llm_chain(text: str) -> str:
    # LLM chain code
    # ...
    return f"Processed: {text}"

# Call with opik_args - it won't be passed to the function
result = llm_chain(
    "hello world",
    opik_args={
        "span": {
            "tags": ["llm", "agent"],
            "metadata": {"version": "1.0", "method": "simple"}
        },
        "trace": {
            "thread_id": "conversation-123",
            "tags": ["user-session"],
            "metadata": {"user_id": "user-456"}
        }
    }
)

print(result)

::: :::

If you need full control over the logging process, you can use the low-level SDKs to log your traces and spans:

import { Opik } from "opik";

const client = new Opik({
    apiUrl: "https://www.comet.com/opik/api",
    apiKey: "your-api-key", // Only required if you are using Opik Cloud
    projectName: "your-project-name",
    workspaceName: "your-workspace-name", // Optional
});

// Log a trace with an LLM span
const trace = client.trace({
    name: `Trace`,
    input: {
        prompt: `Hello!`,
    },
    output: {
        response: `Hello, world!`,
    },
});

const span = trace.span({
    name: `Span`,
    type: "llm",
    input: {
        prompt: `Hello, world!`,
    },
    output: {
        response: `Hello, world!`,
    },
});

// Flush the client to send all traces and spans
await client.flush();

:::

from opik import Opik

client = Opik(project_name="Opik client demo")

# Create a trace
trace = client.trace(
    name="my_trace",
    input={"user_question": "Hello, how are you?"},
    output={"response": "Comment ça va?"}
)

# Add a span
trace.span(
    name="Add prompt template",
    input={"text": "Hello, how are you?", "prompt_template": "Translate the following text to French: {text}"},
    output={"text": "Translate the following text to French: hello, how are you?"}
)

# Add an LLM call
trace.span(
    name="llm_call",
    type="llm",
    input={"prompt": "Translate the following text to French: hello, how are you?"},
    output={"response": "Comment ça va?"}
)

# End the trace
trace.end()

Opik's logging functionality is designed with production environments in mind. To optimize performance, all logging operations are executed in a background thread.

If you want to ensure all traces are logged to Opik before exiting your program, you can use the opik.Opik.flush method:

from opik import Opik

client = Opik()

# Log some traces
client.flush()

::: :::

If you are using the low-level SDKs, you can use the context managers to log traces and spans. Context managers provide a clean and Pythonic way to manage the lifecycle of traces and spans, ensuring proper cleanup and error handling.

import opik

# Basic trace creation
with opik.start_as_current_trace("my-trace", project_name="my-project") as trace:
    # Your application logic here
    trace.input = {"user_query": "What is the weather?"}
    trace.output = {"response": "It's sunny today!"}
    trace.tags = ["weather", "api-call"]
    trace.metadata = {"model": "gpt-4", "temperature": 0.7}

import opik

# Basic span creation
with opik.start_as_current_span("llm-call", type="llm", project_name="my-project") as span:
    # Your LLM call here
    span.input = {"prompt": "Explain quantum computing"}
    span.output = {"response": "Quantum computing is..."}
    span.model = "gpt-4"
    span.provider = "openai"
    span.usage = {
        "prompt_tokens": 10,
        "completion_tokens": 50,
        "total_tokens": 60
    }

import opik

with opik.start_as_current_trace("chatbot-conversation", project_name="chatbot") as trace:
    trace.input = {"user_message": "Help me with Python"}

    # First span: Process user input
    with opik.start_as_current_span("process-input", type="general") as span:
        span.input = {"raw_input": "Help me with Python"}
        span.output = {"processed_input": "Python programming help request"}

    # Second span: Generate response
    with opik.start_as_current_span("generate-response", type="llm") as span:
        span.input = {"prompt": "Python programming help request"}
        span.output = {"response": "I'd be happy to help with Python!"}
        span.model = "gpt-4"
        span.provider = "openai"

    trace.output = {"final_response": "I'd be happy to help with Python!"}

import opik

try:
    with opik.start_as_current_trace("risky-operation", project_name="my-project") as trace:
        trace.input = {"data": "important data"}
        # This will raise an exception
        result = 1 / 0
        trace.output = {"result": result}
except ZeroDivisionError:
    # The trace is still properly closed and logged
    print("Error occurred, but trace was logged")

import opik

# Parameters set outside the context manager
with opik.start_as_current_trace(
    "dynamic-trace",
    input={"initial": "data"},
    tags=["initial-tag"],
    project_name="my-project"
) as trace:
    # Override parameters inside the context manager
    trace.input = {"updated": "data"}
    trace.tags = ["updated-tag", "new-tag"]
    trace.metadata = {"custom": "metadata"}

    # The final trace will use the updated values

import opik

# Immediate flush
with opik.start_as_current_trace("immediate-trace", flush=True) as trace:
    trace.input = {"data": "important"}
    # Data is sent immediately when exiting the context

# Deferred flush (default)
with opik.start_as_current_trace("deferred-trace", flush=False) as trace:
    trace.input = {"data": "less urgent"}
    # Data will be sent asynchronously later or when the program exits

:::

1. Use descriptive names: Choose clear, descriptive names for your traces and spans that explain what they represent.

2. Set appropriate types: Use the correct span types ("llm", "retrieval", "general", etc.) to help with filtering and analysis.

3. Include relevant metadata: Add metadata that will be useful for debugging and analysis, such as model names, parameters, and custom metrics.

4. Handle errors gracefully: Let the context manager handle cleanup, but ensure your application logic handles errors appropriately.

5. Use project organization: Organize your traces by project to keep your Opik dashboard clean and organized.

6. Consider performance: Use flush=True only when immediate data availability is required, as it can slow down your application by triggering a synchronous, immediate data upload.

By default, traces are logged to the Default Project project. You can change the project you want the trace to be logged to in a couple of ways:

import { Opik } from "opik";

const client = new Opik({
    projectName: "my_project",
    // apiKey: "my_api_key",
    // apiUrl: "https://www.comet.com/opik/api",
    // workspaceName: "my_workspace",
});

@track(project_name="my_project")
def my_function():
    pass

from opik import Opik

client = Opik(project_name="my_project")

:::

The project name is determined differently depending on whether an active project context already exists.

This applies to the top-level @track-decorated function call, the Opik() client, or a native integration (e.g., track_openai, OpikTracer) used outside any traced context. The project name is resolved in this order:

1. Explicit project_name argument — passed directly to @track(project_name="..."), Opik(project_name="..."), OpikTracer(project_name="..."), or a client method like client.trace(project_name="...")
2. Client configuration — from the OPIK_PROJECT_NAME environment variable or ~/.opik.config file
3. Default — falls back to "Default Project" (a warning is logged once to remind you to configure a project name)

The first @track(project_name="...") or opik.project_context("...") call that runs establishes the active project context for all nested operations.

Once a project context is established (by a parent @track(project_name="...") or opik.project_context("...")), all nested operations use the context project name. This includes:

• Nested @track-decorated functions — even if they pass a different project_name, the outer context wins (a warning is logged)
• Native integrations (e.g., OpikTracer, track_openai) — if initialized inside an active context, the context project overrides the integration's project_name argument (a warning is logged)
• Opik() client methods — if a method like client.trace(project_name="...") is called with an explicit project_name, the explicit argument wins; if project_name is omitted, the context project is used

This ensures that all traces and spans within a single execution flow are logged to the same project.

When @track(project_name="...") is used on the top-level function, it sets the project context for the entire call tree:

from opik import track

@track(project_name="my-agent")
def agent(query):
    context = retrieve(query)
    return generate(context)

@track
def retrieve(query):
    # Inherits "my-agent" from the parent context
    ...

@track
def generate(context):
    # Also inherits "my-agent" from the parent context
    ...

If a nested function specifies a different project_name, it is ignored and the outer project is preserved:

@track(project_name="my-agent")
def agent(query):
    helper(query)  # Still logs to "my-agent", NOT "other-project"

@track(project_name="other-project")
def helper(query):
    # Warning is logged: outer project "my-agent" will be used
    ...

The opik.project_context() context manager sets the project name for all Opik operations within a block — @track-decorated functions, native integrations, and Opik() client calls (when project_name is not passed explicitly):

import opik

with opik.project_context("customer-support"):
    # @track-decorated functions and native integrations
    # all use "customer-support" as the project name
    my_agent(query)

Nesting rules are the same: the first project_context or @track(project_name=...) to run owns the context. Inner calls with a different project name are ignored (a warning is logged).

Environments let you tag traces with a lifecycle stage — for example development, staging, or production — so you can segment and filter your observability data in the Opik UI.

import { Opik } from "opik";

const client = new Opik({ projectName: "my-project" });

const trace = client.trace({
    name: "my_trace",
    input: { question: "Hello" },
    environment: "production",
});

trace.end();
await client.flush();

import opik

@opik.track(environment="production")
def my_pipeline(input_text: str) -> str:
    return input_text

my_pipeline("Hello, world!")

from opik import Opik

client = Opik(project_name="my_project")

trace = client.trace(
    name="my_trace",
    input={"question": "Hello"},
    environment="production",
)
trace.end()

:::

You can manage the set of named environments in your workspace programmatically:

import { Opik } from "opik";

const client = new Opik();

// Create a new environment
const env = await client.createEnvironment("production", {
    description: "Live production traffic",
    color: "#FF0000",
});

// List all environments
const envs = await client.getEnvironments();

// Update an environment
await client.updateEnvironment("production", { description: "Updated description" });

// Delete an environment
await client.deleteEnvironment("production");

from opik import Opik

client = Opik()

# Create a new environment
env = client.create_environment(
    name="production",
    description="Live production traffic",
    color="#FF0000",
)

# List all environments
envs = client.get_environments()

# Update an environment
client.update_environment("production", description="Updated description")

# Delete an environment
client.delete_environment("production")

:::

Once traces are tagged, you can filter them programmatically using the environment field in filter_string. It supports =, !=, in, and not_in:

from opik import Opik

client = Opik()

# Only production traces
traces = client.search_traces(
    project_name="my_project",
    filter_string='environment = "production"'
)

# Multiple environments
traces = client.search_traces(
    project_name="my_project",
    filter_string='environment in ("production", "staging")'
)

# Same filtering applies to spans
spans = client.search_spans(
    project_name="my_project",
    filter_string='environment = "production"'
)

# And to conversation threads
threads = client.search_threads(
    project_name="my_project",
    filter_string='environment = "production"'
)

# Combine with other thread filters
active_prod_threads = client.search_threads(
    project_name="my_project",
    filter_string='environment = "production" AND status = "active"'
)

This process is optional and is only needed if you are running a short-lived script or if you are debugging why traces and spans are not being logged to Opik.

import { Opik } from "opik";

const client = new Opik();
client.flush();

from opik import Opik

client = Opik()
client.flush()

from opik import track

@track(flush=True)
def llm_chain(input_text):
    # LLM chain code
    # ...
    return f"Processed: {input_text}"

:::

import {
  isTracingActive,
  setTracingActive,
  resetTracingToConfigDefault,
} from "opik";

// Check the current state of the tracing flag
console.log(isTracingActive());

// Disable the logging process
setTracingActive(false);

// Re-enable the logging process
setTracingActive(true);

// Reset to the value resolved from configuration (OPIK_TRACK_DISABLE / trackDisable)
resetTracingToConfigDefault();

import opik

# Check the current state of the tracing flag
print(opik.is_tracing_active())

# Disable the logging process
opik.set_tracing_active(False)

# re-enable the logging process
print(opik.set_tracing_active(True))

:::

Once you have the observability set up for your agent, you can go one step further and:

• Logging chat conversations
• Logging user feedback
• Setup online evaluation metrics