4,500+ servers built on MCP Fusion
Vinkius

Redis Vector MCP. Manage Semantic Search & Embeddings Directly in Redis

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Redis Vector MCP on Cursor AI Code Editor MCP Client Redis Vector MCP on Claude Desktop App MCP Integration Redis Vector MCP on OpenAI Agents SDK MCP Compatible Redis Vector MCP on Visual Studio Code MCP Extension Client Redis Vector MCP on GitHub Copilot AI Agent MCP Integration Redis Vector MCP on Google Gemini AI MCP Integration Redis Vector MCP on Lovable AI Development MCP Client Redis Vector MCP on Mistral AI Agents MCP Compatible Redis Vector MCP on Amazon AWS Bedrock MCP Support

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.

+ 3 more capabilities included
Execute Nearest Neighbor Searches

The agent performs rapid KNN searches by providing a query vector and retrieving the nearest matching records from any defined index.

Manage Index Schemas

It allows you to list all current indexes, check an index's dimensions, or create a new vector index structure on demand.

Write and Update Embeddings

The agent inserts new vectors into specific document keys or overwrites existing embedding data for a key without changing the overall record structure.

Clean Up Data Vectors

You can delete isolated vector documents from Redis, keeping your semantic records clean and preventing bloat.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

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.

create019d75fd

create vector index

Creates a new RediSearch vector index by specifying its name and required dimensions.

delete019d75fd

delete vector

Removes an entire vector document associated with a specific key from Redis.

get019d75fd

get index info

Retrieves detailed metadata, such as dimensions and algorithm type, for one specified vector index.

list019d75fd

list indexes

Returns a list of all available RediSearch vector indexes currently configured in the database.

search019d75fd

search vectors

Performs a KNN similarity search by accepting a JSON array of floats and querying it against an active index.

upsert019d75fd

upsert 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
Start building

Make Your AI Do More

Start with Redis Vector, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ 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

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.

How Redis Vector MCP Works

  1. 1 Authorize the Redis Vector MCP connector. You must point it to a Redis instance running RediSearch.
  2. 2 Prompt your agent with an action, like: 'Find the top 5 nearest neighbors for this JSON embedding array in the 'products-index''.
  3. 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.

Machine Learning Engineer

Runs rapid iteration loops by querying KNN vectors directly from the prompt, eliminating boilerplate code for embedding lookups.

Backend Developer

Maintains semantic storage logic. They use list_indexes to audit schemas and delete_vector to remove obsolete hashes instantly.

Data Architect

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_indexes to audit what's running, then use get_index_info to confirm dimensions before writing any data.
  • Handle embeddings as part of your workflow. upsert_vector lets 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_vector when 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

01

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.

02

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.

03

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.

04

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.

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

How we secure it →

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.

Available Capabilities

create_vector_index delete_vector get_index_info list_indexes search_vectors upsert_vector

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.

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 6 tools

We've already built the connector for Redis Vector. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 6 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.