# Distance Metrics Engine MCP for AI Agents AI Agent Connect > Distance Metrics Engine calculates exact Cosine, Euclidean, Manhattan, and Chebyshev distances for high-dimensional vectors. It runs locally on your machine to provide perfect accuracy for embedding comparisons without cloud dependencies or math hallucinations. This makes it a go-to for developers building production-grade machine learning systems that require precision. ## Overview - **Category:** developer-tools - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_y2uLWGNkX2DGyvuukg2OciAQezxFmCM92SNAHYKa/ai-agent-connect - **Tags:** vector-math, cosine-similarity, euclidean-distance, embeddings, machine-learning, data-processing ## Description When you're building stuff with embeddings, you need to know how close two pieces of data actually are. If you ask a standard AI to do the math on a 1536-dimensional vector, it's going to hallucinate. It'll give you a number that looks right but is mathematically garbage. It's just trying to predict what a similarity score might look like based on patterns, not actually doing the multiplication. This Connector takes that heavy lifting off the AI's plate by running the math locally on your own hardware. It handles the complex stuff like Cosine Similarity and Manhattan distances perfectly every time. You get to keep your data private because nothing leaves your machine. It's part of the Vinkius catalog, making it easy to plug into your existing workflow so your agent can actually do the math instead of just guessing. This means your RAG systems stay accurate, your clustering stays consistent, and your production code doesn't break because of a random math error. You get the reliability of a dedicated library with the convenience of an AI-driven workflow. Whether you're comparing user profiles for a recommendation engine or checking how well a query matches a specific document chunk, you need a tool that doesn't take shortcuts. This Connector ensures that the distance between your data points is always based on real math, not an LLM's best guess. ## Tools ### calculate_distance Calculate exact distances (Cosine, Euclidean, Manhattan) between high-dimensional vectors/embeddings offline ## Prompt Examples **Prompt:** ``` What's the similarity between these two vectors? ``` **Response:** ``` The Cosine similarity is **0.9412**, which means the two documents are highly similar semantically. The corresponding cosine distance is **0.0588**. ``` **Prompt:** ``` What's the Euclidean distance between [1, 2, 3] and [4, 5, 6]? ``` **Response:** ``` The exact Euclidean distance is **5.196152**. Based on this, the similarity score is **0.161290**. ``` **Prompt:** ``` Compare these two user profiles using Manhattan distance. ``` **Response:** ``` The Manhattan distance between the two profiles is **12.0**. This puts the user in the outer boundary of the current cluster. ``` ## Capabilities ### Calculate Cosine similarity Get a precise similarity score between two high-dimensional embeddings. ### Compute Euclidean distance Measure the straight-line distance between two data points in a vector space. ### Measure Manhattan distance Calculate the sum of absolute differences for high-dimensional data. ### Compute Chebyshev distance Determine the maximum difference along any single dimension of a vector. ### Run calculations locally Keep your sensitive embedding data on your machine instead of sending it to a cloud API. ## Use Cases ### RAG Similarity Checks A developer needs to check if a query is relevant to a specific chunk. The agent uses distance_metrics_calculate to get a precise similarity score. ### Clustering Analysis A data scientist wants to know which cluster a point belongs to. The agent calculates Manhattan distances to find the closest centroid. ### Privacy-First Vector Search A company can't send vectors to a cloud API for security. They use this Connector to compare embeddings locally on their own machine. ### Feature Engineering An engineer needs to compare user profiles. The agent calculates Chebyshev distances to find the max variance between features. ## Benefits - Stop math hallucinations by moving vector calculations from the AI's guesswork to local execution. - Keep your sensitive embedding data private by running all distance math on your own hardware. - Get a full suite of metrics including Cosine, Euclidean, Manhattan, and Chebyshev in one place. - Handle massive 1536-dimensional vectors with the same speed as smaller ones. - Simplify your RAG pipeline by letting your agent handle similarity checks without extra API calls. ## How It Works The bottom line is you get mathematically perfect vector math without the AI making up the numbers. 1. Connect the Connector to your AI client through the Vinkius dashboard. 2. Provide the AI with two high-dimensional vectors or embeddings. 3. Get back exact distance and similarity scores in milliseconds. ## Frequently Asked Questions **Can the Distance Metrics Engine handle OpenAI embeddings?** Yes, it handles 1536-dimensional vectors perfectly. It's designed to handle the high-dimensional math used by major embedding models. **Does Distance Metrics Engine work offline?** Yes, all calculations happen locally on your machine. You don't need an internet connection to run the math. **What's the difference between Cosine and Euclidean in this Connector?** Cosine measures the angle between vectors, while Euclidean measures the straight-line distance. You can use both to get a better picture of your data. **Is Distance Metrics Engine safe for sensitive data?** Absolutely. Because the math happens locally, your sensitive embedding vectors never leave your machine. **How fast is the Distance Metrics Engine?** It processes high-dimensional vectors in milliseconds, making it fast enough for real-time similarity checks in your apps. **Can I use this for RAG systems?** Yes, it's a great way to calculate similarity between a user's query and the document chunks in your database to ensure better retrieval. **Is Cosine distance the same as Cosine similarity?** No, Cosine Distance equals 1 minus Cosine Similarity. The engine returns both exact values in the JSON response so you always have the complete picture. **Can it compare 1536-dimensional embeddings like OpenAI's?** Yes! It processes any equal-length array instantly. 1536-dimensional vectors are evaluated in milliseconds local, with exact floating-point precision. **What if the two vectors have different lengths?** The engine enforces a strict validation constraint and throws a clear error. Both arrays must be mathematically equal in length — there is no silent truncation or padding.