Shadowgraph
TrendingBuzzAbout
Sign in

mistralai/client-python

Python client library for Mistral AI platform

Python

772

415 commits

updated Oct 6, 2026

See the code

README

Mistral Python Client

Migrating from v1

If you are upgrading from v1 to v2, check the migration guide for details on breaking changes and how to update your code.

API Key Setup

Before you begin, you will need a Mistral AI API key.

  1. Get your own Mistral API Key: https://docs.mistral.ai/#api-access
  2. Set your Mistral API Key as an environment variable. You only need to do this once.
# set Mistral API Key (using zsh for example)
$ echo 'export MISTRAL_API_KEY=[your_key_here]' >> ~/.zshenv

# reload the environment (or just quit and open a new terminal)
$ source ~/.zshenv

Service-account token

Workloads with a mounted service-account token can set MISTRAL_SA_TOKEN_PATH instead. The file is re-read on every request, so rotation is picked up. Credentials resolve in this order:

  1. an Authorization header passed per request via http_headers
  2. Mistral(api_key=...), which also accepts a callable
  3. the token at MISTRAL_SA_TOKEN_PATH
  4. MISTRAL_API_KEY

An unreadable or empty token file raises ServiceAccountTokenError.

Summary

Mistral AI API: Our Chat Completion and Embeddings APIs specification. Create your account on La Plateforme to get access and read the docs to learn how to use it.

Table of Contents

SDK Installation

[!NOTE] Python version upgrade policy

Once a Python version reaches its official end of life date, a 3-month grace period is provided for users to upgrade. Following this grace period, the minimum python version supported in the SDK will be updated.

The SDK can be installed with uv, pip, or poetry package managers.

uv

uv is a fast Python package installer and resolver, designed as a drop-in replacement for pip and pip-tools. It's recommended for its speed and modern Python tooling capabilities.

uv add mistralai

PIP

PIP is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

pip install mistralai

Poetry

Poetry is a modern tool that simplifies dependency management and package publishing by using a single pyproject.toml file to handle project metadata and dependencies.

poetry add mistralai

Shell and script usage with uv

You can use this SDK in a Python shell with uv and the uvx command that comes with it like so:

uvx --from mistralai python

It's also possible to write a standalone Python script without needing to set up a whole project like so:

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "mistralai",
# ]
# ///

from mistralai.client import Mistral

sdk = Mistral(
  # SDK arguments
)

# Rest of script here...

Once that is saved to a file, you can run it with uv run script.py where script.py can be replaced with the actual file name.

Agents extra dependencies

When using the agents related feature it is required to add the agents extra dependencies. This can be added when installing the package:

pip install "mistralai[agents]"

Note: These features require Python 3.10+ (the SDK minimum).

Additional packages

Additional mistralai-* packages (e.g. mistralai-workflows) can be installed separately and are available under the mistralai namespace:

pip install mistralai-workflows

SDK Example Usage

Create Chat Completions

This example shows how to create chat completions.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.chat.complete(model="mistral-large-latest", messages=[
        {
            "role": "user",
            "content": "Who is the best French painter? Answer in one short sentence.",
        },
    ], stream=False, response_format={
        "type": "text",
    })

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.chat.complete_async(model="mistral-large-latest", messages=[
            {
                "role": "user",
                "content": "Who is the best French painter? Answer in one short sentence.",
            },
        ], stream=False, response_format={
            "type": "text",
        })

        # Handle response
        print(res)

asyncio.run(main())

Upload a file

This example shows how to upload a file.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.files.upload(file={
        "file_name": "example.file",
        "content": open("example.file", "rb"),
    }, visibility="workspace")

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.files.upload_async(file={
            "file_name": "example.file",
            "content": open("example.file", "rb"),
        }, visibility="workspace")

        # Handle response
        print(res)

asyncio.run(main())

Create Agents Completions

This example shows how to create agents completions.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.agents.complete(messages=[
        {
            "role": "user",
            "content": "Who is the best French painter? Answer in one short sentence.",
        },
    ], agent_id="<id>", stream=False, response_format={
        "type": "text",
    })

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.agents.complete_async(messages=[
            {
                "role": "user",
                "content": "Who is the best French painter? Answer in one short sentence.",
            },
        ], agent_id="<id>", stream=False, response_format={
            "type": "text",
        })

        # Handle response
        print(res)

asyncio.run(main())

Create Embedding Request

This example shows how to create embedding request.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.embeddings.create(model="mistral-embed", inputs=[
        "Embed this sentence.",
        "As well as this one.",
    ])

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.embeddings.create_async(model="mistral-embed", inputs=[
            "Embed this sentence.",
            "As well as this one.",
        ])

        # Handle response
        print(res)

asyncio.run(main())

More examples

You can run the examples in the examples/ directory using uv run.

Providers' SDKs Example Usage

Azure AI

Prerequisites

Before you begin, ensure you have AZURE_ENDPOINT and an AZURE_API_KEY. To obtain these, you will need to deploy Mistral on Azure AI. See instructions for deploying Mistral on Azure AI here.

Step 1: Install

pip install mistralai

Step 2: Example Usage

Here's a basic example to get you started. You can also run the example in the examples directory.

import os
from mistralai.azure.client import MistralAzure

# The SDK automatically injects api-version as a query parameter
client = MistralAzure(
    api_key=os.environ["AZURE_API_KEY"],
    server_url=os.environ["AZURE_ENDPOINT"],
    api_version="2024-05-01-preview",  # Optional, this is the default
)

res = client.chat.complete(
    model=os.environ["AZURE_MODEL"],
    messages=[
        {
            "role": "user",
            "content": "Hello there!",
        }
    ],
)
print(res.choices[0].message.content)

Google Cloud

Prerequisites

Before you begin, you will need to create a Google Cloud project and enable the Mistral API. To do this, follow the instructions here.

To run this locally you will also need to ensure you are authenticated with Google Cloud. You can do this by running

gcloud auth application-default login

Step 1: Install

pip install mistralai
# For GCP authentication support (required):
pip install "mistralai[gcp]"

Step 2: Example Usage

Here's a basic example to get you started. You can also run the example in the examples directory.

The SDK automatically:

  • Detects credentials via google.auth.default()
  • Auto-refreshes tokens when they expire
  • Builds the Vertex AI URL from project_id and region
