Mistral MCP

List conversations created with this API key, most recent first.

Start a new stateful, multi-turn conversation. Returns a conversation_id to continue with conversation_append. Pass exactly one of `agentId` (a pre-configured Mistral Agent) or `model` (a base chat model — defaults to the standard chat model if neither is set). `tools` enables Mistral's built-in tools for this conversation: web_search, web_search_premium, code_interpreter, image_generation. Pass `documentLibraryIds` to additionally enable document_library search over specific Mistral Libraries.

Delete a file by id. This is irreversible.

Retrieve a single file's metadata by id.

List files owned by this API key, with optional filters. Use `include_total: true` to get the total count across pages.

Generate a short-lived, signed URL to download a file. Expiry is in hours (1–168). Defaults to 24h server-side.

Upload a file (up to 512 MB) and get a `fileId` that can be referenced by `mistral_ocr`, `voxtral_transcribe`, batch jobs, or fine-tuning. Inputs: - `filename`: user-visible name (e.g. 'contract.pdf'). - `content_base64`: file bytes, base64-encoded. `data:` URI prefix accepted. - `purpose`: 'fine-tune' (.jsonl only), 'batch' (.jsonl), or 'ocr' (pdf/image). - `visibility`: 'user' (default) or 'workspace' (shared with your team). - `expiry_days`: optional auto-delete after N days.

List the documents uploaded to a Library, with their processing status.

Check whether an uploaded document has finished processing and is searchable.

Upload a document (base64-encoded bytes) to a Library for RAG indexing. Processing happens server-side and asynchronously — the document is not searchable until `process_status` reaches 'done'. Poll with libraries_documents_status to track it.

Fetch a Library's metadata (owner, size, document count).

List Libraries (managed RAG document stores) you own or have been shared with you. Use a returned `id` as a `documentLibraryIds` entry on conversation_start to search it.

Legacy agents completion endpoint, retained for compatibility. For modern agents, use agents_list/agents_get then conversation_start with agentId. Unlike `mistral_chat`, this tool requires an `agentId` pointing to an agent you've created in the Mistral dashboard. The agent carries its own system prompt, model, tools, and connectors (web_search, code_interpreter, document_library, image_generation) server-side — you just send messages. Use `mistral_chat` for direct model calls without stateful agent config.

Generate a chat completion using a Mistral model. When to use: - Drafting French (or any European-language) content where Mistral shines. - Codestral for code-specific generation/review. - Ministral for cheap / low-latency classification. Returns structured content with the assistant text and token usage. Does NOT stream — use mistral_chat_stream for long outputs with progress updates.

Like mistral_chat but streams tokens as they arrive. The client must pass _meta.progressToken to receive notifications/progress events for each streamed chunk. Final return payload is the assembled text. Use when: the expected completion is long (> ~500 tokens) or the calling UI wants live output. Otherwise use mistral_chat.

Run a classifier on one or more texts and return per-target scores. Use this with a fine-tuned classifier model id (e.g. `ft:classifier:...`) trained via the Classifier Factory, or a preset classifier model. Each result is a dict of target_name → { scores: { label: score } }.

Generate embeddings for one or more strings via the mistral-embed model. Returns one 1024-dimensional vector per input, plus token usage. Warning: embedding payloads can be large. For > 50 inputs, consider batching client-side and storing vectors yourself instead of routing through the MCP tool channel.

Classify one or more texts for harmful content. Returns per-input `categories` (boolean flags) and `category_scores` (0..1 floats). Categories include: sexual, hate_and_discrimination, violence_and_threats, dangerous_and_criminal_content, selfharm, health, financial, law, pii. Use `mistral_chat_moderate` style pre-filtering by calling this before passing user input to a downstream LLM.

