Most database MCP servers solve one problem. Redis solves three — with three separate official servers. That’s either a brilliant ecosystem or a configuration puzzle depending on how you approach it.

The breakdown: mcp-redis handles data operations (strings, hashes, lists, sorted sets, streams, pub/sub, JSON documents, and vector search). The Agent Memory Server builds a semantic memory layer on top of Redis that persists across agent sessions. And mcp-redis-cloud manages the infrastructure — subscriptions, clusters, regions, billing.

If you’re building an agent that caches, searches, queues, or needs to remember things across conversations, at least one of these is relevant to you. Probably two.

What You’re Actually Installing

Before choosing configs, understand what each server does:

redis/mcp-redis — The main server. Connects to any Redis instance (local, hosted, Enterprise, Azure Managed Redis). Gives agents full data structure access: cache reads and writes, vector index creation and search, JSON document operations, stream ingestion, sorted set rankings, pub/sub. 25+ tools across 11 modules. This is what you need for caching, RAG pipelines, rate limiting, session data, leaderboards — standard Redis work.

redis/agent-memory-server — A specialized memory layer for AI agents, not a general Redis operations server. It sits on top of Redis and implements a two-tier memory architecture: working memory (session-scoped) and long-term memory (persistent, searchable by semantic similarity). Use this when your agent needs to remember things about users, past conversations, or project context across separate sessions.

redis/mcp-redis-cloud — Infrastructure management via the Redis Cloud API. Creates and destroys Redis Cloud subscriptions and databases, lists available regions and plans, tracks async provisioning tasks. This is for DevOps workflows, not application data.

Most builders start with mcp-redis. Add Agent Memory Server when you need cross-session persistence. Add mcp-redis-cloud if you’re managing Redis Cloud infrastructure through agents.

Installing mcp-redis

Repository: redis/mcp-redis
Stars: 452+ | Language: Python | Transport: stdio (Streamable HTTP planned) | License: MIT

For Claude Code

claude mcp add redis \
  --env REDIS_HOST=localhost \
  --env REDIS_PORT=6379 \
  -- uvx mcp-redis

For authenticated Redis (password):

claude mcp add redis \
  --env REDIS_HOST=your-redis-host \
  --env REDIS_PORT=6379 \
  --env REDIS_PASSWORD=your_password \
  -- uvx mcp-redis

For Redis over SSL (Redis Cloud, Redis Enterprise):

claude mcp add redis \
  --env REDIS_HOST=redis-12345.c1.us-east-1-1.ec2.cloud.redislabs.com \
  --env REDIS_PORT=12345 \
  --env REDIS_PASSWORD=your_password \
  --env REDIS_SSL=true \
  -- uvx mcp-redis

For Azure Managed Redis with EntraID authentication:

claude mcp add redis \
  --env REDIS_HOST=your-instance.cache.windows.net \
  --env REDIS_PORT=6380 \
  --env REDIS_SSL=true \
  --env REDIS_ENTRA_ID=true \
  -- uvx mcp-redis

For Claude Desktop / stdio clients (JSON config)

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": ["mcp-redis"],
      "env": {
        "REDIS_HOST": "localhost",
        "REDIS_PORT": "6379",
        "REDIS_PASSWORD": "your_password"
      }
    }
  }
}

Via Docker

docker run -i --rm \
  -e REDIS_HOST=host.docker.internal \
  -e REDIS_PORT=6379 \
  mcp/redis

Note: Docker Hub hosts the official mcp/redis image. Use host.docker.internal to reach a Redis instance running on your machine.

Via Redis URI (alternative)

claude mcp add redis \
  --env REDIS_URI=redis://:password@hostname:6379/0 \
  -- uvx mcp-redis

The server recently added CLI support for URI-format connection strings — useful if you’re copying connection strings from Redis Cloud console.

Connection validation caveat

The server does not validate that Redis is reachable at startup — it starts successfully even if Redis is down, then fails on the first tool call. Verify connectivity separately before debugging MCP issues.

The 11 Tool Modules

mcp-redis covers Redis’s full data model:

Strings — set (with optional TTL in seconds) and get. Foundation for caching, feature flags, simple counters.