import os
from mistralai.gcp.client import MistralGCP

# The SDK auto-detects credentials and builds the Vertex AI URL
client = MistralGCP(
    project_id=os.environ.get("GCP_PROJECT_ID"),  # Optional: auto-detected from credentials
    region="us-central1",  # Default: europe-west4
)

res = client.chat.complete(
    model="mistral-small-2503",
    messages=[
        {
            "role": "user",
            "content": "Hello there!",
        }
    ],
)
print(res.choices[0].message.content)

Available Resources and Operations

Available methods

Agents

Audio.Speech

Audio.Transcriptions

  • complete - Create Transcription
  • stream - Create Streaming Transcription (SSE)

Audio.Voices

Batch.Jobs

Beta.Agents

Beta.Connectors

Beta.Conversations

  • start - Create a conversation and append entries to it.
  • list - List all created conversations.
  • get - Retrieve a conversation information.
  • delete - Delete a conversation.
  • append - Append new entries to an existing conversation.
  • get_history - Retrieve all entries in a conversation.
  • get_messages - Retrieve all messages in a conversation.
  • restart - Restart a conversation starting from a given entry.
  • start_stream - Create a conversation and append entries to it.
  • append_stream - Append new entries to an existing conversation.
  • restart_stream - Restart a conversation starting from a given entry.

Beta.Libraries

  • list - List all libraries you have access to.
  • create - Create a new Library.
  • get - Detailed information about a specific Library.
  • delete - Delete a library and all of it's document.
  • update - Update a library.
  • libraries_update_v1 - Update a library. :warning: Deprecated

Beta.Libraries.Accesses

  • list - List all of the access to this library.
  • update_or_create - Create or update an access level.
  • delete - Delete an access level.

Beta.Libraries.Documents

  • list - List documents in a given library.
  • upload - Upload a new document.
  • get - Retrieve the metadata of a specific document.
  • update - Update the metadata of a specific document.
  • libraries_documents_update_v1 - Update the metadata of a specific document. :warning: Deprecated
  • delete - Delete a document.
  • text_content - Retrieve the text content of a specific document.
  • status - Retrieve the processing status of a specific document.
  • get_signed_url - Retrieve the signed URL of a specific document.
  • extracted_text_signed_url - Retrieve the signed URL of text extracted from a given document.
  • reprocess - Reprocess a document.

Beta.Observability.Datasets

Beta.Observability.Datasets.Records

  • fetch - Get the content of a given dataset record
  • delete - Delete a record from a dataset
  • bulk_delete - Delete multiple records from datasets
  • judge - Run Judge on a dataset record based on the given options
  • update_payload - Update a dataset record payload
  • update_properties - Update dataset record properties

Beta.Observability.Evaluations

Beta.Observability.Evaluations.Optimizations

  • list - List optimizations with optional filters
  • get - Get an optimization by id (with its anchored evaluation + project)
  • list_trials - List an optimization's trials with their observation runs (paginated)

Beta.Observability.Evaluations.Projects

  • list - List projects
  • get - Get project by slug

Beta.Observability.Evaluations.Records

  • get - Get a specific record from an evaluation run
  • search - Search records for an evaluation run with content filters

Beta.Observability.Evaluations.Runs

  • search - Search evaluation runs with filters
  • search_all - Search evaluation runs across all evaluations
  • get - Get a specific evaluation run by ID
  • get_statistics - Get statistics for a specific evaluation run
  • compute_statistics - Compute statistics for a specific evaluation run with optional filters

Beta.Observability.Judges

Beta.Observability.Logs

Beta.Observability.Spans

Beta.Observability.Traces

Beta.Prompts

Beta.Rag.IngestionPipelineConfigurations

Beta.Rag.ManagedIndexes

  • create - Create a managed index
  • list - List managed indexes
  • get - Get a managed index
  • update - Update a managed index schema
  • delete - Delete a managed index
  • ingest_documents - Ingest documents into a managed index
  • delete_documents - Delete documents from a managed index
  • search - Search a managed index
  • navigate - Navigate to adjacent chunks
  • read - Read chunks within a span
  • grep - Grep for a pattern within a source
  • get_chunk - Get a single chunk by id

Beta.Rag.SearchIndexes

Beta.ServiceAccounts

Beta.Skills

Beta.Users

Chat

Classifiers

Embeddings

Events

Files

Fim

Models

Ocr

Realtime.Sessions

  • create - Create Client Session

Workflows

Workflows.Deployments

Workflows.Events

Workflows.Executions

Workflows.Metrics

Workflows.Runs

Workflows.Schedules

Server-sent event streaming

Server-sent events are used to stream content from certain operations. These operations will expose the stream as Generator that can be consumed using a simple for loop. The loop will terminate when the server no longer has any events to send and closes the underlying connection.

The stream is also a Context Manager and can be used with the with statement and will close the underlying connection when the context is exited.

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.conversations.start_stream(inputs=[
        {
            "object": "entry",
            "type": "function.result",
            "tool_call_id": "<id>",
            "result": "<value>",
        },
    ], completion_args={
        "response_format": {
            "type": "text",
        },
    })

    with res as event_stream:
        for event in event_stream:
            # handle event
            print(event, flush=True)

Pagination

Some of the endpoints in this SDK support pagination. To use pagination, you make your SDK calls as usual, but the returned response object will have a Next method that can be called to pull down the next group of results. If the return value of Next is None, then there are no more pages to be fetched.

Here's an example of one such pagination call:

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

File uploads

Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.

[!TIP]

For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.libraries.documents.upload(library_id="a02150d9-5ee0-4877-b62c-28b1fcdf3b76", file={
        "file_name": "example.file",
        "content": open("example.file", "rb"),
    })

    # Handle response
    print(res)

Retries

Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

To change the default retry strategy for a single API call, simply provide a RetryConfig object to the call:

from mistralai.client import Mistral
from mistralai.client.utils import BackoffStrategy, RetryConfig
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list(,
        RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

    while res is not None:
        # Handle items

        res = res.next()

If you'd like to override the default retry strategy for all operations that support retries, you can use the retry_config optional parameter when initializing the SDK:

from mistralai.client import Mistral
from mistralai.client.utils import BackoffStrategy, RetryConfig
import os


with Mistral(
    retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Error Handling

MistralError is the base class for all HTTP error responses. It has the following properties:

PropertyTypeDescription
err.messagestrError message
err.status_codeintHTTP response status code eg 404
err.headershttpx.HeadersHTTP response headers
err.bodystrHTTP body. Can be empty string if no body is returned.
err.raw_responsehttpx.ResponseRaw HTTP response
err.dataOptional. Some errors may contain structured data. See Error Classes.

Example

from mistralai.client import Mistral, errors
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:
    res = None
    try:

        res = mistral.beta.service_accounts.create(name="<value>", workspace_id="cf2146d0-158c-4b19-b8b1-ca0c68f41143")

        # Handle response
        print(res)


    except errors.MistralError as e:
        # The base class for HTTP error responses
        print(e.message)
        print(e.status_code)
        print(e.body)
        print(e.headers)
        print(e.raw_response)

        # Depending on the method different errors may be thrown
        if isinstance(e, errors.HTTPValidationError):
            print(e.data.detail)  # Optional[List[models.ValidationError]]

Error Classes

Primary error:

Less common errors (7)

Network errors:

Inherit from MistralError:

  • HTTPValidationError: Validation Error. Status code 422. Applicable to 165 of 278 methods.*
  • ObservabilityError: Bad Request - Invalid request parameters or data. Applicable to 69 of 278 methods.*
  • ResponseValidationError: Type mismatch between the response data and the expected Pydantic model. Provides access to the Pydantic validation error via the cause attribute.

* Check the method documentation to see if the error is applicable.

Server Selection

Select Server by Name

You can override the default server globally by passing a server name to the server: str optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the names associated with the available servers:

NameServerDescription
globalhttps://api.mistral.aiGlobal Production server
euhttps://api.eu.mistral.aiEU Production server
ushttps://api.us.mistral.aiUS Production server

Example

from mistralai.client import Mistral
import os


with Mistral(
    server="global",
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Override Server URL Per-Client

The default server can also be overridden globally by passing a URL to the server_url: str optional parameter when initializing the SDK client instance. For example:

from mistralai.client import Mistral
import os


with Mistral(
    server_url="https://api.mistral.ai",
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Custom HTTP Client

The Python SDK makes API calls using the httpx2 HTTP library. In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance. Depending on whether you are using the sync or async version of the SDK, you can pass an instance of HttpClient or AsyncHttpClient respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls. This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of httpx.Client or httpx.AsyncClient directly.

For example, you could specify a header for every request that this sdk makes as follows:

from mistralai.client import Mistral
import httpx2 as httpx

http_client = httpx.Client(headers={"x-custom-header": "someValue"})
s = Mistral(client=http_client)

or you could wrap the client with your own custom logic:

from mistralai.client import Mistral
from mistralai.client.httpclient import AsyncHttpClient
import httpx2 as httpx

class CustomClient(AsyncHttpClient):
    client: AsyncHttpClient

    def __init__(self, client: AsyncHttpClient):
        self.client = client

    async def send(
        self,
        request: httpx.Request,
        *,
        stream: bool = False,
        auth: Union[
            httpx._types.AuthTypes, httpx._client.UseClientDefault, None
        ] = httpx.USE_CLIENT_DEFAULT,
        follow_redirects: Union[
            bool, httpx._client.UseClientDefault
        ] = httpx.USE_CLIENT_DEFAULT,
    ) -> httpx.Response:
        request.headers["Client-Level-Header"] = "added by client"

        return await self.client.send(
            request, stream=stream, auth=auth, follow_redirects=follow_redirects
        )

    def build_request(
        self,
        method: str,
        url: httpx._types.URLTypes,
        *,
        content: Optional[httpx._types.RequestContent] = None,
        data: Optional[httpx._types.RequestData] = None,
        files: Optional[httpx._types.RequestFiles] = None,
        json: Optional[Any] = None,
        params: Optional[httpx._types.QueryParamTypes] = None,
        headers: Optional[httpx._types.HeaderTypes] = None,
        cookies: Optional[httpx._types.CookieTypes] = None,
        timeout: Union[
            httpx._types.TimeoutTypes, httpx._client.UseClientDefault
        ] = httpx.USE_CLIENT_DEFAULT,
        extensions: Optional[httpx._types.RequestExtensions] = None,
    ) -> httpx.Request:
        return self.client.build_request(
            method,
            url,
            content=content,
            data=data,
            files=files,
            json=json,
            params=params,
            headers=headers,
            cookies=cookies,
            timeout=timeout,
            extensions=extensions,
        )

s = Mistral(async_client=CustomClient(httpx.AsyncClient()))

httpx2

This SDK is generated against httpx2, Pydantic's maintained fork of httpx. The fork keeps the same public API, so everything above applies unchanged - httpx2.Client and httpx2.AsyncClient are what the SDK expects.

Authentication

Per-Client Security Schemes

This SDK supports the following security scheme globally:

NameTypeSchemeEnvironment Variable
api_keyhttpHTTP BearerMISTRAL_API_KEY

To authenticate with the API the api_key parameter must be set when initializing the SDK client instance. For example:

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Per-Operation Security Schemes

Some operations in this SDK require the security scheme to be specified at the request level. For example:

from mistralai.client import Mistral, models


with Mistral() as mistral:

    res = mistral.beta.users.get_identity(security=models.UsersAPIGetIdentitySecurity(

    ))

    # Handle response
    print(res)

Resource Management

The Mistral class implements the context manager protocol and registers a finalizer function to close the underlying sync and async HTTPX clients it uses under the hood. This will close HTTP connections, release memory and free up other resources held by the SDK. In short-lived Python programs and notebooks that make a few SDK method calls, resource management may not be a concern. However, in longer-lived programs, it is beneficial to create a single SDK instance via a context manager and reuse it across the application.

from mistralai.client import Mistral
import os
def main():

    with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:
        # Rest of application here...


# Or when using async:
async def amain():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:
        # Rest of application here...

Debugging

You can setup your SDK to emit debug logs for SDK requests and responses.

You can pass your own logger class directly into your SDK.

from mistralai.client import Mistral
import logging

logging.basicConfig(level=logging.DEBUG)
s = Mistral(debug_logger=logging.getLogger("mistralai.client"))

You can also enable a default debug logger by setting an environment variable MISTRAL_DEBUG to true.

IDE Support

PyCharm

Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

Telemetry & Observability

The SDK can emit OpenTelemetry traces for the API calls it makes (chat, agents, embeddings, OCR, …), following the GenAI semantic conventions. Spans capture the operation, model, token usage, and — unless redacted — the input/output messages and tool calls. Telemetry is opt-in and lives in the mistralai.extra.observability module.

Installation

Install the telemetry extra:

pip install "mistralai[telemetry]"
# or: uv add "mistralai[telemetry]"

Enabling telemetry

Either set an environment variable before creating the client:

export MISTRAL_SDK_TELEMETRY=dedicated   # dedicated | global | false

or configure it in code:

import os
from mistralai.client import Mistral
from mistralai.extra.observability import configure_telemetry

with Mistral(api_key=os.environ["MISTRAL_API_KEY"]) as client:
    # Dedicated mode (default): the SDK creates and owns an OTLP exporter that
    # ships spans to the Mistral telemetry endpoint. Spans are redacted before
    # export.
    configure_telemetry(client)

    client.chat.complete(
        model="mistral-small-latest",
        messages=[{"role": "user", "content": "Hello!"}],
    )

Provider modes

configure_telemetry(client, provider=...) selects where spans go and who owns the export pipeline:

providerWho owns the exporterWhere spans goRedaction
"dedicated" (default)The SDKMistral telemetry endpointApplied automatically
"global"Your applicationYour global OpenTelemetry providerNot applied — you need to wrap your own exporter
a TracerProviderYour applicationThe provider you passNot applied — you need to wrap your own exporter

In global/custom modes your application owns the pipeline, so the redaction argument is ignored (a warning is logged). Wrap your own exporter with RedactingSpanExporter to redact spans there:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from mistralai.extra.observability import RedactingSpanExporter, configure_telemetry

provider = TracerProvider()
provider.add_span_processor(
    BatchSpanProcessor(RedactingSpanExporter(OTLPSpanExporter()))
)
trace.set_tracer_provider(provider)

# SDK spans now flow through your global provider (already redacted above).
configure_telemetry(client, provider="global")

Redaction

In dedicated mode, redaction is on by default. Control it with the redaction argument, which also accepts any of the reusable policies from mistralai.extra.observability:

from mistralai.extra.observability import AttributeRedactionPolicy

configure_telemetry(client)                                        # default policy (regex)
configure_telemetry(client, redaction=AttributeRedactionPolicy())  # very conservative key-oriented policy
configure_telemetry(client, redaction=False)                       # disabled - no redaction
configure_telemetry(                                               # custom callback to control how attributes are redacted
    client,
    redaction=lambda key, value: None if "email" in key else value,
)
PolicyStrategyTrade-off
RegexRedactionPolicy (default, redaction=True)Content-oriented: keeps keys and structure, redacts matched substrings (secret tokens plus PII — emails, card-like sequences, IPv4).Redacts most sensitive data while preserving observability value; may miss free-form PII or secrets not in the pattern set.
AttributeRedactionPolicyKey-oriented: redacts whole values for sensitive keys (explicit set, fragment match, or non-primitive value), then scans kept values for secret token patterns.Very conservative, but erases most prompt/response content.
CallbackRedactionPolicy (redaction=<callable>)Your (key, value) -> value | None masker per attribute; return None to drop the attribute.Full control; you own the logic.

The built-in defaults are exported as constants, so you can extend them instead of replacing them wholesale:

import re

from mistralai.extra.observability import (
    DEFAULT_PII_SECRET_PATTERNS,
    DEFAULT_SENSITIVE_ATTRIBUTE_KEYS,
    AttributeRedactionPolicy,
    RegexRedactionPolicy,
)

# Content-oriented: add a custom secret pattern to the default set.
configure_telemetry(
    client,
    redaction=RegexRedactionPolicy(
        patterns=(*DEFAULT_PII_SECRET_PATTERNS, re.compile(r"\bacme-[a-z0-9]{16}\b")),
    ),
)

# Key-oriented: mask an extra application attribute on top of the defaults.
configure_telemetry(
    client,
    redaction=AttributeRedactionPolicy(
        sensitive_keys=DEFAULT_SENSITIVE_ATTRIBUTE_KEYS | {"app.customer.email"},
    ),
)

Note: the RedactingSpanExporter primitive is reusable by any OpenTelemetry application, independent of the Mistral client.

Environment variables

VariableDescriptionDefault
MISTRAL_SDK_TELEMETRYAuto-enable telemetry: dedicated, global, or false.unset (disabled)
MISTRAL_OTLP_TRACES_ENDPOINTOverride the OTLP traces endpoint used in dedicated mode.https://api.mistral.ai/telemetry/v1/traces
MISTRAL_SDK_DEBUG_TRACINGSet to true for verbose tracing logs.false
MISTRAL_API_KEYUsed as the bearer token for the dedicated-mode exporter.—

Runnable examples live in examples/mistral/observability.

Development

Contributions

While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation. We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.

Significant stargazers

Donatas Remeika

19 followers · starred May 2024

Cédric Le Moigne

61 followers · starred Oct 2025

Patrick Barker

70 followers · starred Feb 2025

Parshva Daftari

61 followers · starred Mar 2025

Similar repos

mistralai/mistral-vibe

Minimal CLI coding agent by Mistral

5,055

same org

meta-llama/llama-api-python

The official Python library for the Llama API

64

openai/openai-python

The official Python library for the OpenAI API

31,753

googleapis/python-genai

Google Gen AI Python SDK provides an interface for developers to integrate Google's generative…

4,006

xai-org/xai-sdk-python

The official Python SDK for the SpaceXAI API

585

googleapis/python-aiplatform

A Python SDK for Vertex AI, a fully managed, end-to-end platform for data science and machine…

907

modelcontextprotocol/python-sdk

The official Python SDK for Model Context Protocol servers and clients

24,499

deepgram/deepgram-python-sdk

Official Python SDK for Deepgram.

469

mistralai/client-python

Python client library for Mistral AI platform

Python

772

415 commits

updated Oct 6, 2026

See the code

README

Mistral Python Client

Migrating from v1

If you are upgrading from v1 to v2, check the migration guide for details on breaking changes and how to update your code.

API Key Setup

Before you begin, you will need a Mistral AI API key.

  1. Get your own Mistral API Key: https://docs.mistral.ai/#api-access
  2. Set your Mistral API Key as an environment variable. You only need to do this once.
# set Mistral API Key (using zsh for example)
$ echo 'export MISTRAL_API_KEY=[your_key_here]' >> ~/.zshenv

# reload the environment (or just quit and open a new terminal)
$ source ~/.zshenv

Service-account token

Workloads with a mounted service-account token can set MISTRAL_SA_TOKEN_PATH instead. The file is re-read on every request, so rotation is picked up. Credentials resolve in this order:

  1. an Authorization header passed per request via http_headers
  2. Mistral(api_key=...), which also accepts a callable
  3. the token at MISTRAL_SA_TOKEN_PATH
  4. MISTRAL_API_KEY

An unreadable or empty token file raises ServiceAccountTokenError.

Summary

Mistral AI API: Our Chat Completion and Embeddings APIs specification. Create your account on La Plateforme to get access and read the docs to learn how to use it.

Table of Contents

SDK Installation

[!NOTE] Python version upgrade policy

Once a Python version reaches its official end of life date, a 3-month grace period is provided for users to upgrade. Following this grace period, the minimum python version supported in the SDK will be updated.

The SDK can be installed with uv, pip, or poetry package managers.

uv

uv is a fast Python package installer and resolver, designed as a drop-in replacement for pip and pip-tools. It's recommended for its speed and modern Python tooling capabilities.

uv add mistralai

PIP

PIP is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

pip install mistralai

Poetry

Poetry is a modern tool that simplifies dependency management and package publishing by using a single pyproject.toml file to handle project metadata and dependencies.

poetry add mistralai

Shell and script usage with uv

You can use this SDK in a Python shell with uv and the uvx command that comes with it like so:

uvx --from mistralai python

It's also possible to write a standalone Python script without needing to set up a whole project like so:

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "mistralai",
# ]
# ///

from mistralai.client import Mistral

sdk = Mistral(
  # SDK arguments
)

# Rest of script here...

Once that is saved to a file, you can run it with uv run script.py where script.py can be replaced with the actual file name.

Agents extra dependencies

When using the agents related feature it is required to add the agents extra dependencies. This can be added when installing the package:

pip install "mistralai[agents]"

Note: These features require Python 3.10+ (the SDK minimum).

Additional packages

Additional mistralai-* packages (e.g. mistralai-workflows) can be installed separately and are available under the mistralai namespace:

pip install mistralai-workflows

SDK Example Usage

Create Chat Completions

This example shows how to create chat completions.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.chat.complete(model="mistral-large-latest", messages=[
        {
            "role": "user",
            "content": "Who is the best French painter? Answer in one short sentence.",
        },
    ], stream=False, response_format={
        "type": "text",
    })

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.chat.complete_async(model="mistral-large-latest", messages=[
            {
                "role": "user",
                "content": "Who is the best French painter? Answer in one short sentence.",
            },
        ], stream=False, response_format={
            "type": "text",
        })

        # Handle response
        print(res)

asyncio.run(main())

Upload a file

This example shows how to upload a file.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.files.upload(file={
        "file_name": "example.file",
        "content": open("example.file", "rb"),
    }, visibility="workspace")

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.files.upload_async(file={
            "file_name": "example.file",
            "content": open("example.file", "rb"),
        }, visibility="workspace")

        # Handle response
        print(res)

asyncio.run(main())

Create Agents Completions

This example shows how to create agents completions.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.agents.complete(messages=[
        {
            "role": "user",
            "content": "Who is the best French painter? Answer in one short sentence.",
        },
    ], agent_id="<id>", stream=False, response_format={
        "type": "text",
    })

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.agents.complete_async(messages=[
            {
                "role": "user",
                "content": "Who is the best French painter? Answer in one short sentence.",
            },
        ], agent_id="<id>", stream=False, response_format={
            "type": "text",
        })

        # Handle response
        print(res)

asyncio.run(main())

Create Embedding Request

This example shows how to create embedding request.

# Synchronous Example
from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.embeddings.create(model="mistral-embed", inputs=[
        "Embed this sentence.",
        "As well as this one.",
    ])

    # Handle response
    print(res)

The same SDK client can also be used to make asynchronous requests by importing asyncio.

# Asynchronous Example
import asyncio
from mistralai.client import Mistral
import os

async def main():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:

        res = await mistral.embeddings.create_async(model="mistral-embed", inputs=[
            "Embed this sentence.",
            "As well as this one.",
        ])

        # Handle response
        print(res)

asyncio.run(main())

More examples

You can run the examples in the examples/ directory using uv run.

Providers' SDKs Example Usage

Azure AI

Prerequisites

Before you begin, ensure you have AZURE_ENDPOINT and an AZURE_API_KEY. To obtain these, you will need to deploy Mistral on Azure AI. See instructions for deploying Mistral on Azure AI here.

Step 1: Install

pip install mistralai

Step 2: Example Usage

Here's a basic example to get you started. You can also run the example in the examples directory.

import os
from mistralai.azure.client import MistralAzure

# The SDK automatically injects api-version as a query parameter
client = MistralAzure(
    api_key=os.environ["AZURE_API_KEY"],
    server_url=os.environ["AZURE_ENDPOINT"],
    api_version="2024-05-01-preview",  # Optional, this is the default
)

res = client.chat.complete(
    model=os.environ["AZURE_MODEL"],
    messages=[
        {
            "role": "user",
            "content": "Hello there!",
        }
    ],
)
print(res.choices[0].message.content)

Google Cloud

Prerequisites

Before you begin, you will need to create a Google Cloud project and enable the Mistral API. To do this, follow the instructions here.

To run this locally you will also need to ensure you are authenticated with Google Cloud. You can do this by running

gcloud auth application-default login

Step 1: Install

pip install mistralai
# For GCP authentication support (required):
pip install "mistralai[gcp]"

Step 2: Example Usage

Here's a basic example to get you started. You can also run the example in the examples directory.

The SDK automatically:

  • Detects credentials via google.auth.default()
  • Auto-refreshes tokens when they expire
  • Builds the Vertex AI URL from project_id and region
import os
from mistralai.gcp.client import MistralGCP

# The SDK auto-detects credentials and builds the Vertex AI URL
client = MistralGCP(
    project_id=os.environ.get("GCP_PROJECT_ID"),  # Optional: auto-detected from credentials
    region="us-central1",  # Default: europe-west4
)

res = client.chat.complete(
    model="mistral-small-2503",
    messages=[
        {
            "role": "user",
            "content": "Hello there!",
        }
    ],
)
print(res.choices[0].message.content)

Available Resources and Operations

Available methods

Agents

Audio.Speech

Audio.Transcriptions

  • complete - Create Transcription
  • stream - Create Streaming Transcription (SSE)

Audio.Voices

Batch.Jobs

Beta.Agents

Beta.Connectors

Beta.Conversations

  • start - Create a conversation and append entries to it.
  • list - List all created conversations.
  • get - Retrieve a conversation information.
  • delete - Delete a conversation.
  • append - Append new entries to an existing conversation.
  • get_history - Retrieve all entries in a conversation.
  • get_messages - Retrieve all messages in a conversation.
  • restart - Restart a conversation starting from a given entry.
  • start_stream - Create a conversation and append entries to it.
  • append_stream - Append new entries to an existing conversation.
  • restart_stream - Restart a conversation starting from a given entry.

Beta.Libraries

  • list - List all libraries you have access to.
  • create - Create a new Library.
  • get - Detailed information about a specific Library.
  • delete - Delete a library and all of it's document.
  • update - Update a library.
  • libraries_update_v1 - Update a library. :warning: Deprecated

Beta.Libraries.Accesses

  • list - List all of the access to this library.
  • update_or_create - Create or update an access level.
  • delete - Delete an access level.

Beta.Libraries.Documents

  • list - List documents in a given library.
  • upload - Upload a new document.
  • get - Retrieve the metadata of a specific document.
  • update - Update the metadata of a specific document.
  • libraries_documents_update_v1 - Update the metadata of a specific document. :warning: Deprecated
  • delete - Delete a document.
  • text_content - Retrieve the text content of a specific document.
  • status - Retrieve the processing status of a specific document.
  • get_signed_url - Retrieve the signed URL of a specific document.
  • extracted_text_signed_url - Retrieve the signed URL of text extracted from a given document.
  • reprocess - Reprocess a document.

Beta.Observability.Datasets

Beta.Observability.Datasets.Records

  • fetch - Get the content of a given dataset record
  • delete - Delete a record from a dataset
  • bulk_delete - Delete multiple records from datasets
  • judge - Run Judge on a dataset record based on the given options
  • update_payload - Update a dataset record payload
  • update_properties - Update dataset record properties

Beta.Observability.Evaluations

Beta.Observability.Evaluations.Optimizations

  • list - List optimizations with optional filters
  • get - Get an optimization by id (with its anchored evaluation + project)
  • list_trials - List an optimization's trials with their observation runs (paginated)

Beta.Observability.Evaluations.Projects

  • list - List projects
  • get - Get project by slug

Beta.Observability.Evaluations.Records

  • get - Get a specific record from an evaluation run
  • search - Search records for an evaluation run with content filters

Beta.Observability.Evaluations.Runs

  • search - Search evaluation runs with filters
  • search_all - Search evaluation runs across all evaluations
  • get - Get a specific evaluation run by ID
  • get_statistics - Get statistics for a specific evaluation run
  • compute_statistics - Compute statistics for a specific evaluation run with optional filters

Beta.Observability.Judges

Beta.Observability.Logs

Beta.Observability.Spans

Beta.Observability.Traces

Beta.Prompts

Beta.Rag.IngestionPipelineConfigurations

Beta.Rag.ManagedIndexes

  • create - Create a managed index
  • list - List managed indexes
  • get - Get a managed index
  • update - Update a managed index schema
  • delete - Delete a managed index
  • ingest_documents - Ingest documents into a managed index
  • delete_documents - Delete documents from a managed index
  • search - Search a managed index
  • navigate - Navigate to adjacent chunks
  • read - Read chunks within a span
  • grep - Grep for a pattern within a source
  • get_chunk - Get a single chunk by id

Beta.Rag.SearchIndexes

Beta.ServiceAccounts

Beta.Skills

Beta.Users

Chat

Classifiers

Embeddings

Events

Files

Fim

Models

Ocr

Realtime.Sessions

  • create - Create Client Session

Workflows

Workflows.Deployments

Workflows.Events

Workflows.Executions

Workflows.Metrics

Workflows.Runs

Workflows.Schedules

Server-sent event streaming

Server-sent events are used to stream content from certain operations. These operations will expose the stream as Generator that can be consumed using a simple for loop. The loop will terminate when the server no longer has any events to send and closes the underlying connection.

The stream is also a Context Manager and can be used with the with statement and will close the underlying connection when the context is exited.

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.conversations.start_stream(inputs=[
        {
            "object": "entry",
            "type": "function.result",
            "tool_call_id": "<id>",
            "result": "<value>",
        },
    ], completion_args={
        "response_format": {
            "type": "text",
        },
    })

    with res as event_stream:
        for event in event_stream:
            # handle event
            print(event, flush=True)

Pagination

Some of the endpoints in this SDK support pagination. To use pagination, you make your SDK calls as usual, but the returned response object will have a Next method that can be called to pull down the next group of results. If the return value of Next is None, then there are no more pages to be fetched.

Here's an example of one such pagination call:

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

File uploads

Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.

[!TIP]

For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.libraries.documents.upload(library_id="a02150d9-5ee0-4877-b62c-28b1fcdf3b76", file={
        "file_name": "example.file",
        "content": open("example.file", "rb"),
    })

    # Handle response
    print(res)

Retries

Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

To change the default retry strategy for a single API call, simply provide a RetryConfig object to the call:

from mistralai.client import Mistral
from mistralai.client.utils import BackoffStrategy, RetryConfig
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list(,
        RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

    while res is not None:
        # Handle items

        res = res.next()

If you'd like to override the default retry strategy for all operations that support retries, you can use the retry_config optional parameter when initializing the SDK:

from mistralai.client import Mistral
from mistralai.client.utils import BackoffStrategy, RetryConfig
import os


with Mistral(
    retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Error Handling

MistralError is the base class for all HTTP error responses. It has the following properties:

PropertyTypeDescription
err.messagestrError message
err.status_codeintHTTP response status code eg 404
err.headershttpx.HeadersHTTP response headers
err.bodystrHTTP body. Can be empty string if no body is returned.
err.raw_responsehttpx.ResponseRaw HTTP response
err.dataOptional. Some errors may contain structured data. See Error Classes.

Example

from mistralai.client import Mistral, errors
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:
    res = None
    try:

        res = mistral.beta.service_accounts.create(name="<value>", workspace_id="cf2146d0-158c-4b19-b8b1-ca0c68f41143")

        # Handle response
        print(res)


    except errors.MistralError as e:
        # The base class for HTTP error responses
        print(e.message)
        print(e.status_code)
        print(e.body)
        print(e.headers)
        print(e.raw_response)

        # Depending on the method different errors may be thrown
        if isinstance(e, errors.HTTPValidationError):
            print(e.data.detail)  # Optional[List[models.ValidationError]]

Error Classes

Primary error:

Less common errors (7)

Network errors:

Inherit from MistralError:

  • HTTPValidationError: Validation Error. Status code 422. Applicable to 165 of 278 methods.*
  • ObservabilityError: Bad Request - Invalid request parameters or data. Applicable to 69 of 278 methods.*
  • ResponseValidationError: Type mismatch between the response data and the expected Pydantic model. Provides access to the Pydantic validation error via the cause attribute.

* Check the method documentation to see if the error is applicable.

Server Selection

Select Server by Name

You can override the default server globally by passing a server name to the server: str optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the names associated with the available servers:

NameServerDescription
globalhttps://api.mistral.aiGlobal Production server
euhttps://api.eu.mistral.aiEU Production server
ushttps://api.us.mistral.aiUS Production server

Example

from mistralai.client import Mistral
import os


with Mistral(
    server="global",
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Override Server URL Per-Client

The default server can also be overridden globally by passing a URL to the server_url: str optional parameter when initializing the SDK client instance. For example:

from mistralai.client import Mistral
import os


with Mistral(
    server_url="https://api.mistral.ai",
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Custom HTTP Client

The Python SDK makes API calls using the httpx2 HTTP library. In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance. Depending on whether you are using the sync or async version of the SDK, you can pass an instance of HttpClient or AsyncHttpClient respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls. This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of httpx.Client or httpx.AsyncClient directly.

For example, you could specify a header for every request that this sdk makes as follows:

from mistralai.client import Mistral
import httpx2 as httpx

http_client = httpx.Client(headers={"x-custom-header": "someValue"})
s = Mistral(client=http_client)

or you could wrap the client with your own custom logic:

from mistralai.client import Mistral
from mistralai.client.httpclient import AsyncHttpClient
import httpx2 as httpx

class CustomClient(AsyncHttpClient):
    client: AsyncHttpClient

    def __init__(self, client: AsyncHttpClient):
        self.client = client

    async def send(
        self,
        request: httpx.Request,
        *,
        stream: bool = False,
        auth: Union[
            httpx._types.AuthTypes, httpx._client.UseClientDefault, None
        ] = httpx.USE_CLIENT_DEFAULT,
        follow_redirects: Union[
            bool, httpx._client.UseClientDefault
        ] = httpx.USE_CLIENT_DEFAULT,
    ) -> httpx.Response:
        request.headers["Client-Level-Header"] = "added by client"

        return await self.client.send(
            request, stream=stream, auth=auth, follow_redirects=follow_redirects
        )

    def build_request(
        self,
        method: str,
        url: httpx._types.URLTypes,
        *,
        content: Optional[httpx._types.RequestContent] = None,
        data: Optional[httpx._types.RequestData] = None,
        files: Optional[httpx._types.RequestFiles] = None,
        json: Optional[Any] = None,
        params: Optional[httpx._types.QueryParamTypes] = None,
        headers: Optional[httpx._types.HeaderTypes] = None,
        cookies: Optional[httpx._types.CookieTypes] = None,
        timeout: Union[
            httpx._types.TimeoutTypes, httpx._client.UseClientDefault
        ] = httpx.USE_CLIENT_DEFAULT,
        extensions: Optional[httpx._types.RequestExtensions] = None,
    ) -> httpx.Request:
        return self.client.build_request(
            method,
            url,
            content=content,
            data=data,
            files=files,
            json=json,
            params=params,
            headers=headers,
            cookies=cookies,
            timeout=timeout,
            extensions=extensions,
        )

s = Mistral(async_client=CustomClient(httpx.AsyncClient()))

httpx2

This SDK is generated against httpx2, Pydantic's maintained fork of httpx. The fork keeps the same public API, so everything above applies unchanged - httpx2.Client and httpx2.AsyncClient are what the SDK expects.

Authentication

Per-Client Security Schemes

This SDK supports the following security scheme globally:

NameTypeSchemeEnvironment Variable
api_keyhttpHTTP BearerMISTRAL_API_KEY

To authenticate with the API the api_key parameter must be set when initializing the SDK client instance. For example:

from mistralai.client import Mistral
import os


with Mistral(
    api_key=os.getenv("MISTRAL_API_KEY", ""),
) as mistral:

    res = mistral.beta.prompts.list()

    while res is not None:
        # Handle items

        res = res.next()

Per-Operation Security Schemes

Some operations in this SDK require the security scheme to be specified at the request level. For example:

from mistralai.client import Mistral, models


with Mistral() as mistral:

    res = mistral.beta.users.get_identity(security=models.UsersAPIGetIdentitySecurity(

    ))

    # Handle response
    print(res)

Resource Management

The Mistral class implements the context manager protocol and registers a finalizer function to close the underlying sync and async HTTPX clients it uses under the hood. This will close HTTP connections, release memory and free up other resources held by the SDK. In short-lived Python programs and notebooks that make a few SDK method calls, resource management may not be a concern. However, in longer-lived programs, it is beneficial to create a single SDK instance via a context manager and reuse it across the application.

from mistralai.client import Mistral
import os
def main():

    with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:
        # Rest of application here...


# Or when using async:
async def amain():

    async with Mistral(
        api_key=os.getenv("MISTRAL_API_KEY", ""),
    ) as mistral:
        # Rest of application here...

Debugging

You can setup your SDK to emit debug logs for SDK requests and responses.

You can pass your own logger class directly into your SDK.

from mistralai.client import Mistral
import logging

logging.basicConfig(level=logging.DEBUG)
s = Mistral(debug_logger=logging.getLogger("mistralai.client"))

You can also enable a default debug logger by setting an environment variable MISTRAL_DEBUG to true.

IDE Support

PyCharm

Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

Telemetry & Observability

The SDK can emit OpenTelemetry traces for the API calls it makes (chat, agents, embeddings, OCR, …), following the GenAI semantic conventions. Spans capture the operation, model, token usage, and — unless redacted — the input/output messages and tool calls. Telemetry is opt-in and lives in the mistralai.extra.observability module.

Installation

Install the telemetry extra:

pip install "mistralai[telemetry]"
# or: uv add "mistralai[telemetry]"

Enabling telemetry

Either set an environment variable before creating the client:

export MISTRAL_SDK_TELEMETRY=dedicated   # dedicated | global | false

or configure it in code:

import os
from mistralai.client import Mistral
from mistralai.extra.observability import configure_telemetry

with Mistral(api_key=os.environ["MISTRAL_API_KEY"]) as client:
    # Dedicated mode (default): the SDK creates and owns an OTLP exporter that
    # ships spans to the Mistral telemetry endpoint. Spans are redacted before
    # export.
    configure_telemetry(client)

    client.chat.complete(
        model="mistral-small-latest",
        messages=[{"role": "user", "content": "Hello!"}],
    )

Provider modes

configure_telemetry(client, provider=...) selects where spans go and who owns the export pipeline:

providerWho owns the exporterWhere spans goRedaction
"dedicated" (default)The SDKMistral telemetry endpointApplied automatically
"global"Your applicationYour global OpenTelemetry providerNot applied — you need to wrap your own exporter
a TracerProviderYour applicationThe provider you passNot applied — you need to wrap your own exporter

In global/custom modes your application owns the pipeline, so the redaction argument is ignored (a warning is logged). Wrap your own exporter with RedactingSpanExporter to redact spans there:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from mistralai.extra.observability import RedactingSpanExporter, configure_telemetry

provider = TracerProvider()
provider.add_span_processor(
    BatchSpanProcessor(RedactingSpanExporter(OTLPSpanExporter()))
)
trace.set_tracer_provider(provider)

# SDK spans now flow through your global provider (already redacted above).
configure_telemetry(client, provider="global")

Redaction

In dedicated mode, redaction is on by default. Control it with the redaction argument, which also accepts any of the reusable policies from mistralai.extra.observability:

from mistralai.extra.observability import AttributeRedactionPolicy

configure_telemetry(client)                                        # default policy (regex)
configure_telemetry(client, redaction=AttributeRedactionPolicy())  # very conservative key-oriented policy
configure_telemetry(client, redaction=False)                       # disabled - no redaction
configure_telemetry(                                               # custom callback to control how attributes are redacted
    client,
    redaction=lambda key, value: None if "email" in key else value,
)
PolicyStrategyTrade-off
RegexRedactionPolicy (default, redaction=True)Content-oriented: keeps keys and structure, redacts matched substrings (secret tokens plus PII — emails, card-like sequences, IPv4).Redacts most sensitive data while preserving observability value; may miss free-form PII or secrets not in the pattern set.
AttributeRedactionPolicyKey-oriented: redacts whole values for sensitive keys (explicit set, fragment match, or non-primitive value), then scans kept values for secret token patterns.Very conservative, but erases most prompt/response content.
CallbackRedactionPolicy (redaction=<callable>)Your (key, value) -> value | None masker per attribute; return None to drop the attribute.Full control; you own the logic.

The built-in defaults are exported as constants, so you can extend them instead of replacing them wholesale:

import re

from mistralai.extra.observability import (
    DEFAULT_PII_SECRET_PATTERNS,
    DEFAULT_SENSITIVE_ATTRIBUTE_KEYS,
    AttributeRedactionPolicy,
    RegexRedactionPolicy,
)

# Content-oriented: add a custom secret pattern to the default set.
configure_telemetry(
    client,
    redaction=RegexRedactionPolicy(
        patterns=(*DEFAULT_PII_SECRET_PATTERNS, re.compile(r"\bacme-[a-z0-9]{16}\b")),
    ),
)

# Key-oriented: mask an extra application attribute on top of the defaults.
configure_telemetry(
    client,
    redaction=AttributeRedactionPolicy(
        sensitive_keys=DEFAULT_SENSITIVE_ATTRIBUTE_KEYS | {"app.customer.email"},
    ),
)

Note: the RedactingSpanExporter primitive is reusable by any OpenTelemetry application, independent of the Mistral client.

Environment variables

VariableDescriptionDefault
MISTRAL_SDK_TELEMETRYAuto-enable telemetry: dedicated, global, or false.unset (disabled)
MISTRAL_OTLP_TRACES_ENDPOINTOverride the OTLP traces endpoint used in dedicated mode.https://api.mistral.ai/telemetry/v1/traces
MISTRAL_SDK_DEBUG_TRACINGSet to true for verbose tracing logs.false
MISTRAL_API_KEYUsed as the bearer token for the dedicated-mode exporter.—

Runnable examples live in examples/mistral/observability.

Development

Contributions

While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation. We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.

Significant stargazers

Donatas Remeika

19 followers · starred May 2024

Cédric Le Moigne

61 followers · starred Oct 2025

Patrick Barker

70 followers · starred Feb 2025

Parshva Daftari

61 followers · starred Mar 2025

Similar repos

mistralai/mistral-vibe

Minimal CLI coding agent by Mistral

5,055

same org

meta-llama/llama-api-python

The official Python library for the Llama API

64

openai/openai-python

The official Python library for the OpenAI API

31,753

googleapis/python-genai

Google Gen AI Python SDK provides an interface for developers to integrate Google's generative…

4,006

xai-org/xai-sdk-python

The official Python SDK for the SpaceXAI API

585

googleapis/python-aiplatform

A Python SDK for Vertex AI, a fully managed, end-to-end platform for data science and machine…

907

modelcontextprotocol/python-sdk

The official Python SDK for Model Context Protocol servers and clients

24,499

deepgram/deepgram-python-sdk

Official Python SDK for Deepgram.

469