> ## Documentation Index
> Fetch the complete documentation index at: https://braintrust.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Cohere

> Trace Cohere SDK calls in Braintrust to debug prompts, evaluate models, and monitor production usage

If you are a coding agent, prefer the Braintrust [`bt` CLI](/docs/reference/cli/quickstart) for repeatable, scriptable work: running evals, instrumenting code, querying logs, syncing data, managing functions, and configuring coding agents. Use the MCP server for reasoning over Braintrust data in conversation, and for capabilities the CLI doesn't cover, such as monitor views, alerts, and authoring evaluators, preprocessors, and facets.

[Cohere](https://cohere.com/) provides chat, embeddings, reranking, and audio transcription models. Braintrust traces Cohere SDK calls, including streaming chat and tool calls.

<View title="TypeScript" icon="https://img.logo.dev/typescriptlang.org?token=pk_BdcHD9e5SCW3j1rnJkNyMQ">
  <h2 id="setup-typescript">
    Setup
  </h2>

  Install the Braintrust and `cohere-ai` packages, then set your API keys. Requires `cohere-ai` v7.0.0 or later, including both the v7 request shape and the current v8 SDK.

  <Steps>
    <Step title="Install packages">
      <CodeGroup>
        ```bash pnpm theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
        pnpm add braintrust cohere-ai
        ```

        ```bash npm theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
        npm install braintrust cohere-ai
        ```
      </CodeGroup>
    </Step>

    <Step title="Set environment variables">
      ```bash title=".env" theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
      BRAINTRUST_API_KEY=<your-braintrust-api-key>
      COHERE_API_KEY=<your-cohere-api-key>

      # For organizations on the EU data plane, use https://api-eu.braintrust.dev
      # For self-hosted deployments, use your data plane URL
      # BRAINTRUST_API_URL=<your-braintrust-api-url>
      ```
    </Step>
  </Steps>

  <h2 id="auto-instrumentation-typescript">
    Auto-instrumentation
  </h2>

  To trace Cohere SDK calls without modifying your application code, initialize Braintrust normally, then run your app with Braintrust's import hook to patch the Cohere SDK at runtime.

  <Steps>
    <Step title="Initialize Braintrust and call Cohere">
      <CodeGroup>
        ```javascript title="trace-cohere-auto.js" theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
        import { initLogger } from "braintrust";
        import { CohereClientV2 } from "cohere-ai";

        initLogger({
          projectName: "cohere-example",
          apiKey: process.env.BRAINTRUST_API_KEY,
        });

        const client = new CohereClientV2({
          token: process.env.COHERE_API_KEY,
        });

        const response = await client.chat({
          model: "command-a-03-2025",
          messages: [
            {
              role: "user",
              content: "Explain tracing in one sentence.",
            },
          ],
          maxTokens: 64,
          temperature: 0,
        });

        console.log(response.message?.content);
        ```
      </CodeGroup>
    </Step>

    <Step title="Run with the import hook">
      ```bash theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
      node --import braintrust/hook.mjs trace-cohere-auto.js
      ```

      The auto-instrumentation example uses plain JavaScript so `node --import` can run the file directly. The Braintrust APIs work the same in TypeScript projects — compile your TypeScript to JavaScript, then run the compiled file with the import hook.

      <Note>
        If you're using a bundler, see [Trace LLM calls](/docs/instrument/trace-llm-calls#auto-instrumentation) for plugin and loader setup.
      </Note>
    </Step>
  </Steps>

  <h2 id="manual-instrumentation-typescript">
    Manual instrumentation
  </h2>

  To trace Cohere clients manually, wrap them yourself with `wrapCohere()`. Use this when you want to instrument specific clients individually rather than all of them globally.

  <CodeGroup>
    ```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
    import { initLogger, wrapCohere } from "braintrust";
    import { CohereClientV2 } from "cohere-ai";

    initLogger({
      projectName: "cohere-example",
      apiKey: process.env.BRAINTRUST_API_KEY,
    });

    const client = wrapCohere(
      new CohereClientV2({
        token: process.env.COHERE_API_KEY,
      }),
    );

    const response = await client.chat({
      model: "command-a-03-2025",
      messages: [
        {
          role: "user",
          content: "Explain tracing in one sentence.",
        },
      ],
      maxTokens: 64,
      temperature: 0,
    });

    console.log(response.message?.content);
    ```
  </CodeGroup>

  <h2 id="what-traced-typescript">
    What Braintrust traces
  </h2>

  Braintrust patches the `cohere-ai` SDK and creates an LLM-typed span per call:

  * Chat completion spans (`cohere.chat` and `cohere.chatStream`), with messages and request parameters as input; chat output (including aggregated tool calls for streaming) and token usage; first-token timing for streaming.
  * Extended thinking content for reasoning models, captured from streaming `cohere.chatStream` responses as structured `thinking` content blocks in the span output.
  * Embedding spans (`cohere.embed`), with input texts and request parameters; output summarized as the first embedding's vector length.
  * Rerank spans (`cohere.rerank`), with query and documents as input; results as a list of `{index, relevance_score}` items.
  * Token usage metrics (prompt, completion, total, plus cached prompt tokens and reasoning tokens when reported).
  * Request metadata (model and selected request parameters) and response metadata (response ID, finish reason, generation ID, response type, and Cohere API version when present).
  * Errors captured on every call.

  <h2 id="resources-typescript">
    Resources
  </h2>

  * [Cohere TypeScript SDK](https://github.com/cohere-ai/cohere-typescript)
  * [Cohere API reference](https://docs.cohere.com/reference/about)
</View>

<View title="Python" icon="https://img.logo.dev/python.org?token=pk_BdcHD9e5SCW3j1rnJkNyMQ">
  <h2 id="setup-python">
    Setup
  </h2>

  Install the Braintrust and Cohere packages, then set your API keys. Requires `cohere` v5.0.0 or later.

  <Steps>
    <Step title="Install packages">
      <CodeGroup>
        ```bash uv theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
        uv add braintrust cohere
        ```

        ```bash pip theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
        pip install braintrust cohere
        ```
      </CodeGroup>
    </Step>

    <Step title="Set environment variables">
      ```bash title=".env" theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
      BRAINTRUST_API_KEY=<your-braintrust-api-key>
      CO_API_KEY=<your-cohere-api-key>

      # For organizations on the EU data plane, use https://api-eu.braintrust.dev
      # For self-hosted deployments, use your data plane URL
      # BRAINTRUST_API_URL=<your-braintrust-api-url>
      ```
    </Step>
  </Steps>

  <h2 id="auto-instrumentation-python">
    Auto-instrumentation
  </h2>

  To trace Cohere SDK calls without modifying your application code, call `braintrust.auto_instrument()` before creating your Cohere client.

  <CodeGroup>
    ```python Python theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
    import os

    import braintrust

    braintrust.auto_instrument()
    braintrust.init_logger(
        api_key=os.environ["BRAINTRUST_API_KEY"],
        project="cohere-example",  # Replace with your project name
    )

    import cohere

    client = cohere.ClientV2(os.environ["CO_API_KEY"])
    response = client.chat(
        model="command-a-03-2025",
        messages=[{"role": "user", "content": "Explain tracing in one sentence."}],
    )

    print(response.message.content[0].text)
    ```
  </CodeGroup>

  <h2 id="manual-instrumentation-python">
    Manual instrumentation
  </h2>

  To trace Cohere clients manually, wrap them yourself with `wrap_cohere()`. Use this when you want to instrument specific clients individually rather than all of them globally.

  <CodeGroup>
    ```python Python theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
    import os

    from braintrust import init_logger
    from braintrust.integrations.cohere import wrap_cohere
    import cohere

    init_logger(
        api_key=os.environ["BRAINTRUST_API_KEY"],
        project="cohere-example",  # Replace with your project name
    )

    client = wrap_cohere(cohere.ClientV2(os.environ["CO_API_KEY"]))
    response = client.chat(
        model="command-a-03-2025",
        messages=[{"role": "user", "content": "Explain tracing in one sentence."}],
    )

    print(response.message.content[0].text)
    ```
  </CodeGroup>

  <h2 id="what-traced-python">
    What Braintrust traces
  </h2>

  Braintrust patches `cohere.Client`, `cohere.AsyncClient`, `cohere.ClientV2`, and `cohere.AsyncClientV2` and creates an LLM-typed span per call:

  * Chat completion spans (`cohere.chat` and `cohere.chat_stream`), with messages and request parameters as input; chat output (including aggregated tool calls for streaming) and token usage; first-token timing for streaming.
  * Tool call spans (`tool: <function_name>`) for each tool call returned by v1 and v2 chat responses (sync and streaming), with the tool arguments as input and `tool_call_id` and `tool_type` as metadata.
  * Embedding spans (`cohere.embed`), with input texts and request parameters; output summarized as embedding count and the first embedding's vector length.
  * Rerank spans (`cohere.rerank`), with query and documents as input; results as a list of `{index, relevance_score}` items (capped at 100).
  * Audio transcription spans (`cohere.audio.transcriptions.create`), with the input audio captured as an attachment and the transcribed text as output. Requires `cohere>=6.1.0`, v1 clients only.
  * Token usage metrics (prompt, completion, total, plus cached prompt tokens when reported).
  * Request metadata (model and selected request parameters) and response metadata (response ID, generation ID, response type, finish reason, and Cohere API version when present).
  * Errors captured on every call.

  <h2 id="resources-python">
    Resources
  </h2>

  * [Cohere Python SDK](https://github.com/cohere-ai/cohere-python)
  * [Cohere API reference](https://docs.cohere.com/reference/about)
</View>