Mistral MCP vs Interactive MCP
A side-by-side look at the Mistral MCP and Interactive MCP MCP servers: transport, auth, tools, quality signals, and the config to install either one in Claude, Cursor, Windsurf or VS Code.
Verdict: choose Mistral MCP for other tools and integrations work as a local process; choose Interactive MCP for other tools and integrations as a local process. You can also run both side by side in one mcpServers block.
Which MCP server should you choose?
Choose Mistral MCP when
- You need dedicated capabilities in the Other Tools and Integrations domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: API key required.
- You have the keys it needs:
MISTRAL_API_KEY. - You want tools like
mistral_chat, codestral_fim, mistral_vision.
Choose Interactive MCP when
- You need dedicated capabilities in the Other Tools and Integrations domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: No auth required.
- You want tools like
request_user_input, message_complete_notification, start_intensive_chat.
Feature & specification comparison
Rows where the two servers differ are marked.
| Spec | ||
|---|---|---|
| Category | Other Tools and Integrations | Other Tools and Integrations |
| Quality signal | 65/100 · Great | 64/100 · Good |
| Install command | Confirmed | Confirmed |
| Transport | Local subprocess (stdio) | Local subprocess (stdio) |
| Auth | API key required | No auth required |
| Pricing | BYOK (pay the provider) | Free |
| Required env vars | MISTRAL_API_KEY | None listed |
| Verified owner | Community listing | Community listing |
| GitHub stars | 15 | 351 |
| Directory activity | 2 views 0 installs 0 upvotes | 4 views 0 installs 0 upvotes |
| Tools | 8 | 5 |
| Full listing | View Mistral MCP | View Interactive MCP |
Tools & capabilities
Mistral MCP tools 8
mistral_chatGenerate 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.codestral_fimFill-in-the-middle code completion with Codestral. Given `prompt` (code preceding the cursor) and `suffix` (code after the cursor), Codestral writes the middle. Use for editor autocomplete scenarios, code-patching agents, or structured refactors where you know the target boundaries. Default stop tokens: [] — let the model decide. Override with `stop` if needed.mistral_visionChat completion with multimodal input: text + image_url parts. Requires a vision-capable model. Accepted: - pixtral-large-latest - pixtral-12b-latest - mistral-large-latest - mistral-medium-latest - mistral-small-latest Each message's `content` is either a plain string (pure text) or an array of parts `{ type: 'text', text }` / `{ type: 'image_url', imageUrl }`. The image URL can be an https URL or a data: URI base64 payload. Returns the assistant text + token usage. For non-visual requests, prefer `mistral_chat`.mistral_ocrRun 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_annotation_format`: JSON schema for whole-document structured extraction. - `bbox_annotation_format`: JSON schema for extracted image / bbox annotations. - `confidence_scores_granularity`: 'page' or 'word'. Returns `pages[].markdown` plus optional `pages[].hyperlinks`, `header`, `footer`, `images` bounding boxes, annotations, confidence scores, and `dimensions`.voxtral_transcribeTranscribe an audio file to text using Mistral Voxtral. Accepted models: - voxtral-mini-latest - voxtral-small-latest Audio source is one of: - { type: "file_url", fileUrl: "https://..." } (public URL) - { type: "file", fileId: "<id-from-files-api>" } Options: - `language`: ISO-639-1 hint (e.g. 'fr', 'en'). Boosts accuracy when known. - `temperature`: sampling temperature. - `diarize`: return per-speaker segments (default false). - `timestampGranularities`: ['segment'] to return per-segment timestamps. - `contextBias`: list of phrases/terms that should bias the decoder. Returns plain `text`, detected `language`, optional `segments[]`, and token usage.workflow_executeStart 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.workflow_statusGet 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.workflow_interactSend 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. - `input`: optional payload for the update. - Returns `update_name` + `result` inline.
Interactive MCP tools 5
request_user_input<description> Send a question to the user via a pop-up command prompt. **Crucial for clarifying requirements, confirming plans, or resolving ambiguity.** You should call this tool whenever it has **any** uncertainty or needs clarification or confirmation, even for trivial or silly questions. Feel free to ask anything! **Proactive questioning is preferred over making assumptions.** </description> <importantNotes> - (!important!) **Use this tool FREQUENTLY** for any question that requires user input or confirmation. - (!important!) Continue to generate existing messages after user answers. - (!important!) Provide predefined options for quick selection if applicable. - (!important!) **Essential for validating assumptions before proceeding with significant actions (e.g., code edits, running commands).** </importantNotes> <whenToUseThisTool> - When you need clarification on user requirements or preferences - When multiple implementation approaches are possible and user input is needed - **Before making potentially impactful changes (code edits, file operations, complex commands)** - When you need to confirm assumptions before proceeding - When you need additional information not available in the current context - When validating potential solutions before implementation - When facing ambiguous instructions that require clarification - When seeking feedback on generated code or solutions - When needing permission to modify critical files or functionality - **Whenever you feel even slightly unsure about the user's intent or the correct next step.** </whenToUseThisTool> <features> - Pop-up command prompt display for user input - Returns user response or timeout notification (timeout defaults to 60 seconds)) - Maintains context across user interactions - Handles empty responses gracefully - Properly formats prompt with project context </features> <bestPractices> - Keep questions concise and specific - Provide clear options when applicable - Do not ask the question if you have another tool that can answer the question - e.g. when you searching file in the current repository, do not ask the question "Do you want to search for a file in the current repository?" - e.g. prefer to use other tools to find the answer (Cursor tools or other MCP Server tools) - Limit questions to only what's necessary **to resolve the uncertainty** - Format complex questions into simple choices - Reference specific code or files when relevant - Indicate why the information is needed - Use appropriate urgency based on importance </bestPractices> <parameters> - projectName: Identifies the context/project making the request (used in prompt formatting) - message: The specific question for the user (appears in the prompt) - predefinedOptions: Predefined options for the user to choose from (optional) </parameters> <examples> - "Should I implement the authentication using JWT or OAuth?" - "Do you want to use TypeScript interfaces or type aliases for this component?" - "I found three potential bugs. Should I fix them all or focus on the critical one first?" - "Can I refactor the database connection code to use connection pooling?" - "Is it acceptable to add React Router as a dependency?" - "I plan to modify function X in file Y. Is that correct?" </examples>message_complete_notification<description> Notify when a response has completed. Use this tool **once** at the end of **each and every** message to signal completion to the user. </description> <importantNotes> - (!important!) **MANDATORY:** ONLY use this tool exactly once per message to signal completion. **Do not forget this step.** </importantNotes> <whenToUseThisTool> - When you've completed answering a user's query - When you've finished executing a task or a sequence of tool calls - When a multi-step process is complete - When you want to provide a summary of completed actions just before ending the response </whenToUseThisTool> <features> - Cross-platform OS notifications (Windows, macOS, Linux) - Reusable tool to signal end of message - Should be called exactly once per LLM response </features> <bestPractices> - Keep messages concise - Use projectName consistently to group notifications by context </bestPractices> <parameters> - projectName: Identifies the context/project making the notification (appears in notification title) - message: The specific notification text (appears in the body) </parameters> <examples> - { "projectName": "MyApp", "message": "Feature implementation complete. All tests passing." } - { "projectName": "MyLib", "message": "Analysis complete: 3 issues found and fixed." } </examples>start_intensive_chat<description> Start an intensive chat session for gathering multiple answers quickly from the user. **Highly recommended** for scenarios requiring a sequence of related inputs or confirmations. Very useful for gathering multiple answers from the user in a short period of time. Especially useful for brainstorming ideas or discussing complex topics with the user. </description> <importantNotes> - (!important!) Opens a persistent console window that stays open for multiple questions. - (!important!) Returns a session ID that **must** be used for subsequent questions via 'ask_intensive_chat'. - (!important!) **Must** be closed with 'stop_intensive_chat' when finished gathering all inputs. - (!important!) After starting a session, **immediately** continue asking all necessary questions using 'ask_intensive_chat' within the **same response message**. Do not end the response until the chat is closed with 'stop_intensive_chat'. This creates a seamless conversational flow for the user. </importantNotes> <whenToUseThisTool> - When you need to collect a series of quick answers from the user (more than 2-3 questions) - When setting up a project with multiple configuration options - When guiding a user through a multi-step process requiring input at each stage - When gathering sequential user preferences - When you want to maintain context between multiple related questions efficiently - When brainstorming ideas with the user interactively </whenToUseThisTool> <features> - Opens a persistent console window for continuous interaction - Supports starting with an initial question - Configurable timeout for each question (set via -t/--timeout, defaults to 60 seconds) - Returns a session ID for subsequent interactions - Keeps full chat history visible to the user - Maintains state between questions </features> <bestPractices> - Use a descriptive session title related to the task - Start with a clear initial question when possible - Do not ask the question if you have another tool that can answer the question - e.g. when you searching file in the current repository, do not ask the question "Do you want to search for a file in the current repository?" - e.g. prefer to use other tools to find the answer (Cursor tools or other MCP Server tools) - Always store the returned session ID for later use - Always close the session when you're done with stop_intensive_chat </bestPractices> <parameters> - sessionTitle: Title for the intensive chat session (appears at the top of the console) </parameters> <examples> - Start session for project setup: { "sessionTitle": "Project Configuration" } </examples>ask_intensive_chat<description> Ask a new question in an active intensive chat session previously started with 'start_intensive_chat'. </description> <importantNotes> - (!important!) Requires a valid session ID from 'start_intensive_chat'. - (!important!) Supports predefined options for quick selection. - (!important!) Returns the user's answer or indicates if they didn't respond. - (!important!) **Use this repeatedly within the same response message** after 'start_intensive_chat' until all questions are asked. </importantNotes> <whenToUseThisTool> - When continuing a series of questions in an intensive chat session. - When you need the next piece of information in a multi-step process initiated via 'start_intensive_chat'. - When offering multiple choice options to the user within the session. - When gathering sequential information from the user within the session. </whenToUseThisTool> <features> - Adds a new question to an existing chat session - Supports predefined options for quick selection - Returns the user's response - Maintains the chat history in the console </features> <bestPractices> - Ask one clear question at a time - Provide predefined options when applicable - Don't ask overly complex questions - Keep questions focused on a single piece of information </bestPractices> <parameters> - sessionId: ID of the intensive chat session (from start_intensive_chat) - question: The question text to display to the user - predefinedOptions: Array of predefined options for the user to choose from (optional) </parameters> <examples> - Simple question: { "sessionId": "abcd1234", "question": "What is your project named?" } - With predefined options: { "sessionId": "abcd1234", "question": "Would you like to use TypeScript?", "predefinedOptions": ["Yes", "No"] } </examples>stop_intensive_chat<description> Stop and close an active intensive chat session. **Must be called** after all questions have been asked using 'ask_intensive_chat'. </description> <importantNotes> - (!important!) Closes the console window for the intensive chat. - (!important!) Frees up system resources. - (!important!) **Should always be called** as the final step when finished with an intensive chat session, typically at the end of the response message where 'start_intensive_chat' was called. </importantNotes> <whenToUseThisTool> - When you've completed gathering all needed information via 'ask_intensive_chat'. - When the multi-step process requiring intensive chat is complete. - When you're ready to move on to processing the collected information. - When the user indicates they want to end the session (if applicable). - As the final action related to the intensive chat flow within a single response message. </whenToUseThisTool> <features> - Gracefully closes the console window - Cleans up system resources - Marks the session as complete </features> <bestPractices> - Always stop sessions when you're done to free resources - Provide a summary of the information collected before stopping </bestPractices> <parameters> - sessionId: ID of the intensive chat session to stop </parameters> <examples> - { "sessionId": "abcd1234" } </examples>
Ready-to-paste client configs
Paste either block (or both) into your client config, e.g. claude_desktop_config.json or ~/.cursor/mcp.json. We only show a config when the install command is confirmed.
Mistral MCP
{
"mcpServers": {
"swih-mistral-mcp": {
"command": "npx",
"args": [
"-y",
"mistral-mcp@1.0.0"
],
"env": {
"MISTRAL_API_KEY": "YOUR_MISTRAL_API_KEY_HERE"
}
}
}
}
Interactive MCP
{
"mcpServers": {
"ttommyth-interactive-mcp": {
"command": "npx",
"args": [
"-y",
"interactive-mcp"
]
}
}
}
Frequently asked questions
Mistral MCP is categorized under Other Tools and Integrations and uses a local stdio subprocess. Interactive MCP belongs to Other Tools and Integrations and uses a local stdio subprocess. Pick Mistral MCP for other tools and integrations work and Interactive MCP for other tools and integrations.
Copy the mcpServers block from the config section on this page into your client's config (for example claude_desktop_config.json or ~/.cursor/mcp.json), then fully restart the client.
Mistral MCP is bring-your-own-key: usage is billed by the API provider you supply a key for. Auth: api key required. Interactive MCP is listed as free. Auth: no auth required. If a server needs environment variables such as API keys, define them under the env key in your client's MCP config.
Yes. MCP clients support multiple servers: add swih-mistral-mcp and ttommyth-interactive-mcp as separate keys in the same mcpServers object, and your assistant will call tools from either one.
On AllMCPs, Mistral MCP has a quality signal of 65/100 (Great) with 2 views, 0 installs and 15 GitHub stars. Interactive MCP has 64/100 (Good) with 4 views, 0 installs and 351 GitHub stars.