# Cohere (Embed & Rerank) MCP MCP > Cohere (Embed & Rerank) lets your agent read documents like a human does—understanding context, not just keywords. It generates deep vector embeddings for semantic search and uses reranking to pull out the single most relevant chunk of text from massive knowledge bases. Use it when basic keyword matching fails. ## Overview - **Category:** ai-frontier - **Price:** Free - **Tags:** embeddings, semantic-search, vector-representation, natural-language-processing, rag, text-analysis ## Description Your AI agent needs to understand meaning, not just match words. This MCP connects your system to Cohere's advanced NLP tools, allowing you to build truly intelligent retrieval-augmented generation (RAG) pipelines directly into your workflow. You can generate precise vector embeddings that map plain strings into dense mathematical shapes, letting the AI find information based on *what* it means, not just *how* it’s spelled. Beyond basic search, you get semantic reranking. Instead of retrieving a handful of documents and asking your agent to guess the best one, this process structures contextual chunks by priority, giving your LLM the absolute most relevant information upfront for better accuracy. You can also run text classification on incoming data, categorizing inputs into predefined labels with confidence scores. For complex conversations, you'll use formatted conversational transformations, while `tokenize_text` lets developers audit exactly how many tokens a prompt will consume before sending it. Building these sophisticated pipelines is easier than ever. When your agent processes and sends all this data through the secure Vinkius platform, your credentials pass through a zero-trust proxy, meaning your keys are used only in transit—they never sit on disk. Plus, Vinkius handles native token optimization for every call, cutting up to 60% of token consumption compared to running these tools without it. ## Tools ### chat_completion Runs specific conversational transformations to maintain state and context across multiple messages. ### classify_texts Assigns a predefined label to a text string and provides a score indicating how certain the classification is. ### embed_texts Creates dense vector representations for texts, allowing the system to calculate semantic distance between concepts. ### list_models Provides a list of available models and their internal properties so you can verify API access against your plan limits. ### rerank_documents Structures an array of documents, sorting them by relevance to a specific query for improved search accuracy. ### tokenize_text Breaks down raw text into its structural token segments, allowing precise auditing of the input length. ## Prompt Examples **Prompt:** ``` Generate embeddings for these texts: ['Hello world', 'Artificial Intelligence'] ``` **Response:** ``` Embeddings generated! I've retrieved the dense vector representations for both strings. You can now use these floats for semantic search or similarity calculations. ``` **Prompt:** ``` Rerank these documents for query 'Best pizza in NY': ['Pizza hut review', 'Joe's Pizza is the local favorite'] ``` **Response:** ``` Reranking complete! 'Joe's Pizza is the local favorite' has been moved to rank 0 with a high relevance score. 'Pizza hut review' is now at rank 1. ``` **Prompt:** ``` How many tokens are in the text: 'The quick brown fox jumps over the lazy dog'? ``` **Response:** ``` That sentence contains 9 tokens according to the Cohere tokenizer. I can provide the exact integer array mapping these tokens if you'd like. ``` ## Capabilities ### Generate Semantic Embeddings Converts any text into a dense vector shape that mathematically represents its meaning. ### Improve Document Relevance Structures and orders multiple documents against a query, ensuring the LLM only sees the highest-priority context. ### Categorize Incoming Text Assigns clear labels to text inputs based on predefined rules and provides a confidence score for that label. ### Process Conversational Flows Executes structured, multi-step conversational tasks using the latest LLM models. ### Audit Token Usage Provides a structural segmentation of text to show developers exactly how many tokens an input will consume. ## Use Cases ### Internal Knowledge Base Search A support agent needs to answer a complex technical question from an old manual. Instead of simple keyword matching, the agent uses `embed_texts` and then passes those vectors through `rerank_documents`, ensuring it retrieves the exact paragraph about the relevant procedure, not just the chapter title. ### Financial Document Review A compliance officer uploads 50 legal contracts. The agent uses `classify_texts` to automatically flag every document that mentions 'indemnification clause' or 'jurisdictional risk,' drastically reducing the time spent manually reviewing boilerplate text. ### Multi-Platform Data Ingestion An operations team is collecting customer feedback from various forms. They use `classify_texts` to immediately sort every incoming submission into 'Billing Issue', 'Product Bug', or 'Feature Request,' allowing the agent to route it instantly. ### Debugging LLM Costs A developer needs to estimate the cost of a new conversational feature. They use `tokenize_text` first, then call `list_models`, confirming the token count and available model parameters before writing any integration code. ## Benefits - Boost retrieval accuracy by using `rerank_documents` to sort context, ensuring your agent only sees the most critical parts of a document. - Handle complex Q&A systems by generating high-quality vector embeddings with `embed_texts`, making semantic search reliable. - Keep development costs low; Vinkius's native token optimization cuts API spending by up to 60% on every call. - Improve data quality checks using `classify_texts` to automatically tag incoming records, reducing manual triage time. - Audit your entire workflow upfront. Use `tokenize_text` and `list_models` to verify model availability and token consumption before deployment. ## How It Works The bottom line is that you stop building basic API wrappers and start telling your AI what specific data it needs to achieve its goal. 1. Subscribe to the MCP and enter your Cohere API key (Trial or Production). 2. Connect this MCP to your preferred AI client, like Cursor or Claude. 3. Run a complex retrieval job: first generate embeddings for documents, then use `rerank_documents` with a query, and finally pass that highly focused context into the agent. ## Frequently Asked Questions **How does `embed_texts` help with semantic search?** `embed_texts` converts text into dense vector shapes (floating point arrays). These vectors are used to calculate the mathematical distance between two pieces of text, allowing your agent to find concepts that are similar in meaning, even if they use different words. **What is the difference between `rerank_documents` and a standard search?** Standard searches look for keyword matches. `rerank_documents` takes multiple results and reorders them based on deep contextual relevance, ensuring the highest-priority information appears at the top. **Do I need to worry about token costs with this MCP?** No. When running through Vinkius, you benefit from native token optimization built into every call, cutting down your overall token consumption by up to 60% compared to using the tools without that feature. **What does `classify_texts` actually output?** `classify_texts` takes an input string and returns a predefined label (like 'Billing' or 'Technical') along with a score, which tells you how confident the model is in that classification. **What specific structural data does the `tokenize_text` tool return?** It returns the exact integer array segmentation of your input text. This is crucial for debugging, as it lets you audit precisely how many tokens a model sees and what context segments are being used. **How do I verify which Cohere models are available using `list_models`?** `list_models` inspects all internal properties, giving you the names and hashes of available models. You use this to confirm that your current API plan supports the specific model needed for a complex workflow. **When I execute `chat_completion`, how are my credentials kept secure by Vinkius?** Vinkius uses a zero-trust proxy for all credentials. Your keys pass through in transit, but they're never stored on disk, keeping your access tokens completely isolated and safe. **Do I need special setup steps to use the `embed_texts` tool with my existing AI client?** No. Once you connect your preferred AI client through Vinkius, you can immediately start passing text inputs to `embed_texts`. The platform handles all secure credential routing automatically.