Redis MCP — Use Cases, Install & Live Demo

Name: Redis MCP Server
Author: redis

Why use it

Key features

Coverage of every core data type: string, hash, list, set, zset, stream, JSON, vector
Key scanning with patterns and TTL inspection
Pub/sub publish + subscribe plus Streams XADD/XREAD
Works against Redis OSS, Redis Stack, Redis Cloud, AWS ElastiCache (with TLS)
Lightweight — no server-side changes needed, one URL config

Live Demo

What it looks like in practice

redis.replay ▶ ready

0/0

Install

Pick your client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "mcp-redis"
      ]
    }
  }
}

Open Claude Desktop → Settings → Developer → Edit Config. Restart after saving.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "mcp-redis"
      ]
    }
  }
}

Cursor uses the same mcpServers schema as Claude Desktop. Project config wins over global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "mcp-redis"
      ]
    }
  }
}

Click the MCP Servers icon in the Cline sidebar, then "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "mcp-redis"
      ]
    }
  }
}

Same shape as Claude Desktop. Restart Windsurf to pick up changes.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "redis",
      "command": "uvx",
      "args": [
        "mcp-redis"
      ]
    }
  ]
}

Continue uses an array of server objects rather than a map.

~/.config/zed/settings.json

{
  "context_servers": {
    "redis": {
      "command": {
        "path": "uvx",
        "args": [
          "mcp-redis"
        ]
      }
    }
  }
}

Add to context_servers. Zed hot-reloads on save.

claude mcp add redis -- uvx mcp-redis

One-liner. Verify with claude mcp list. Remove with claude mcp remove.

Use Cases

Real-world ways to use Redis

Investigate why a cached value is stale or missing

👤 Backend engineers debugging cache bugs ⏱ ~10 min beginner

When to use: A user says 'I updated my profile but it's still showing the old name' — likely a cache invalidation issue.

Prerequisites

Redis URL with at least read access — REDIS_URL=redis://:pw@host:6379/0

Flow

Find the right key

Scan keys matching user:profile:42* — show each with its type and TTL.✓ Copied

→ Matching keys list
Inspect the stored value and expiry

For user:profile:42, GET the value and show the TTL. Is it stale vs expected?✓ Copied

→ Value + TTL + verdict
Bust it deliberately

Delete that key (and any related list/set keys) so the app repopulates on next read. Confirm deletion.✓ Copied

→ DEL returned 1 or more

Outcome: A confirmed-fixed cache with a trail of what was stale and why.

Pitfalls

KEYS * on a big instance stalls the server — Always use SCAN (the server translates scan tools to non-blocking cursors); never KEYS

Audit rate-limit counters for abuse patterns

👤 Platform / abuse team ⏱ ~15 min intermediate

When to use: You suspect a client is bursting against your rate limiter; you want to see live counters and TTLs.

Flow

List active counters

Scan for keys matching ratelimit:* and group by prefix. Show count per group.✓ Copied

→ Prefix histogram
Find top consumers

For ratelimit:api:*, return the 20 keys with the highest integer value.✓ Copied

→ Top-20 offenders
Block or reset

For abusive key ratelimit:api:client_abc, DELETE it so the next call fails open — and add client_abc to blocklist set abuse:blocked with EXPIRE 86400.✓ Copied

→ Key deleted + blocklist updated

Outcome: Live evidence of abuse plus targeted mitigation, all in a few Redis ops.

Pitfalls

Deleting a rate-limit key lets the client burst again immediately — Add to a blocklist set first, then delete the counter — not the other way around

Combine with: sentry

Find and purge orphan session keys consuming memory

👤 SREs responding to a Redis memory alert ⏱ ~20 min intermediate

When to use: Redis is at 85% maxmemory and you need to know what's filling it before it evicts important keys.

Flow

Sample big keys

Find the 50 largest keys by memory (use MEMORY USAGE per sampled key across a SCAN pass).✓ Copied

→ Largest keys list with sizes
Group by prefix and sum

From that sample, group keys by the first colon-segment. Sum sizes per group to find the worst prefix.✓ Copied

→ Prefix → total bytes
Prune with TTL fix

For prefix session: keys without TTL (persistent), set EXPIRE to 86400 seconds. Count how many got updated.✓ Copied

→ Number of keys given a TTL

Outcome: Memory relief plus a root-cause (missing EXPIRE on session writes) to fix in app code.

Pitfalls

MEMORY USAGE is expensive on big hashes/zsets — Sample 5–10k keys via SCAN, not the full keyspace

Combine with: sentry

Inspect a Redis Stream for stuck consumer-group entries

👤 Engineers using Redis Streams for work queues ⏱ ~20 min advanced

When to use: A consumer group is lagging; messages aren't being ack'd; throughput has tanked.

Flow

Check the stream and groups

For stream jobs, show XLEN, consumer groups, and pending count per group.✓ Copied

→ Backlog numbers
Look at pending entries