Run Mistral OCR on a PDF or image, returning structured markdown per page. Input `document` is one of: - { type: "document_url", documentUrl: "https://...pdf" } - { type: "image_url", imageUrl: "https://..." | "data:image/..." } - { type: "file", fileId: "<id-from-files-api>" } Options: - `pages`: array of 0-indexed page numbers or string like "0-5,7". - `tableFormat`: 'markdown' (default) or 'html'. - `extractHeader` / `extractFooter`: include page header/footer when present. - `includeImageBase64`: embed extracted image bytes as base64 in the response. - `document_annotatio…

Run a chat completion with function-calling enabled. The model inspects the provided `tools` (OpenAI-style function schemas) and decides whether to emit one or more `tool_calls`. This tool does NOT execute the tools — it only returns the model's decision and arguments, which the caller then routes to the appropriate local handlers. Use when: building agent loops where Mistral picks actions from a tool catalog. Supported models (via Mistral docs): mistral-*/magistral-*/ministral-*/devstral-*/codestral-*.

Description is built at runtime.

Single-call pipeline: provided text/Markdown or Mistral OCR → classify (if kind=auto) → typed extraction → validation. source.type=text skips OCR and Files uploads. Text with kind=generic makes no API calls; classification and typed extraction use Mistral chat. Results expose extraction_source. Provided text has null ocr_confidence and page_count; ocr_text contains the supplied text unchanged. Replaces the manual chain of mistral_ocr + mistral_chat + JSON parsing. Kinds: contract | invoice | id_document | generic. Use kind=auto to let the server classify. Returns a discriminated union — switc…

List the search-index deployments registered with Mistral and visible to this API key — the corpora an agent can retrieve from. When to use: - Before any retrieval, to discover which indexes exist and whether they are ready. - To map a human-readable corpus name onto the index id a retrieval tool needs. This tool does not search. Retrieval itself runs in the Mistral Search Toolkit (self-hosted, exposes its own MCP tools) or in Mistral Libraries — pair a library id with `conversation_start`'s `documentLibraryIds` for the managed path. Registering or removing a deployment is a deploy-pipeline…

Synthesize speech from text. Returns base64-encoded audio. Inputs: - `input`: the text to speak. - `voiceId`: preset or custom voice id (see resource `mistral://voices`). - `responseFormat`: mp3 (default), wav, flac, opus, or pcm. - `model`: optional model id. Leave empty to let the API pick the default. - `refAudio`: base64 reference audio for voice cloning (when supported). Returns `audio_base64` plus `mime_type` and echoed `format`/`voice_id`.

Description is built at runtime.

List the workflow deployments in this workspace and whether each can run right now. Call this before workflow_execute. A workflow returned by mistral://workflows is a *definition*; running it requires a deployment with at least one live worker. A workflow whose deployment is missing or has no live worker answers 404 (no active deployment found) — this tool is how to see that first. runnable_count is the number of deployments with a live worker. When it is 0, no workflow can be executed and the operator has to start a deployment.

Start a Mistral Workflow execution. `workflowIdentifier` is the workflow name or ID (visible in mistral://workflows). `input` is a free-form JSON object matching the workflow's input schema. Modes: - waitForResult=false (default): returns immediately with execution_id and RUNNING status. Poll workflow_status to track completion. - waitForResult=true: blocks until the workflow finishes and returns the result inline. Use timeoutSeconds (default 30) to cap the wait. Use deploymentName to target a specific deployment slot when multiple are configured.

Send a signal to or run a query against a running workflow execution. action=signal: fire-and-forget event; the workflow reacts asynchronously. - `name`: signal name defined in the workflow. - `input`: optional payload matching the signal's schema. action=query: synchronous read of internal workflow state. - `name`: query handler name defined in the workflow. - `input`: optional parameters for the query. - Returns `query_name` + `result` inline. action=update: synchronous request to modify workflow state mid-execution. - `name`: update handler name defined in the workflow. - `…

List workflow executions, most recent first. Use it to find an execution_id to pass to workflow_status, workflow_interact or workflow_stop. All filters are optional; with none, returns the latest executions in the workspace.

Get the current state and result of a workflow execution. Statuses: RUNNING | COMPLETED | FAILED | CANCELED | TERMINATED | CONTINUED_AS_NEW | TIMED_OUT | RETRYING_AFTER_ERROR Poll until status is COMPLETED (or terminal) when waitForResult was false. `result` is populated once the workflow reaches a terminal state.

Stop a running workflow execution. mode=cancel (default): asks the workflow to wind down, letting it run its cleanup handlers. Prefer this — a cancelled workflow leaves consistent state. mode=terminate: kills the execution immediately. Cleanup handlers do not run, so any half-finished side effect stays half-finished. Use only when cancel is stuck. Both are accepted asynchronously: the call returning does not mean the execution has already stopped. Poll workflow_status to observe the final state.