# Mistral AI MCP > Mistral AI connects your agent to Mistral's open and commercial large language models. It handles text generation (`chat_completion`), data parsing (`extract_entities` as JSON), deep document understanding (`summarize_text`), and generating vector embeddings (`create_embeddings`) for advanced search (RAG). Use it when you need high-performance, European-based AI tools that run through any MCP-compatible client. ## Overview - **Category:** ai-frontier - **Price:** Free - **Tags:** large-language-models, embeddings, natural-language-processing, generative-ai, api-integration, rag ## Description **Mistral AI MCP Server: What You Get When Your Agent Connects Here** Forget running your client directly against the Mistral API endpoint. By connecting through this server, your agent talks to *Vinkius*, which handles all the messy authentication and routing for you. It's cleaner than dealing with raw keys every time. This setup gives your AI agent access to a powerful suite of specialized tools designed for real-world tasks—from generating natural language responses to building complex knowledge bases. *** **Generating and Manipulating Text** *You'll use `chat_completion` when you need your agent to generate human-quality text, whether it’s drafting an email or handling a back-and-forth conversation.* For simple writing tasks, the system supports comprehensive language capabilities through Mistral's various models. If you deal with multiple languages, *you can send any text to `translate_text`* and get accurate conversions across dozens of tongues. When your documents are massive—think 50-page reports or long articles—don’t try to feed it all at once. *Run `summarize_text`* to condense the material down to key, actionable points while keeping the core meaning intact. If you need more than just a summary, *you can analyze the overall emotional tone of any passage using `analyze_sentiment`*, letting your agent instantly flag whether the content is positive, negative, or neutral. *** **Structuring and Indexing Data for Search (RAG)** If you’re building a knowledge base or an internal search tool, this server is what you need. *You'll run `create_embeddings`* to convert any chunk of text into a numerical vector. This process is critical; it allows your agent to perform semantic searches and build robust Retrieval-Augmented Generation (RAG) pipelines that go way beyond simple keyword matching. For documents where you need specific data points, *you can't rely on fuzzy searching*. Instead, use `extract_entities`. This tool analyzes unstructured text—like a contract or an invoice—and pulls out precise data types (names, dates, IDs) and packages them neatly into a JSON object. It’s structured data extraction, period. *** **Coding Operations** This server gives your agent full control over code assets. *You'll use `generate_code`* to write brand new functions or snippets based on simple descriptive prompts. If you get a piece of unfamiliar code—say, from an old colleague—*you just feed it into `explain_code`*, and the tool spits out plain English explaining exactly what that logic does. For managing your workflow, *the `list_models` function lets your agent check every Mistral model available right now*, so you always know which one to point it toward for a given task. *** **Refining and Cleaning Content** *You can't trust raw input*. If the text coming into your workflow is messy, *you’ll run `fix_grammar`*. This checks for every spelling mistake and grammatical slip-up, giving you a clean, corrected version of the text. Combining this with `summarize_text` means you can take poorly written, rambling content, fix it up, and then condense it into a perfect summary—all in one flow. ## Tools ### chat_completion Generates natural language responses using Mistral's available models. ### fix_grammar Checks submitted text for spelling errors and grammatical mistakes, returning corrected versions. ### create_embeddings Converts input text into numerical vectors for similarity search and RAG systems. ### explain_code Takes a code snippet as input and returns a plain English explanation of its logic. ### extract_entities Analyzes text and pulls out specific data types (like names, dates, or IDs) into a JSON structure. ### generate_code Writes new code snippets or functions based on a descriptive prompt. ### list_models Returns a list of all Mistral models and their current capabilities for the user to choose from. ### analyze_sentiment Reads text and returns an assessment of its overall emotional tone. ### summarize_text Condenses long documents or articles into brief, key-point summaries while preserving core meaning. ### translate_text Converts text from one language to another with high accuracy across multiple languages. ## Prompt Examples **Prompt:** ``` List all available Mistral models. ``` **Response:** ``` Available models: 8. 1) mistral-large-latest (Top tier reasoning). 2) mistral-small-latest (Cost-effective). 3) open-mixtral-8x22b (Open weights). 4) mistral-embed (Embeddings). 5) codestral-latest (Code generation). Plus 3 older versions. ``` **Prompt:** ``` Generate a completion using mistral-large-latest. ``` **Response:** ``` Generation complete! ✅ Model: mistral-large-latest. Output: 'Bonjour! Here is a concise explanation of quantum computing...' Tokens used: 45 prompt, 120 completion. ``` **Prompt:** ``` Generate embeddings for a list of 3 sentences. ``` **Response:** ``` Embeddings generated! ✅ Model: mistral-embed. Input: 3 sentences. Output: 3 vectors (Dimensions: 1024 each). Total tokens used: 48. Ready for vector DB insertion. ``` ## Capabilities ### Generate Text Completions Your agent generates human-quality text using various Mistral models for chat or writing tasks. ### Create Embeddings The system converts arbitrary text inputs into numerical vectors, allowing your agent to perform semantic search and RAG. ### Extract Structured Data Your agent runs `extract_entities` to pull specific data points from unstructured text and return them as JSON objects. ### Analyze Text Sentiment The server processes a given piece of text and returns its emotional tone (positive, negative, neutral). ### Write and Explain Code Your agent can use `generate_code` to write snippets or call `explain_code` to detail the logic of existing code. ### Manage Models The tool set provides `list_models`, letting your agent check which Mistral models are available for current tasks. ## Use Cases ### Processing Customer Feedback A customer service agent receives a transcript of complaints. They ask their agent to process it. The agent runs `analyze_sentiment` (to find general tone), then uses `extract_entities` (to pull out product names and account IDs), and finally calls `summarize_text` to generate a single report for the engineering team. ### Building Internal Wiki Search A data scientist needs an internal search engine. They use `create_embeddings` on all 50 policy documents to build a vector database. When asked a question, the agent retrieves relevant chunks and uses `chat_completion` for a factual answer. ### Localizing Marketing Content A marketing team needs to roll out a campaign globally. They feed their source text into the agent, which runs `translate_text` first. Then they run the translated output through `fix_grammar` and `analyze_sentiment` to ensure tone consistency in all target markets. ### Onboarding New Developers A new hire needs to understand legacy code. They point the agent at a file, which calls `explain_code`. The agent then uses `generate_code` to write a simple test case based on that explanation, speeding up the review process. ## Benefits - **Structured Data Parsing:** Use `extract_entities` to reliably pull names, dates, or IDs from messy text. This is faster than writing custom regex parsers for every document type. - **Advanced Search (RAG):** The `create_embeddings` tool turns documents into vectors, letting your agent search a knowledge base by meaning, not just keywords. Essential for enterprise Q&A systems. - **Code Reliability:** Don't guess about code. Use `explain_code` to validate complex functions or use `generate_code` to scaffold new modules quickly. - **Content Quality Control:** Run text through `fix_grammar` before publishing or send it through `analyze_sentiment` to gauge public reception automatically. - **Universal Model Access:** With `list_models`, your agent always knows which Mistral model—Large, Small, or Open—is best suited for the task at hand. ## How It Works The bottom line is: it makes calling complex AI functions as simple as calling a native library method in your code. 1. Enter your Mistral API Key in the server settings. 2. Your AI client calls a specific tool (e.g., `translate_text`) with input parameters. 3. The MCP Server processes the request, executes the function using Mistral's backend, and sends the final data back to your agent. ## Frequently Asked Questions **How do I use `create_embeddings` in my agent workflow?** `create_embeddings` takes text as a list of strings. It returns a set of vectors (arrays of floats). You then send these vectors to your vector database (like Pinecone or Chroma) for similarity lookups. **Is `analyze_sentiment` reliable enough for production use?** It's designed for high accuracy. It returns a clear classification, making it ideal for initial triage of large volumes of feedback before human review is needed. **What's the difference between `summarize_text` and `chat_completion`?** `summarize_text` is dedicated to condensing long documents into key points. While you *could* prompt for a summary in `chat_completion`, using the dedicated tool gives more predictable, focused results. **Can I use `generate_code` and `explain_code` together?** Yes. You can use `generate_code` to create a new function, then immediately call `explain_code` on that output. This lets your agent document its own work automatically. **What credentials do I need to use the `chat_completion` tool?** You'll need a valid Mistral API Key. You enter this key during server setup; it authenticates your calls and allows us to track token usage against your account limits. **If my agent sends many requests, how does the system handle rate limits for `chat_completion`?** The client monitors your total token usage. If you hit a rate limit, it returns a standard HTTP 429 error code. Your AI client should recognize this and automatically retry the request after a specified delay. **Is the data I send via `extract_entities` secure, and what's the residency?** The service runs on European infrastructure. Mistral adheres to strict privacy guidelines for all inputs, meaning your data remains private during processing and is not used to train public models. **Using `list_models`, how do I decide between using Mistral Large and Mistral Small?** You select the model based on complexity versus cost. Use Mistral Large when you need top-tier reasoning for difficult tasks, or switch to Mistral Small if budget efficiency is more important. **Which models can I access?** Access all available endpoints including `mistral-large-latest`, `mistral-small-latest`, `open-mixtral-8x22b`, and `mistral-embed`. **How does Mistral authentication work?** Mistral requires an **API Key** sent as a Bearer token against `api.mistral.ai/v1`. **Can I generate vector embeddings?** Yes. Use the `mistral-embed` model to generate 1024-dimensional embeddings for your text data.