# Redis Vector MCP for AI Agents AI Agent Connect

> Redis Vector lets your AI agent act as a dedicated administrator for your vector database. It handles everything from creating new KNN indexes and managing geometric data to running similarity searches on embeddings. Instead of writing boilerplate code to talk to Redis, your agent can now query, update, and audit your semantic search infrastructure directly.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_zP1SqypHeKOFu0yRPw2yTUOrfnlmdOQBZrAWkuF4/ai-agent-connect
- **Tags:** vector-search, embeddings, semantic-search, knn-search, indexing, machine-learning-data

## Description

The Redis Vector MCP lets your AI agent act as a dedicated administrator for your vector database. You're likely dealing with a mountain of unstructured data and need a way to make it searchable by meaning rather than just keywords. This Connector bridges that gap by letting your AI agent interact directly with your Redis instance. It turns your conversational interface into a command center for your vector storage. You can ask your agent to find similar items in a collection, build out new indexes for different types of data, or clean up old records to keep your search results accurate. It's about moving away from manual scripting and letting the agent handle the heavy lifting of database management. When you find this in the Vinkius catalog, you're getting a way to make your RAG pipelines more interactive and easier to maintain. You don't have to jump between your terminal and your AI client to check index dimensions or update a specific vector. It just works. Instead of wrestling with connection strings and boilerplate drivers, you just give your agent a goal. Whether you're auditing your current setup or injecting new geometric data, the agent handles the interaction with the RediSearch module for you. This keeps your focus on the logic of your application rather than the plumbing of your database.

## Tools

### search_vectors
Perform a KNN similarity search using a JSON array of floats. This is the primary way to find related content.

### get_index_info
Pull the metadata and configuration details for a specific index. It helps you verify dimensions and search metrics.

### list_indexes
Get a full list of all vector indexes in your Redis instance. This is perfect for auditing your current setup.

### upsert_vector
Insert or update a vector in a Redis hash using a document key. Use this to keep your embeddings synced with your data.

### create_vector_index
Create a new RediSearch vector index by specifying the name and dimensions. This is how you set up new search spaces for your data.

### delete_vector
Remove a specific vector document from your Redis database. Use this to keep your storage clean and up to date.

## Prompt Examples

**Prompt:** 
```
Find the top 3 similar records for this vector: [0.1, -0.2, 0.5, 0.8, -0.1...]
```

**Response:** 
```
I've performed a KNN similarity search in your index. Here are the 3 nearest matches based on the vector provided:

| Document ID | Similarity Score |
| :--- | :--- |
| doc:faq:882 | 0.89 |
| doc:faq:104 | 0.81 |
| doc:faq:002 | 0.77 |
```

**Prompt:** 
```
Create a new index for my 'user-profiles' with 768 dimensions.
```

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

**Index Details:**
- **Name:** user-profiles
- **Dimensions:** 768
- **Status:** Active and ready for embedding injection.
```

**Prompt:** 
```
What are the settings for 'product-search'?
```

**Response:** 
```
I've retrieved the configuration for the 'product-search' index:

- **Dimensions:** 1536
- **Algorithm:** HNSW
- **Metric:** COSINE
- **Document Count:** 5,000
```

## Capabilities

### Run similarity searches
Get the closest matches for a given embedding array instantly.

### Create vector indexes
Set up new KNN indexes with specific dimensions and metrics.

### Update vector data
Modify or add new geometric components to existing records.

### List all indexes
See every vector index currently loaded in your Redis instance.

### Retrieve index details
Check the dimensions, algorithms, and metrics of a specific index.

### Purge old embeddings
Remove outdated vector data to keep your semantic search clean.

## Use Cases

### Finding similar products
A customer support agent finds the 3 most relevant FAQ entries based on a user's specific problem description using search_vectors.

### Dynamic index creation
An ML engineer tells the agent to create a new 1536-dimensional index for a new batch of product images using create_vector_index.

### Data cleanup
A backend dev asks the agent to purge all embeddings associated with deleted user accounts to maintain privacy using delete_vector.

### Schema validation
A data architect asks the agent to list all indexes and check the COSINE metric on the main product index using list_indexes and get_index_info.

## Benefits

- Faster RAG development because you can query embeddings using search_vectors directly from a prompt.
- Easier index auditing by using list_indexes to see every active vector space in your Redis stack.
- Cleaner data management since you can use delete_vector to remove stale embeddings without manual scripts.
- Precise configuration control by using get_index_info to verify dimensions and HNSW settings.
- Dynamic data updates that let you use upsert_vector to keep your semantic records in sync with your app.
- Reduced boilerplate code because your agent handles the connection logic to your RediSearch module.

## How It Works

The bottom line is this Connector turns your AI agent into a native administrator for your Redis vector database.

1. Connect the Redis Vector MCP to your AI client using your existing Redis URL.
2. Ensure your Redis instance has the RediSearch module enabled for vector support.
3. Ask your agent to perform tasks like searching for neighbors or creating new indexes.

## Frequently Asked Questions

**Can the Redis Vector MCP help with my RAG pipeline?**
Yes, it connects your AI agent to your Redis vector store. This allows your agent to perform similarity searches and manage embeddings directly, which is a core part of building a Retrieval-Augmented Generation system.

**Do I need to write code to use the Redis Vector MCP?**
No, you don't need to write any custom drivers. Once the Connector is connected to your AI client, you can just use plain English to ask your agent to perform searches, update records, or manage your indexes.

**How does the Redis Vector MCP handle similarity searches?**
It allows your agent to execute native KNN similarity searches. You just provide the embedding array, and the agent retrieves the nearest neighbors from your Redis instance for you.

**Can I use the Redis Vector MCP to manage my embeddings?**
Absolutely. You can use it to inject new embeddings, update existing ones, or delete old records to keep your semantic data clean and accurate.

**Does the Redis Vector MCP work with any Redis instance?**
It works with Redis instances that have the RediSearch module installed and enabled for vector search. This is the standard way to handle vector data in the Redis ecosystem.

**How do I check my index dimensions with the Redis Vector MCP?**
You can simply ask your agent to check the info for a specific index. It will pull the metadata for you, showing dimensions, algorithms, and other configuration details.

**What is the format required for the 'Redis URL' parameter?**
The parameter requires standard Redis URI string formatting. Typically it looks like `redis://[username]:[password]@[host]:[port]`. For TLS/SSL-enabled endpoints spanning secure setups, use the `rediss://` scheme prefix.

**Does my Redis instance strictly need the RediSearch module?**
Yes, absolutely. The base Redis product (standard open-source) only manages key-value caching out of the box. You must be running the Redis Stack or a managed tier (like Redis Enterprise or compatible cloud offerings) that explicitly includes RediSearch to generate and query KNN vector indexes.

**Can I query using embedding arrays output directly from OpenAI models?**
Yes. Once you receive your numerical float array from an embedding model (like text-embedding-ada-002), you can pipe that exact JSON array into the `search_vectors` agent tool alongside the relevant index name to perform immediate proximity lookups.