const { Mistral } = await import("./mistral/index.js");

4. Environment variable. Set your API key before running:

export MISTRAL_API_KEY="your-key-here"

5. Import path alias (optional). In tsconfig.json add a path alias so imports stay clean:

{
  "compilerOptions": {
    "paths": {
      "@mistral/*": ["./src/mistral/*"]
    }
  }
}

Public API

Mistral

import { Mistral } from "./mistral/index.js";

const client = new Mistral({ apiKey: string; serverURL?: string });

The root SDK client. Exposes resource sub-clients as properties: client.chat, client.agents, client.files, client.models, client.batch, client.finetuning, client.embeddings, client.audio, and beta namespaces. Instantiate once and reuse across your application.

HTTPClient

import { HTTPClient } from "./mistral/index.js";

const http = new HTTPClient(options?: HTTPClientOptions);

A configurable fetch wrapper you can pass to Mistral to override the default fetch implementation, add proxy support, or inject custom headers. Pass it via new Mistral({ apiKey, httpClient: http }).

RealtimeConnection

import { RealtimeConnection } from "./mistral/extra/realtime/index.js";

WebSocket-based connection class for Mistral's real-time transcription API. Manages connection lifecycle, emits typed RealtimeEvent objects, and underlies RealtimeTranscription. Use this when you need raw event-level control over the WebSocket session.

RealtimeTranscription

import { RealtimeTranscription } from "./mistral/extra/realtime/index.js";

Higher-level wrapper around RealtimeConnection that handles session creation, audio streaming, and exposes transcript segment/text delta events. Use this for live microphone or audio-stream transcription.

SDKError / MistralError

import { SDKError, MistralError } from "./mistral/models/errors/index.js";

Base error classes thrown by all SDK operations. MistralError carries structured API error detail. Catch these in your error boundary to distinguish Mistral API errors from network failures.

Working examples

Scenario - Chat completion

Send a single user message and log the assistant's reply.

import { Mistral } from "./mistral/index.js";

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

const result = await client.chat.complete({
  model: "mistral-large-latest",
  messages: [
    { role: "user", content: "Explain ESM modules in one sentence." },
  ],
});

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

Scenario - Streaming chat completion

Use server-sent events to stream tokens as they arrive.

import { Mistral } from "./mistral/index.js";

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

const stream = await client.chat.stream({
  model: "mistral-small-latest",
  messages: [{ role: "user", content: "Count to five, one word per line." }],
});

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

Scenario - Standalone function (tree-shaking)

Use an individual function import instead of the class-based client to keep bundle size minimal.

import { Mistral } from "./mistral/index.js";
import { agentsComplete } from "./mistral/funcs/agentsComplete.js";

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

const result = await agentsComplete(client, {
  messages: [{ role: "user", content: "Summarise today's weather briefly." }],
  agentId: "ag:your-agent-id",
});

console.log(result);

Scenario - Real-time audio transcription

Stream microphone audio over a WebSocket and receive live transcripts.

import { RealtimeTranscription } from "./mistral/extra/realtime/index.js";
import type { RealtimeEvent } from "./mistral/extra/realtime/index.js";

const rt = new RealtimeTranscription({
  apiKey: process.env.MISTRAL_API_KEY ?? "",
});

await rt.connect();

rt.on("event", (event: RealtimeEvent) => {
  if (event.type === "transcription.stream.text_delta") {
    process.stdout.write(event.delta ?? "");
  }
});

// pipe your audio Buffer chunks:
// rt.sendAudio(buffer);

File walkthrough

• index.ts — Re-exports everything from lib/config.js, lib/http.js, lib/files.js, and the main sdk/sdk.js. Start imports here.
• core.ts — Internal plumbing: pagination cursors, retry logic, auth header injection. Not typically imported directly.
• sdk/ — Houses the Mistral class definition and all resource sub-clients. Each sub-client maps to one API surface area.
• funcs/ — One file per API operation, exported as standalone async functions. Prefer these in serverless/edge environments for tree-shaking.
• models/components/ — Zod schemas and inferred TypeScript types for every request and response shape.
• models/errors/ — Typed error classes: SDKError, MistralError, SDKValidationError, HTTPValidationError, ResponseValidationError.
• hooks/ — BeforeRequestHook, AfterSuccessHook, AfterErrorHook interfaces for middleware registration.
• lib/ — HTTPClient, SDKOptions/config, file-upload helpers, and fetch utilities.
• types/ — Shared utility generics used internally (e.g. PageIterator, Result).
• extra/structChat.ts — Helper for building structured/tool-use chat requests.
• extra/realtime/connection.ts — Low-level RealtimeConnection WebSocket class.
• extra/realtime/transcription.ts — RealtimeTranscription high-level audio transcription helper.
• extra/realtime/index.ts — Barrel re-exporting all realtime types and classes.

Common pitfalls and fixes

• ERR_REQUIRE_ESM in CommonJS projects. The package is ESM-only; use await import("./mistral/index.js") or convert your project to "type": "module".
• .js extension resolution errors. TypeScript path imports end in .js (even for .ts files); set "moduleResolution": "bundler" or "node16" in tsconfig.json.
• Missing MISTRAL_API_KEY. The client does not throw until the first request; set the env var or pass apiKey explicitly to the Mistral constructor.
• ws peer dep not installed. RealtimeConnection requires the ws package at runtime; install it and @types/ws explicitly as shown above.
• Zod version mismatch. The SDK expects Zod v4 (zod@^4); installing Zod v3 will cause silent schema failures. Pin to zod@^4.
• Streaming in non-Node runtimes. for await SSE streaming requires a runtime with ReadableStream support; on older Node versions (< 18) polyfill the Web Streams API or upgrade Node.

Vibe-coding prompt template

I have dropped the Mistral AI TypeScript SDK source into `src/mistral/` in my project.
The integration guide is in `USAGE.md`. The upstream package is `@mistralai/mistralai@2.2.1`.

Please help me integrate this SDK into my existing project step-by-step:

1. Read `USAGE.md` fully before writing any code.
2. Install the required runtime dependencies listed in USAGE.md.
3. Update `tsconfig.json` as described in the Project Setup section.
4. Create a singleton `src/lib/mistralClient.ts` that instantiates `Mistral` from
   `src/mistral/index.ts` using `process.env.MISTRAL_API_KEY`.
5. Add a `src/services/chatService.ts` that wraps `client.chat.complete(...)` and
   `client.chat.stream(...)` with proper TypeScript types and error handling
   (catching `MistralError` from `src/mistral/models/errors/index.ts`).
6. Show me how to use the standalone function imports from `src/mistral/funcs/` for
   any route handlers where tree-shaking matters.
7. If my project uses Express, add example route handlers.

Only use symbols and imports visible in USAGE.md and the source files. Do not invent APIs.

License and credit

The SDK source is generated by Speakeasy on behalf of Mistral AI. See source/LICENSE if present for the full license text, or refer to the upstream npm package (@mistralai/mistralai@2.2.1) and the GitHub repository for official license and attribution information.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

Vercel AI SDK Multi-Provider TypeScript Toolkit

SaaS, AI & Subscription Products

Free