# Elasticsearch Vector MCP for AI Agents AI Agent Connect

> Elasticsearch Vector MCP. Connect your Elasticsearch cluster to your AI agent to handle dense vector kNN searches, manage index mappings, and perform bulk document indexing. It lets your agent treat your vector database as a first-class storage layer for semantic discovery and high-dimensional data management.

## Overview
- **Category:** brain-trust
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_kUWPWShL0BRuDE0k7qrS1ZYbK8Cj21vwQZnEsEiQ/ai-agent-connect
- **Tags:** vector-search, knn-search, embeddings, semantic-search, indexing, ai-infrastructure

## Description

This Connector lets you talk to your Elasticsearch cluster as if it were just another part of your agent's memory. Instead of writing complex query DSL or manual indexing scripts, you can just tell your agent to find similar items, create new search indexes, or update your existing embeddings. It handles the heavy lifting of interacting with the Lucene partitions, so you can focus on the actual data. Whether you're trying to build a semantic search feature or just need to audit your current dimensional constraints, this connection makes the process direct. You can find this and thousands of other connectors in the Vinkius catalog, making it easy to plug into your existing stack. It's about moving from manual database management to natural language commands for your vector data.

## Tools

### search
Run a dense vector kNN search to find semantically similar documents. This helps you find relevant results based on vector similarity.

### list_indexes
See every active index in your Elasticsearch cluster. This provides a quick overview of your current storage namespaces.

### get_index
Look up the specific mapping and dimension details for a single index. Use this to verify your configuration before indexing.

### index_document
Add a new document with its dense_vector embedding to your storage. This handles the insertion into your Lucene partitions.

### delete_document
Remove a specific record from your physical index using its UUID. This is the fastest way to invalidate specific data.

### create_index
Set up a new dense_vector index with the correct number of dimensions. This allows you to provision new search structures quickly.

## Prompt Examples

**Prompt:** 
```
Find the top 3 products similar to 'leather boots' in the 'footwear-embeddings' index.
```

**Response:** 
```
Searching the 'footwear-embeddings' index for items similar to 'leather boots'...

| Rank | Product Name | Similarity Score |
| :--- | :--- | :--- |
| 1 | Premium Leather Boots | 0.98 |
| 2 | Rugged Winter Boots | 0.94 |
| 3 | Classic Chelsea Boots | 0.91 |

Would you like to see the full metadata for these items?
```

**Prompt:** 
```
Show me all the indexes we have in our cluster and their dimensions.
```

**Response:** 
```
I've retrieved the list of active vector indexes:

*   **product-embeddings**: 1536 dimensions
*   **image-features**: 512 dimensions
*   **user-preferences**: 768 dimensions

Let me know if you'd like me to inspect the mapping for any of these.
```

**Prompt:** 
```
Create a new index called 'user-preferences' with 768 dimensions.
```

**Response:** 
```
I've successfully created the new index.

**Index Name:** `user-preferences`
**Dimensions:** 768
**Status:** Ready for ingestion.

You can now start adding embedding documents to this index.
```

## Capabilities

### Perform kNN searches
Run similarity queries on multi-dimensional embedding arrays to find the most relevant documents.

### Create search indexes
Provision new dense_vector structures with specific dimensions for your vector data.

### List all indexes
See every active storage namespace in your cluster at a glance.

### Get index info
Look up the specific mapping rules and dimensions of a single index.

### Index documents
Add new document entries with their dense_vector embedding payloads to your storage.

### Delete documents
Remove specific records from your physical indices using their unique UUIDs.

## Use Cases

### Testing new embeddings
An AI Engineer wants to see how a new model performs. They ask the agent to `search` a test index with a sample vector to check similarity scores.

### Rapid prototyping
A dev needs a search feature. They ask the agent to `create_index` for 'image-features' and then use `index_document` to populate it.

### Database Auditing
An Ops lead needs to check the cluster. They ask the agent to `list_indexes` and `get_index` to verify all 1536-dimension mappings are correct.

### Data Cleanup
A user needs to remove a specific entry. They ask the agent to `delete_document` using a UUID to ensure the record is gone from the Lucene partition.

## Benefits

- Stop writing complex Query DSL by using `search` to find similar items immediately.
- Provision new search structures quickly using `create_index` without manual configuration.
- Audit your data storage easily by using `list_indexes` to see all active namespaces.
- Verify your embedding dimensions with `get_index` to ensure your cluster is ready for production.
- Update your knowledge base on the fly by using `index_document` for synchronous bulk insertions.
- Clean up your data instantly with `delete_document` to remove specific records by UUID.

## How It Works

The bottom line is that you turn your Elasticsearch cluster into a conversational vector database.

1. Subscribe to this Connector and gather your Host URL and API Key from your Kibana security settings.
2. Provide your credentials to your AI client to establish the connection.
3. Start asking your agent to search, index, or manage your vector data in plain English.

## Frequently Asked Questions

**Can the Elasticsearch Vector MCP help me manage my embeddings?**
Yes, it lets your agent handle the indexing and searching of your dense vector data directly, making it easy to manage your embeddings without manual scripts.

**How do I connect my Elasticsearch cluster to my AI agent?**
You just need your Host URL and an API Key from your Kibana security settings to link the Connector to your AI client.

**Does this Connector support kNN searches?**
It specifically handles dense vector kNN computations to find the most similar items in your data based on semantic similarity.

**Can I use this to delete specific records?**
You can use the delete tool to remove documents from your physical indices using their unique UUIDs, which is great for data cleanup.

**Is this good for checking my index mappings?**
Yes, it allows your agent to pull and display the specific rules and dimensions for any index in your cluster to ensure your configuration is correct.

**Can my agent create new vector indexes for me?**
It can provision new dense_vector structures with the exact dimensions you specify in plain English, saving you from manual configuration.

**Can my agent perform kNN searches using raw vector arrays?**
Yes. Use the 'search' tool. Provide the index name and a JSON array representing your query vector. The agent will perform raw K-Nearest Neighbors computations to find the most semantically similar documents.

**How do I create a new vector index with specific dimensions via chat?**
Use the 'create_index' tool. You can specify the index name and the number of dimensions (e.g., 1536 for OpenAI embeddings). The agent will provision the strictly typed data structure in your Elasticsearch cluster.

**Can I delete a single document from a vector index through the agent?**
Absolutely. Use the 'delete_document' tool with the index and document ID. The agent will enforce immediate document vaporization, stripping the record from the physical Lucene partitions.