Redis Vector MCP. Manage Semantic Search & Embeddings Directly in Redis
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Redis Vector lets your AI agent manage embeddings and run KNN similarity searches natively inside Redis. It turns your database into a full-featured vector store, letting you query complex, high-dimensional data structures—like semantic relationships or image feature vectors—without needing external clients or dedicated ML services.
You can autonomously create indexes (`create_vector_index`), upsert data (`upsert_vector`), and run rapid similarity searches in one go.
What your AI agents can do
Create vector index
Creates a new RediSearch vector index by specifying its name and required dimensions.
Delete vector
Removes an entire vector document associated with a specific key from Redis.
Get index info
Retrieves detailed metadata, such as dimensions and algorithm type, for one specified vector index.
The agent performs rapid KNN searches by providing a query vector and retrieving the nearest matching records from any defined index.
It allows you to list all current indexes, check an index's dimensions, or create a new vector index structure on demand.
The agent inserts new vectors into specific document keys or overwrites existing embedding data for a key without changing the overall record structure.
You can delete isolated vector documents from Redis, keeping your semantic records clean and preventing bloat.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
Redis Vector: 6 Tools for Vector Index Management
These tools give your AI agent full control over the lifecycle of vector data—from creating new indexes to running complex similarity searches.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Redis Vector on Vinkius019d75fdcreate vector index
Creates a new RediSearch vector index by specifying its name and required dimensions.
019d75fddelete vector
Removes an entire vector document associated with a specific key from Redis.
019d75fdget index info
Retrieves detailed metadata, such as dimensions and algorithm type, for one specified vector index.
019d75fdlist indexes
Returns a list of all available RediSearch vector indexes currently configured in the database.
019d75fdsearch vectors
Performs a KNN similarity search by accepting a JSON array of floats and querying it against an active index.
019d75fdupsert vector
Inserts or updates a vector component into a document key, requiring the target key and the embedding as a JSON array.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Redis Vector, then connect any of our 4,900+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,900+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Redis Vector. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 6 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Searching for related information shouldn't require three different modules.
Today, finding relevant data means jumping through hoops. You check your main document store; it gives you a key ID. Then you have to copy that ID into a separate vector database client just to run the similarity search against the embeddings. Finally, you stitch those two results back together in application code.
With Redis Vector MCP Server, that entire multi-step process disappears. You prompt your agent—'Find documents related to this topic.' The agent runs `search_vectors` directly against the index, and it hands you the final, scored list of relevant keys. It's one conversation, one answer.
Redis Vector MCP Server: Control your vector lifecycle with tools like `create_vector_index`.
Manually managing a vector store means constantly running scripts to check if the index exists, or worse, accidentally creating an index with the wrong dimension count. This leads to runtime failures and brittle code that breaks when the data schema changes.
Now you can let your agent handle it. Before any search, the AI checks what's available using `list_indexes`. If a new dataset comes online, it calls `create_vector_index`—all without human intervention or hardcoded logic.
What you can do with this MCP connector
Your agent takes over vector management right inside Redis. It treats your database like a full-featured vector store, letting you query complex data—like semantic relationships or image feature vectors—without needing to spin up external services or write extra client code.
When you connect your AI client via MCP, the server gives it native access to all vector operations. You won't need separate database connections or specialized ML libraries; everything stays contained within Redis.
Managing Your Vector Data Structure
Before running any searches, you gotta set up the index. To see what indexes are already configured in your database, run list_indexes. If you want to know the specific details of an existing index—like its exact dimensions or the underlying search algorithm type—you use get_index_info and point it at the name you care about.
When you're ready for a new data set, you initialize the structure by calling create_vector_index, specifying both the unique name and the required dimensionality for that index.
Writing and Updating Embeddings
Your agent handles the data lifecycle too. You don't have to rebuild entire records just because an embedding changes. To inject new vectors into a document key or overwrite old embeddings without changing the overall record structure, you use upsert_vector. This tool requires the target key and the new embedding array as JSON.
If a vector component is obsolete or needs to be removed entirely, you can clean up with delete_vector. You pass it a specific key, and it wipes out that entire associated vector document from Redis.
Running Similarity Searches (KNN)
The main job is searching. To run a rapid KNN similarity query, your agent calls search_vectors. You just provide an embedding array—that's the JSON array of floats representing your query vector—and it queries that against any active index you’ve established. The result is always the absolute nearest top-K neighbors found in your cluster, giving you semantic relationships instantly.
This setup keeps your entire semantic layer self-contained and fast within Redis. You'll run searches, update data, and manage schemas all through simple function calls to your agent.
019d75fd-9c11-70f3-afb4-a35b466ea1d6 
How Redis Vector MCP Works
- 1 Authorize the Redis Vector MCP connector. You must point it to a Redis instance running RediSearch.
- 2 Prompt your agent with an action, like: 'Find the top 5 nearest neighbors for this JSON embedding array in the 'products-index''.
- 3 The agent uses
search_vectors(or another tool) to query the index directly and returns the list of matching keys and proximity scores.
The bottom line is: you talk naturally to your AI, and it handles all the complex database calls needed for vector math automatically.
Who Is Redis Vector MCP For?
ML Engineers who can't afford time wasted scripting Python drivers. Backend Developers building RAG pipelines who need self-contained semantic storage logic. Data Architects validating Redis as a primary, integrated vector layer instead of just an ancillary cache.
Runs rapid iteration loops by querying KNN vectors directly from the prompt, eliminating boilerplate code for embedding lookups.
Maintains semantic storage logic. They use list_indexes to audit schemas and delete_vector to remove obsolete hashes instantly.
Validates the entire vector environment interactively, using tools like get_index_info to confirm dimension structures for RAG viability.
What Changes When You Connect
- Run rapid, native vector comparisons using
search_vectors. You just provide the query embedding array and get back the top-K nearest matches—no complex client setup needed. - Control your entire schema lifecycle. Use
list_indexesto audit what's running, then useget_index_infoto confirm dimensions before writing any data. - Handle embeddings as part of your workflow.
upsert_vectorlets you attach or update a vector component to an existing document key in Redis with a simple prompt. - Build clean pipelines by controlling the data lifecycle. Use
delete_vectorwhen records become obsolete, keeping your semantic store performant and accurate. - Set up new search capabilities on the fly. When you need a totally fresh index for a new dataset, just call
create_vector_index. It's fast.
Real-World Use Cases
Finding related product FAQs
A support agent needs to find the best article match for vague user input. They prompt their AI client: 'Find 3 top matches in the customer-support-vector index.' The agent executes search_vectors, returning relevant document keys and proximity scores, solving the search instantly.
Updating a user's preference vector
A new ML model generates updated usage vectors for a user. Instead of running an update script, the developer prompts: 'Update the embedding for key user:439:preference with this new array.' The agent runs upsert_vector, making the data immediately queryable.
Auditing index readiness
A Data Architect is setting up a new RAG system. First, they run list_indexes to see what exists. Then, they use get_index_info on the target index to confirm it’s configured for 1536 float dimensions before proceeding.
Cleaning out old data
The team retires an old product line and needs to remove all associated vectors. They prompt: 'Delete vector doc:product:old_sku.' The agent executes delete_vector, keeping the remaining semantic record set clean.
The Tradeoffs
Trying to search without knowing the index.
The user just runs 'Search for similar data' and assumes the AI knows which index name is correct, leading to a failure because no index was specified.
→
Always check first. Use list_indexes to see all available vector indexes names before attempting any search or creation.
Using simple keys for vectors.
Trying to store a complex, high-dimensional embedding by just assigning it to a standard Redis key—this makes it impossible to query mathematically.
→
You must use upsert_vector and ensure the underlying index is created first via create_vector_index. This handles the vector math layer.
Over-relying on simple deletes.
Just calling a delete command without checking if other records depend on that key, resulting in lost data or partial deletions.
→
Before deleting with delete_vector, run get_index_info to confirm the index is still needed. Use structured workflows instead of single commands.
When It Fits, When It Doesn't
Use this MCP Server if your application requires semantic search, high-dimensional data storage, or dynamic indexing within Redis itself. This is for RAG (Retrieval-Augmented Generation) pipelines and ML feature stores.
Don't use it if you only need simple key-value lookups (e.g., 'get user:123'). For those cases, standard Redis commands are faster and simpler. If your goal is merely to track document metadata without vector similarity, a basic hash map works fine. This tool adds significant overhead—the complexity of index management and vector math—but it's necessary if the similarity between data points matters.
Common Questions About Redis Vector MCP
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.
When I use `search_vectors`, what security protocols must be in place to authorize access? +
Authorization relies on standard Redis ACLs. You must configure the connection string with appropriate user credentials and required read permissions for the target index. The MCP connector respects these underlying server-side rules, preventing unauthorized data reads or writes.
If my embedding model changes its output dimension, how do I update the schema using `create_vector_index`? +
You must drop the existing index and recreate it. Use delete_vector to clean up old data first, then run create_vector_index specifying the new, correct vector dimensions (e.g., 3072 instead of 1536). This ensures semantic consistency.
If I send bad data to `upsert_vector`, will it crash my connection or just fail that single record? +
The tool handles invalid input gracefully by failing only the specific operation. If the provided key format is wrong, or the vector array structure is malformed, the connector returns an error code but keeps your overall MCP session stable.
Can I change the similarity metric (like switching from COSINE to EUCLIDEAN) for my index after creation? +
No, you cannot change the core metric of a vector index. The metric is set during index creation using create_vector_index. If you need a different distance measure, you must delete and recreate the entire index structure.
What happens to my data if I run too many queries with `search_vectors` in rapid succession? +
The performance is governed by Redis server load and your network bandwidth. While Vinkius manages connection stability, high-volume querying might trigger rate limits or increased latency on the Redis side. Batching requests helps maintain speed.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.