# Distance Metrics Engine MCP > Distance Metrics Engine calculates mathematically exact distances between high-dimensional vectors locally. Need Cosine, Euclidean, Manhattan, or Chebyshev metrics for embeddings? This MCP handles vector math without needing cloud APIs or risking model hallucinations. It's essential for any ML workflow where accurate similarity scoring is non-negotiable. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** vector-math, cosine-similarity, euclidean-distance, embeddings, machine-learning, data-processing ## Description When you work with machine learning embeddings, the numbers matter. Calculating metrics like Cosine Similarity between two 1024-dimensional vectors isn't something your AI client can just guess at; it needs perfect math. This MCP handles that complex vector algebra locally on your CPU, guaranteeing accuracy and total data privacy. You don't have to worry about cloud latency or the agent approximating results incorrectly. Instead, you get precise distance scores for every common metric—Cosine, Euclidean, Manhattan, and Chebyshev. These metrics are critical when determining how semantically close two pieces of text or feature vectors actually are. Because it runs locally, your embedding data never leaves your machine. Vinkius brings this functionality into the MCP catalog so your agent can access guaranteed mathematical precision right where you work. ## Tools ### distance_metrics_calculate Calculates exact distances (Cosine, Euclidean, Manhattan) between high-dimensional vectors offline. ## Prompt Examples **Prompt:** ``` Calculate the Cosine similarity between these two embedding vectors. ``` **Response:** ``` The exact cosine similarity is 0.9412, meaning the two documents are highly semantically similar. The cosine distance is 0.0588. ``` **Prompt:** ``` What is the Euclidean distance between [1, 2, 3] and [4, 5, 6]? ``` **Response:** ``` The exact Euclidean distance is 5.196152. The corresponding similarity score (1/(1+d)) is 0.161290. ``` **Prompt:** ``` Measure the Manhattan distance between the user's feature vector and the cluster centroid. ``` **Response:** ``` The Manhattan distance computation returned exactly 12.0. This positions the user in the outer boundary of Cluster 3. ``` ## Capabilities ### Compute Cosine Similarity Determines how semantically related two high-dimensional vectors are using the cosine formula. ### Calculate Euclidean Distance Provides the straight-line distance between two points in a multi-dimensional space. ### Measure Manhattan Distance Calculates the sum of the absolute differences along each dimension, useful for feature comparison. ### Determine Chebyshev Distance Finds the largest difference between corresponding components in two vectors, defining the maximum deviation. ## Use Cases ### Clustering Outlier Detection A data scientist needs to know if a new user's feature vector falls outside an established cluster. Instead of relying on approximate metrics, they use the MCP to calculate the exact Manhattan distance between the user and all known centroids, identifying true outliers with certainty. ### Semantic Search Validation A research analyst has two documents represented by vectors and needs to confirm if they are truly 'highly similar.' They ask their agent to calculate the Cosine similarity using this MCP. The resulting exact score confirms semantic relationship much faster than manual comparison. ### Feature Drift Monitoring An ML engineer is monitoring model drift and needs to compare a current feature vector against a historical baseline vector. They use the Euclidean distance calculation via this MCP, getting an exact deviation score that signals if retraining is required. ### Vector Database Comparison A developer building a similarity search tool requires multiple metric checks (e.g., Cosine and Chebyshev) to validate results before showing them to the user. This MCP executes both tests reliably in one step, providing necessary validation data. ## Benefits - Avoid model hallucinations. Since the MCP runs calculations locally, you get exact mathematical answers for metrics like Cosine Similarity—you don't have to trust an approximation. - Maintain data privacy. Your embedding vectors and weights never leave your machine; this is critical when working with sensitive client or proprietary data sets. - Handle high dimensions fast. It processes large, complex embeddings (like 1536-dimensional OpenAI vectors) in milliseconds, keeping your workflow moving. - Use a full metric suite. You access Cosine, Euclidean, Manhattan, and Chebyshev distances all from one place; you don't need multiple connections for different types of math. - Streamline complex analysis. Instead of running separate scripts for each distance type, the MCP lets your agent calculate everything in one go. ## How It Works The bottom line is you get mathematically perfect vector math results without any network calls or risk of hallucination. 1. You pass your high-dimensional embedding vectors into the MCP. 2. The system runs the required mathematical calculation (e.g., Cosine or Euclidean) locally on your machine's CPU, bypassing external services. 3. Your agent receives an exact numerical result for the specified distance or similarity score. ## Frequently Asked Questions **What is the maximum dimension size for distance_metrics_calculate?** It supports high-dimensional vectors, including 1536-dimensional embeddings. You just need to make sure your input vectors match that length. **Is calculating Cosine similarity with the Distance Metrics Engine secure?** Yes, it's highly secure because the entire calculation runs locally on your CPU. Your embedding data never leaves your machine. **Can I use distance_metrics_calculate for anything other than embeddings?** It calculates standard vector metrics (Cosine, Euclidean, etc.). If your data isn't structured as a high-dimensional vector, this MCP won't help. **Does the Distance Metrics Engine calculate all four major distances?** Yep. It handles Cosine, Euclidean, Manhattan, and Chebyshev metrics in one single tool call for convenience. **How does `distance_metrics_calculate` ensure my proprietary data stays private?** It computes everything locally on your machine. All vector math happens directly through your CPU, so your embedding vectors and model weights never leave your network. This keeps sensitive information fully contained. **What are the performance expectations when running `distance_metrics_calculate`?** Performance is fast because the computation bypasses cloud APIs and network latency. It efficiently handles high-dimensional vectors, delivering precise distance metrics in milliseconds. **How do I integrate `distance_metrics_calculate` into my existing AI client workflow?** You connect your preferred agent via any MCP-compatible client to Vinkius. Once connected, the tool becomes available for direct invocation by your AI client without needing separate API keys or complex setups. **What happens if `distance_metrics_calculate` receives mismatched vector dimensions?** The MCP validates input arrays before it runs the math. If the vectors don't match in size, it throws a specific error detailing the mismatch. This prevents bad calculations and helps you debug fast. **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.