Mistral AI Free code examples in C#, Python, Java and JavaScript

The official SDK. Note the class is Mistral, not MistralClient — that older name is from the v0 package and is the most common import error.

pip install mistralai

export MISTRAL_API_KEY="..."      # macOS / Linux
setx MISTRAL_API_KEY "..."        # Windows, then open a new shell

chat.complete, not chat.completions.create — the method names differ from OpenAI even though the response shape does not.

import os
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain a database index in two sentences."},
    ],
)

print(response.choices[0].message.content)
print(response.usage.prompt_tokens, response.usage.completion_tokens)

chat.stream returns events wrapping the chunk in .data — one level deeper than OpenAI's. Reading event.choices directly is the usual AttributeError here.

stream = client.chat.stream(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Write a haiku about indexes."}],
)

for event in stream:
    delta = event.data.choices[0].delta.content      # note .data
    if delta:
        print(delta, end="", flush=True)

print()

Mistral publishes open weights, which is the reason to pick it over a closed model: the same prompt can run on their API today and on your own hardware when the data cannot leave. Serve the weights with Ollama or vLLM and only the client changes.

import os
from openai import OpenAI

LOCAL_KEY = "unused"      # required by the client, ignored by Ollama

# Ollama and vLLM both expose an OpenAI-compatible endpoint, so a
# locally served Mistral is reachable with the OpenAI client.
local = OpenAI(
    base_url="http://localhost:11434/v1",   # ollama serve
    api_key=LOCAL_KEY,
)

response = local.chat.completions.create(
    model="mistral",                         # ollama pull mistral
    messages=[{"role": "user", "content": "Explain a database index."}],
)
print(response.choices[0].message.content)

# Keep the prompt in one place and switch only the client, so the
# hosted and local paths cannot drift apart.

There is no official Mistral SDK for Java — Mistral ships Python and TypeScript only. The OpenAI Java SDK pointed at Mistral's endpoint is the same wire format without an unofficial dependency.

<dependency>
    <groupId>com.openai</groupId>
    <artifactId>openai-java</artifactId>
    <version>4.69.2</version>
</dependency>

baseUrl retargets the client. From here every OpenAI Java sample in this guide applies unchanged.

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey(System.getenv("MISTRAL_API_KEY"))
    .baseUrl("https://api.mistral.ai/v1")
    .build();

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("mistral-large-latest")
    .addSystemMessage("You are a concise technical assistant.")
    .addUserMessage("Explain a database index in two sentences.")
    .build();

ChatCompletion completion = client.chat().completions().create(params);

completion.choices().get(0).message().content()
    .ifPresent(System.out::println);

Identical to the OpenAI page. Close the stream — it holds an HTTP connection open.

import com.openai.core.http.StreamResponse;
import com.openai.models.chat.completions.ChatCompletionChunk;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("mistral-large-latest")
    .addUserMessage("Write a haiku about indexes.")
    .build();

try (StreamResponse<ChatCompletionChunk> stream =
         client.chat().completions().createStreaming(params)) {

    stream.stream()
        .flatMap(chunk -> chunk.choices().stream())
        .flatMap(choice -> choice.delta().content().stream())
        .forEach(System.out::print);
}

Mistral speaks the OpenAI wire format, not the whole OpenAI API.

// 1. MODEL IDS ARE MISTRAL'S. mistral-large-latest is an alias and so
//    survives releases; an OpenAI id is a 404 here.

// 2. OPENAI-ONLY FEATURES ARE ABSENT. Anything newer than chat
//    completions will be rejected or quietly ignored.

// 3. ERROR BODIES ARE MISTRAL'S, but the typed exceptions still work
//    because they branch on HTTP status, not on the vendor.

// 4. FOR MISTRAL-SPECIFIC FEATURES, call their REST API directly.
//    This path is the portable subset, not the full surface.

The official TypeScript SDK. Server-side only.

npm install @mistralai/mistralai

export MISTRAL_API_KEY="..."

chat.complete, not chat.completions.create. The response shape matches OpenAI's, the method names do not.

import { Mistral } from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: "mistral-large-latest",
  messages: [
    { role: "system", content: "You are a concise technical assistant." },
    { role: "user", content: "Explain a database index in two sentences." },
  ],
});

console.log(response.choices[0].message.content);

Events wrap the chunk in .data — one level deeper than OpenAI's. Reading event.choices directly returns undefined rather than throwing, so the loop looks like it works and prints nothing.

const stream = await client.chat.stream({
  model: "mistral-large-latest",
  messages: [{ role: "user", content: "Write a haiku about indexes." }],
});

for await (const event of stream) {
  const delta = event.data.choices[0]?.delta?.content;   // note .data
  if (delta) process.stdout.write(delta);
}

Open weights are the reason to pick Mistral. Serve them with Ollama or vLLM and only the client changes.

import OpenAI from "openai";

const LOCAL_KEY = "unused";   // required by the client, ignored by Ollama

// Ollama and vLLM expose an OpenAI-compatible endpoint.
const local = new OpenAI({
  baseURL: "http://localhost:11434/v1",   // ollama serve
  apiKey: LOCAL_KEY,
});

const response = await local.chat.completions.create({
  model: "mistral",                        // ollama pull mistral
  messages: [{ role: "user", content: "Explain a database index." }],
});
console.log(response.choices[0].message.content);