For group workers, list the top 20 PEL entries (XPENDING) — show idle time and consumer.✓ Copied

→ Stuck message ids
Reclaim or drop

XCLAIM idle>300000 the stuck entries to a fresh consumer; or XACK them if they're safe to drop. Confirm with me which before running.✓ Copied

→ Reclaim/ack summary

Outcome: Stream unblocked with a documented action (claim vs ack) per batch.

Pitfalls

XACK without inspecting the message can silently drop work — Always fetch the message body (XRANGE) and confirm it's safe to drop before XACK

Debug feature-flag rollout stored in Redis hashes

👤 Platform teams using Redis-backed flags ⏱ ~10 min beginner

When to use: A flag isn't behaving as expected for a subset of users.

Flow

Inspect the flag hash

HGETALL flags:new-checkout. Show every field and value.✓ Copied

→ Flag definition
Check override set

SMEMBERS flags:new-checkout:allowlist and flags:new-checkout:blocklist. Is user 42 in either?✓ Copied

→ Membership answers
Fix and verify

SADD user 42 to the allowlist. Re-read HGETALL to confirm flag state is otherwise unchanged.✓ Copied

→ Allowlist updated; other fields identical

Outcome: The flag matches intended state, with a verified change record.

Pitfalls

Writing to flag keys without coordination breaks another admin's ongoing test — Announce in #platform before any write; better, use an admin UI that logs changes

Combine with: sentry

Combinations

Pair with other MCPs for X10 leverage

redis + sentry

Correlate a cache key with the Sentry error that referenced it

Sentry event mentions cache key user:profile:42 as missing. GET the key, check its TTL, and confirm whether it was evicted or never populated.✓ Copied

redis + postgres

Compare cached counts to source-of-truth in Postgres

GET stats:active_users:today from Redis. Run SELECT COUNT(*) FROM users WHERE last_seen > ... in Postgres. Report drift.✓ Copied

redis + filesystem

Export a snapshot of keys for offline analysis

SCAN every key matching session:*, dump key+TTL+size to /tmp/session-audit.jsonl.✓ Copied

Tools

What this MCP exposes

Tool	Inputs	When to call	Cost
scan	pattern: str, count?: int	Discover keys by pattern (always, never use KEYS)	free
type	key: str	Before any data-type-specific op on an unknown key	free
get / set / del	key, value?, ex?	String ops — caches, counters, locks	free
hgetall / hset / hdel	key, field?, value?	Structured records stored as hashes	free
sadd / smembers / sismember / srem	key, member(s)	Blocklists, allowlists, memberships	free
zadd / zrange / zrangebyscore	key, score+member(s)	Leaderboards, priority queues	free
xadd / xrange / xread / xpending / xclaim / xack	stream ops	Work queues on Redis Streams	free
ttl / expire / persist	key, seconds?	Check or set expirations	free
info / memory_usage	section? / key	Capacity and perf inspection	free

Cost & Limits

What this costs to run

API quota: Bounded by Redis command-per-second limits (your instance, not the MCP)
Tokens per call: Most commands <200 tokens; HGETALL/LRANGE scale with data size
Monetary: Free against your existing Redis. Redis Cloud free tier 30MB.
Tip: Always pass a realistic count to SCAN (default 10 is slow at scale; 1000 is a good batch).

Security

Permissions, secrets, blast radius

Minimum scopes: ACL user with `~pattern` and `+@read` for read-only work

Credential storage: REDIS_URL (includes password) in env; prefer TLS with rediss://

Data egress: Direct TCP to your Redis endpoint; no third-party proxy

Never grant: FLUSHALL FLUSHDB CONFIG SET SHUTDOWN

Create a dedicated ACL user (user claude on >pass ~* +@read) for read-only sessions.
Never point at production primary for exploratory work — use a replica if you have one.

Troubleshooting

Common errors and fixes

NOAUTH Authentication required

Password missing from REDIS_URL. Use redis://:password@host:6379.

Verify: redis-cli -u $REDIS_URL PING

MOVED 1234 other-host:6379 (Redis Cluster)

Plain MCP uses standalone client. Point at a cluster-aware proxy or use a non-cluster Redis endpoint.

ERR unknown command 'JSON.GET'

That's Redis Stack only. Either upgrade to Redis Stack / Redis Cloud, or store as hashes.

Verify: redis-cli MODULE LIST

OOM command not allowed when used memory > 'maxmemory'

Redis is full. Check MEMORY STATS, evict or grow the instance, and set TTLs on future writes.

Verify: redis-cli INFO memory

Alternatives

Redis vs others

Alternative	When to use it instead	Tradeoff
Memcached MCP	You have plain KV cache needs, no data structures	Much smaller surface; no lists/sets/streams
DragonflyDB MCP	Redis-compatible but multi-threaded	Newer; not every module works

More

Resources

📖 Read the official README on GitHub

🐙 Browse open issues

🔍 Browse all 400+ MCP servers and Skills