Observability for Mistral AI (Python) with Opik

Mistral AI provides cutting-edge large language models with excellent performance for text generation, reasoning, and specialized tasks like code generation.

This guide explains how to integrate Opik with the Mistral AI Python SDK. By using the track_mistral method provided by Opik, you can easily track and evaluate your Mistral API calls within your Opik projects as Opik will automatically log the input prompt, model used, token usage, and response generated.

Account Setup

Comet provides a hosted version of the Opik platform, simply create an account and grab your API Key.

You can also run the Opik platform locally, see the installation guide for more information.

Getting Started

Installation

First, ensure you have both opik and mistralai packages installed. This integration targets the Mistral Python SDK v1 (from mistralai import Mistral), version 1.3.0 or newer:

$
pip install opik "mistralai>=1.3.0,<2"

Configuring Opik

Configure the Opik Python SDK for your deployment type. See the Python SDK Configuration guide for detailed instructions on:

• CLI configuration: opik configure
• Code configuration: opik.configure()
• Self-hosted vs Cloud vs Enterprise setup
• Configuration files and environment variables

Configuring Mistral AI

You’ll need to set your Mistral AI API key. You can find or create your Mistral API Key in the console:

$
export MISTRAL_API_KEY="YOUR_API_KEY"

Logging LLM calls

In order to log the LLM calls to Opik, you will need to wrap the Mistral client with track_mistral. When making calls with that wrapped client, all calls will be logged to Opik:

1
import os
2
from mistralai import Mistral
3
from opik.integrations.mistral import track_mistral
4
5
os.environ["OPIK_PROJECT_NAME"] = "mistral-integration-demo"
6
7
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
8
mistral_client = track_mistral(client)
9
10
response = mistral_client.chat.complete(
11
    model="mistral-small-latest",
12
    messages=[
13
        {"role": "user", "content": "Write a short two sentence story about Opik."}
14
    ],
15
)
16
17
print(response.choices[0].message.content)

track_mistral also wraps the async and streaming methods — chat.complete_async, chat.stream, and chat.stream_async — so those calls are logged the same way, with streamed responses aggregated into a single span.

Advanced Usage

Using with the @track decorator

If you have multiple steps in your LLM pipeline, you can use the @track decorator to log the traces for each step. If Mistral is called within one of these steps, the LLM call will be associated with that corresponding step:

1
import os
2
from mistralai import Mistral
3
from opik import track
4
from opik.integrations.mistral import track_mistral
5
6
os.environ["OPIK_PROJECT_NAME"] = "mistral-integration-demo"
7
8
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
9
mistral_client = track_mistral(client)
10
11
12
@track
13
def generate_story(prompt):
14
    response = mistral_client.chat.complete(
15
        model="mistral-small-latest",
16
        messages=[{"role": "user", "content": prompt}],
17
    )
18
    return response.choices[0].message.content
19
20
21
@track
22
def generate_topic():
23
    prompt = "Generate a topic for a story about Opik."
24
    response = mistral_client.chat.complete(
25
        model="mistral-small-latest",
26
        messages=[{"role": "user", "content": prompt}],
27
    )
28
    return response.choices[0].message.content
29
30
31
@track
32
def generate_opik_story():
33
    topic = generate_topic()
34
    story = generate_story(topic)
35
    return story
36
37
38
generate_opik_story()

The trace can now be viewed in the UI with hierarchical spans showing the relationship between different steps.

Streaming

Streamed responses are tracked as well — the chunks are aggregated into a single span with the full output and token usage:

1
stream = mistral_client.chat.stream(
2
    model="mistral-small-latest",
3
    messages=[{"role": "user", "content": "Tell me a fact about space."}],
4
)
5
6
for event in stream:
7
    print(event.data.choices[0].delta.content, end="")

Structured output

chat.parse() (and its async / streaming variants) is tracked too. It delegates to complete()/stream() internally, so the call is logged as a single chat_completion_create / chat_completion_stream span with the structured JSON in the output:

1
from pydantic import BaseModel
2
3
4
class Person(BaseModel):
5
    name: str
6
    age: int
7
8
9
response = mistral_client.chat.parse(
10
    model="mistral-small-latest",
11
    messages=[{"role": "user", "content": "Extract: John is 30 years old."}],
12
    response_format=Person,
13
)
14
15
print(response.choices[0].message.parsed)

Setting the provider name

By default the provider recorded on each LLM span is mistral, which Opik recognizes for cost tracking. You can override it by passing provider to track_mistral:

1
from opik import LLMProvider
2
from opik.integrations.mistral import track_mistral
3
4
# Accepts any string, or the opik.LLMProvider enum
5
mistral_client = track_mistral(client, provider=LLMProvider.MISTRALAI)

Cost Tracking

The track_mistral integration automatically logs token usage and estimated cost for each traced LLM call, based on the model and provider.

Cost information is automatically captured and displayed in the Opik UI, including:

• Cost per trace
• Total cost aggregated at the project level

Supported Methods

track_mistral logs calls to the following methods of the Mistral client:

• chat.complete() and chat.complete_async()
• chat.stream() and chat.stream_async()
• chat.parse() and chat.parse_async() (structured output)
• chat.parse_stream() and chat.parse_stream_async()

Using Mistral AI via LiteLLM

If you prefer to route Mistral calls through LiteLLM — for example to use the same code across multiple providers — you can use the LiteLLM integration instead of track_mistral.

To track Mistral calls made through LiteLLM, create the OpikLogger callback and add it to LiteLLM:

1
from litellm.integrations.opik.opik import OpikLogger
2
import litellm
3
4
opik_logger = OpikLogger()
5
litellm.callbacks = [opik_logger]
6
7
response = litellm.completion(
8
    model="mistral/mistral-large-2407",
9
    messages=[
10
        {"role": "user", "content": "Why is tracking and evaluation of LLMs important?"}
11
    ]
12
)

If you are using LiteLLM within a function tracked with the @track decorator, pass the current_span_data as metadata to the litellm.completion call:

1
from opik import track, opik_context
2
import litellm
3
4
@track
5
def generate_story(prompt):
6
    response = litellm.completion(
7
        model="mistral/mistral-large-2407",
8
        messages=[{"role": "user", "content": prompt}],
9
        metadata={
10
            "opik": {
11
                "current_span_data": opik_context.get_current_span_data(),
12
            },
13
        },
14
    )
15
    return response.choices[0].message.content