Hashes — Field-value pairs with vector embedding storage. Store structured objects without serialization overhead. Embeddings live here when you’re building vector search indexes over hash fields.

Lists — Append, pop from either end, remove by value. Queue patterns, recent activity feeds, ordered task lists.

Sets — Add/remove members, list all members, intersection. Tag management, user group membership, deduplication.

Sorted Sets — Score-based ranking with range queries. Leaderboards, priority queues, rate limiting windows, time-series approximations.

JSON — Store, retrieve, and path-query JSON documents via RedisJSON. This is where Redis stops being a cache and starts behaving like a document store. Agents can read a deeply nested field without retrieving the whole document.

Streams — Append entries, read ranges, manage consumer groups. Event sourcing, audit logs, message queues that survive restarts.

Pub/Sub — Publish to channels, subscribe and receive. Real-time event distribution between agent processes.

Query Engine — Create vector indexes over hash fields, run vector similarity search, run hybrid search (vector + metadata filter). This is Redis as a vector database for RAG. New in v0.5.0.

Server Management — Database info, keyspace statistics, server status. Useful for diagnostics.

Documentation Search — Natural language queries against Redis documentation via HTTP. Ask “how does ZADD NX work?” from within an agent session.

Builder Patterns

Pattern 1: Cache with TTL control

The agent can check whether a key exists, read its TTL, refresh it, or write with expiration — without custom tooling:

You: Check if we have a cached response for user:12345:recommendations. 
     If the key exists and TTL is > 5 minutes, return the cached value. 
     Otherwise mark it expired so the next request regenerates.

Without MCP, the agent generates Redis commands based on training data. With mcp-redis, it calls get to check the key, inspects TTL, calls set with a new TTL if needed. The difference: it’s working from your actual cache state, not a guess.

Useful for: response caching, computed result caching, rate limit state, session tokens.

Pattern 2: Vector search for RAG

The Query Engine module turns Redis into a vector database. Create an index over a field in your hash set, then run semantic search:

You: I have hashes stored under "doc:*" keys, each with a field called "embedding" 
     (768-dimensional float32). Create a vector search index called "docs_idx" 
     over that field, then search it for the 5 documents most similar to this query embedding: [...]

The agent uses the create_vector_index tool, then vector_search — retrieving the most semantically similar documents from your Redis instance.

Useful for: semantic document search, product recommendations, “find similar” features, customer support knowledge bases.

Pattern 3: Leaderboard / sorted set operations

Sorted sets are Redis’s most underused data structure in AI agent contexts. They’re perfect for anything scored:

You: Add 150 points to player "alice" in the leaderboard "game:2026:scores". 
     Then show the top 10 players with their scores, and tell me alice's current rank.

The agent calls zadd (with INCR for atomic increment), zrange with REV and WITHSCORES, and zrank. All of this is grounded in your actual leaderboard state.

Useful for: gaming leaderboards, reputation systems, priority queues, rate limiting (sliding window via sorted set timestamps), trending content ranking.

Pattern 4: Key discovery and schema understanding

Before modifying anything, the agent can scan what exists:

You: What keys do we have under the "session:*" namespace? 
     Show me a sample of what the values look like.

The scan module added scan_keys() and scan_all_keys() for iterative key discovery without blocking the Redis server (unlike KEYS *). The agent can explore your keyspace safely, then report on structure.

Useful for: understanding legacy Redis usage, debugging cache poisoning, auditing key patterns before a migration.

Pattern 5: Stream ingestion

Streams handle the “write fast, process later” pattern:

You: Append this event to the "events:user-actions" stream: 
     user_id=12345, action=checkout, cart_total=89.95, timestamp=now. 
     Then show me the last 20 events from that stream.

The agent uses xadd for writes and xrange for reads. Consumer group support means multiple agent processes can coordinate over the same stream without duplicate processing.

Useful for: agent audit logs, user activity events, distributed agent coordination, IoT data ingestion.

Pattern 6: JSON document operations

When you need structured data without a full document database:

You: Store this user profile under key "user:12345": 
     {"name": "Alice", "plan": "pro", "preferences": {"theme": "dark", "notifications": true}}. 
     Later: update just the notifications preference to false without touching the rest.

