Quickstart

<Steps>
  <Step>
    Install the Opik Python SDK:

    ```bash
    pip install opik
    ```
  </Step>
  <Step>
    Configure the Opik Python SDK:

    ```bash
    opik configure
    ```
  </Step>
  <Step>
    Wrap your function with the `@track` decorator:

    ```python
    from opik import track

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

    All calls to the `my_function` will now be logged to Opik. This works well for any function
    even nested ones and is also supported by most integrations (just wrap any parent function
    with the `@track` decorator).
  </Step>
</Steps>

<Steps>
  <Step>
    Install the Opik TypeScript SDK:

    ```bash
    npm install opik
    ```
  </Step>
  <Step>
    Configure the Opik TypeScript SDK by running the interactive CLI tool:

    ```bash
    npx opik-ts configure
    ```

    This will detect your project setup, install required dependencies, and help you configure environment variables.
  </Step>
  <Step>
    Log a trace using the Opik client:

    ```typescript
    import { Opik } from "opik";

    const client = new Opik();

    const trace = client.trace({
      name: "My LLM Application",
      input: { prompt: "What is the capital of France?" },
      output: { response: "The capital of France is Paris." },
    });

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

    All traces will now be logged to Opik. You can also log spans within traces for more detailed observability.
  </Step>
</Steps>

<Steps>
  <Step>
    Install the Opik Python SDK:

    ```bash
    pip install opik
    ```
  </Step>
  <Step>
    Configure the Opik Python SDK, this will prompt you for your API key if you are using Opik
    Cloud or your Opik server address if you are self-hosting:

    ```bash
    opik configure
    ```
  </Step>
  <Step>
    Wrap your OpenAI client with the `track_openai` function:

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

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

    # Use the client as normal
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "user", "content": "Hello, how are you?",
            },
        ],
    )
    print(completion.choices[0].message.content)
    ```

    All OpenAI calls made using the `client` will now be logged to Opik. You can combine
    this with the `@track` decorator to log the traces for each step of your agent.

  </Step>
</Steps>

<Steps>
  <Step>
    Install the Opik TypeScript SDK:

    ```bash
    npm install opik-openai
    ```
  </Step>
  <Step>
    Configure the Opik TypeScript SDK by running the interactive CLI tool:

    ```bash
    npx opik-ts configure
    ```

    This will detect your project setup, install required dependencies, and help you configure environment variables.
  </Step>
  <Step>
    Wrap your OpenAI client with the `trackOpenAI` function:

    ```typescript
    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();
    ```

    All OpenAI calls made using the `trackedOpenAI` will now be logged to Opik.

  </Step>
</Steps>

<Steps>
  <Step>
    Install the Opik SDK:

    ```bash
    pip install opik
    ```
  </Step>
  <Step>
    Configure the Opik SDK by running the `opik configure` command in your terminal:

    ```bash
    opik configure
    ```
  </Step>
  <Step>
    Track your LangGraph graph with `track_langgraph`:

    ```python
    from opik.integrations.langchain import OpikTracer, track_langgraph

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

    # Create OpikTracer and track the graph once
    # The graph visualization is automatically extracted by track_langgraph
    opik_tracer = OpikTracer()
    app = track_langgraph(app, opik_tracer)

    # Now all invocations are automatically tracked!
    result = app.invoke({"messages": [HumanMessage(content = "How to use LangGraph ?")]})
    ```

    All LangGraph calls will now be logged to Opik. No need to pass callbacks on every invocation!
  </Step>
</Steps>

<Steps>
  <Step title="Install the Opik skill">
    ```bash
    npx skills add comet-ml/opik-skills
    ```
  </Step>
  <Step title="Run the integration">
    Once the skill is installed, you can integrate with Opik using the following prompt:
    ```
    Instrument my agent with Opik using the /instrument command.
    ```
  </Step>
</Steps>

<CardGroup cols={3}>
  <Card title="LangChain" href="/integrations/langchain" icon={} iconPosition="left"/>
  <Card title="LlamaIndex" href="/integrations/llama_index" icon={} iconPosition="left"/>
  <Card title="Anthropic" href="/integrations/anthropic" icon={} iconPosition="left"/>
  <Card title="AWS Bedrock" href="/integrations/bedrock" icon={} iconPosition="left"/>
  <Card title="Google Gemini" href="/integrations/gemini" icon={} iconPosition="left"/>
  <Card title="CrewAI" href="/integrations/crewai" icon={} iconPosition="left"/>
</CardGroup>

**[View all 30+ integrations →](/integrations/overview)**