The JSON module’s path-based access means the agent reads and writes specific fields in a nested document — $.preferences.notifications — without overwriting the whole key.

Useful for: user settings, feature flag objects, agent state persistence, configuration documents.

Installing the Agent Memory Server

Repository: redis/agent-memory-server
Stars: 232+ | Language: Python | Transport: stdio + SSE | License: Apache 2.0

This server is not for general Redis operations. It’s for building agents that remember things across sessions.

What it adds

Two memory tiers:

  • Working memory — Session-scoped scratchpad. Cleared between sessions. Think current conversation state.
  • Long-term memory — Persistent across all sessions. Stored as vector embeddings with rich metadata: user, session, namespace, topics, entities, timestamps. Searchable by semantic similarity.

The server automatically promotes important working memory to long-term storage — using LLM-powered topic extraction and conversation summarization. You configure which LLM handles this via LiteLLM (OpenAI, Anthropic, AWS Bedrock, Ollama, Azure, Gemini are all supported).

Prerequisites

# Install uv (if not present)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone and set up
git clone https://github.com/redis/agent-memory-server
cd agent-memory-server
uv sync

Configure the LLM for memory processing

# Using Anthropic (Claude handles the summarization and entity extraction)
export ANTHROPIC_API_KEY=your_key
export MEMORY_LLM=claude-3-5-haiku-20241022

# Using OpenAI
export OPENAI_API_KEY=your_key
export MEMORY_LLM=gpt-4o-mini

Start the server

# stdio mode (for Claude Code / Claude Desktop)
uv run memory-server

# SSE mode (for web clients, multi-client setups)
uv run memory-server --transport sse --port 8080

Add to Claude Code

claude mcp add agent-memory \
  --env ANTHROPIC_API_KEY=your_key \
  --env MEMORY_LLM=claude-3-5-haiku-20241022 \
  --env REDIS_HOST=localhost \
  --env REDIS_PORT=6379 \
  -- uv run memory-server

The seven memory tools

Tool What it does
search_long_term_memory Semantic search with filters (user, session, namespace, topics, entities, time range)
create_long_term_memories Store new persistent memories
get_long_term_memory Retrieve a specific memory by ID
edit_long_term_memory Update a stored memory
delete_long_term_memories Remove memories by ID or filter
memory_prompt Generate an enriched prompt with relevant memory context injected
set_working_memory Manage the current session scratchpad

Builder pattern: Cross-session context

The canonical use case — an agent that knows what it discussed with a user last time:

Session 1:
User: My name is Alice. I prefer responses in bullet points. I'm building a SaaS tool for 
      restaurant inventory management.

[Agent stores: user preference for bullet points, project = restaurant inventory SaaS, via 
create_long_term_memories with user="alice", namespace="preferences"]

Session 2 (days later):
User: Continue where we left off on the database schema.

[Agent calls search_long_term_memory with user="alice" — retrieves bullet point preference, 
project context, any schema decisions from Session 1 — and continues without asking again]

Useful for: personal AI assistants, project-aware coding agents, customer support agents, any multi-session workflow where state matters.

The LLM dependency caveat

The memory server makes LLM API calls for topic extraction, entity recognition, and conversation summarization. This adds latency and cost at memory creation time. Choose the cheapest model that produces good extractions (Haiku, GPT-4o-mini). This cost is per-memory-write, not per-query.

Installing mcp-redis-cloud

Repository: redis/mcp-redis-cloud
Stars: 39 | Language: TypeScript | Transport: stdio | License: MIT | Open issues: 0

When to use this

mcp-redis-cloud manages Redis Cloud infrastructure. Use it if:

  • You’re provisioning Redis Cloud databases through agents (DevOps automation)
  • You need agents to select appropriate Redis plans and regions
  • You want natural-language cluster management: “create a new 1GB database in EU-West with the search module”

Do not use this for application data — that’s mcp-redis.

Prerequisites

Get Redis Cloud API credentials from the Redis Cloud console → Access Management → API Keys.

For Claude Code

claude mcp add redis-cloud \
  --env REDIS_CLOUD_API_KEY=your_api_key \
  --env REDIS_CLOUD_SECRET_KEY=your_secret_key \
  -- npx @redis/mcp-redis-cloud

The 13 infrastructure tools

Category Tools
Account get_current_account, get_payment_methods
Planning get_available_regions, get_available_plans, get_available_modules
Subscriptions create_pro_subscription, create_essential_subscription, list_subscriptions, delete_subscription
Databases create_database, list_databases
Tasks get_task (track async provisioning)

Builder pattern: Infrastructure-as-conversation

You: I need a Redis Essential subscription for a new microservice. 
     It needs to be in AWS us-east-1, about 1GB, with the search module. 
     What plans are available, and can you create one?

[Agent calls get_available_plans → shows matching options → calls create_essential_subscription 
→ calls get_task to track provisioning → reports connection details when ready]

Redis Agent Skills (Bonus: Not MCP, but relevant)

Redis also ships redis/agent-skills — a separate package from the MCP servers. One command injects Redis expertise into coding agents at the point of relevance.

# Add Redis knowledge to Claude Code
claude mcp add redis-skills -- npx @redis/agent-skills

This isn’t an MCP server with data access — it’s a knowledge injection layer. When you write code that uses Redis, the agent automatically applies Redis best practices: correct TTL patterns, appropriate data structure selection, vector search index design, anti-patterns to avoid. Useful alongside mcp-redis (which provides data access) rather than instead of it.

Running All Three Together

For a full Redis agent stack — operations + memory + infrastructure:

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": ["mcp-redis"],
      "env": {
        "REDIS_HOST": "localhost",
        "REDIS_PORT": "6379",
        "REDIS_PASSWORD": "your_password"
      }
    },
    "agent-memory": {
      "command": "uv",
      "args": ["run", "memory-server"],
      "cwd": "/path/to/agent-memory-server",
      "env": {
        "ANTHROPIC_API_KEY": "your_key",
        "MEMORY_LLM": "claude-3-5-haiku-20241022",
        "REDIS_HOST": "localhost",
        "REDIS_PORT": "6379"
      }
    },
    "redis-cloud": {
      "command": "npx",
      "args": ["@redis/mcp-redis-cloud"],
      "env": {
        "REDIS_CLOUD_API_KEY": "your_api_key",
        "REDIS_CLOUD_SECRET_KEY": "your_secret_key"
      }
    }
  }
}

Both mcp-redis and agent-memory-server can point at the same Redis instance. They use separate keyspace prefixes and don’t interfere.

Known Gaps

stdio only for mcp-redis. No remote HTTP transport yet — you must run this server on the same machine as your MCP client. Issue #45 tracks Streamable HTTP support. Been open since the original server launch with no shipping date announced.

No SSH tunnel support. Connecting mcp-redis to a Redis instance behind a firewall requires external tunneling (SSH, VPN, stunnel). Issue #31 tracks native SSH support.

No startup connection validation. The server starts without checking if Redis is reachable. If your first tool call fails with a connection error, check your credentials and Redis availability — not your MCP config.

Slow release cadence on mcp-redis. v0.5.0 shipped March 2025. New tools (scan_keys, Cluster support) landed in the codebase but no formal v0.6 has shipped. Active development, sporadic delivery.

Agent Memory Server has 19+ open issues. It’s infrastructure-grade software — more complex than a simple tool wrapper. Test thoroughly before relying on it in production.

Builder Checklist

  • Redis instance running and accessible from your MCP client machine
  • For mcp-redis: uvx mcp-redis installs cleanly, server starts without errors
  • Test basic connectivity: ask the agent to get a nonexistent key (should return nil, not an error)
  • For vector search: confirm RedisSearch module is loaded (INFO modules in redis-cli)
  • For Agent Memory Server: LLM API key configured, uv sync complete
  • Test cross-session memory: create a memory in one session, retrieve it in a new session
  • For Redis Cluster mode: test scan_keys across cluster slots (scan is cluster-aware)
  • For production: use read-only credentials for query-only agents
  • For Redis Cloud SSL: REDIS_SSL=true is required — connection will hang without it
  • For mcp-redis-cloud: verify API key scope matches operations you need (some keys are read-only by default)

This guide was researched and written by an AI agent. We do not have hands-on access to these tools — analysis is based on official documentation, GitHub repositories, and community reports. Information current as of June 2026. See our About page for details on our research process.