Redis MCP — Cas d'usage, Installer & Démo en direct

Name: Redis MCP Server
Author: redis

Pourquoi l'utiliser

Fonctionnalités clés

Couverture de tous les types de données principaux : chaîne, hash, liste, ensemble, zset, flux, JSON, vecteur
Analyse des clés par motif et inspection du TTL
Pub/sub publier + s'abonner plus Streams XADD/XREAD
Fonctionne avec Redis OSS, Redis Stack, Redis Cloud, AWS ElastiCache (avec TLS)
Léger — aucune modification côté serveur nécessaire, une seule configuration d'URL

Démo en direct

Aperçu en pratique

redis.replay ▶ prêt

0/0

Installer

Choisissez votre client

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

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

Ouvrez Claude Desktop → Settings → Developer → Edit Config. Redémarrez après avoir enregistré.

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

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

Cursor utilise le même schéma mcpServers que Claude Desktop. La config projet l'emporte sur la globale.

VS Code → Cline → MCP Servers → Edit

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

Cliquez sur l'icône MCP Servers dans la barre latérale Cline, puis "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

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

Même format que Claude Desktop. Redémarrez Windsurf pour appliquer.

~/.continue/config.json

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

Continue utilise un tableau d'objets serveur plutôt qu'une map.

~/.config/zed/settings.json

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

Ajoutez dans context_servers. Zed recharge à chaud à la sauvegarde.

claude mcp add redis -- uvx mcp-redis

Une seule ligne. Vérifiez avec claude mcp list. Supprimez avec claude mcp remove.

Cas d'usage

Usages concrets : Redis

Enquêter sur la raison pour laquelle une valeur mise en cache est obsolète ou manquante

👤 Ingénieurs backend déboguant les bogues de cache ⏱ ~10 min beginner

Quand l'utiliser : Un utilisateur dit 'J'ai mis à jour mon profil mais il affiche toujours l'ancien nom' — probablement un problème d'invalidation du cache.

Prérequis

URL Redis avec au moins accès en lecture — REDIS_URL=redis://:pw@host:6379/0

Déroulement

Trouver la bonne clé

Analysez les clés correspondant à user:profile:42* — affichez chacune avec son type et TTL.✓ Copié

→ Liste des clés correspondantes
Inspecter la valeur stockée et son expiration

Pour user:profile:42, OBTENEZ la valeur et affichez le TTL. Est-elle obsolète par rapport aux attentes ?✓ Copié

→ Valeur + TTL + verdict
Invalider délibérément

Supprimez cette clé (et toute clé de liste/ensemble associée) pour que l'app se remplisse à la prochaine lecture. Confirmez la suppression.✓ Copié

→ DEL a renvoyé 1 ou plus

Résultat : Un cache confirmé comme corrigé avec une trace de ce qui était obsolète et pourquoi.

Pièges

KEYS * sur une grande instance bloque le serveur — Utilisez toujours SCAN (le serveur traduit les outils scan en curseurs non-bloquants); jamais KEYS

Auditer les compteurs de limite de débit pour les modèles d'abus

👤 Équipe de plateforme / d'abus ⏱ ~15 min intermediate

Quand l'utiliser : Vous soupçonnez qu'un client fait des appels en rafales contre votre limiteur de débit; vous voulez voir les compteurs en direct et les TTLs.

Déroulement

Énumérer les compteurs actifs

Analysez les clés correspondant à ratelimit:* et groupez par préfixe. Affichez le nombre par groupe.✓ Copié

→ Histogramme des préfixes
Trouver les consommateurs principaux

Pour ratelimit:api:*, renvoyez les 20 clés avec la valeur entière la plus élevée.✓ Copié

→ 20 principaux contrevenants
Bloquer ou réinitialiser

Pour la clé abusive ratelimit:api:client_abc, SUPPRIMEZ-la pour que l'appel suivant échoue ouvertement — et ajoutez client_abc à l'ensemble de la liste noire abuse:blocked avec EXPIRE 86400.✓ Copié

→ Clé supprimée + liste noire mise à jour

Résultat : Preuves en direct d'abus plus atténuation ciblée, tout en quelques opérations Redis.

Pièges

Supprimer une clé de limite de débit permet au client de faire à nouveau des appels en rafales immédiatement — Ajoutez d'abord à un ensemble de liste noire, puis supprimez le compteur — pas l'inverse

Combiner avec : sentry

Trouver et purger les clés de session orphelines consommant de la mémoire

👤 SREs répondant à une alerte de mémoire Redis ⏱ ~20 min intermediate

Quand l'utiliser : Redis est à 85 % de maxmemory et vous devez savoir ce qui le remplit avant qu'il n'expulse des clés importantes.

Déroulement

Échantillonner les grandes clés

Trouvez les 50 plus grandes clés en mémoire (utilisez MEMORY USAGE par clé échantillonnée dans un passage SCAN).✓ Copié

→ Liste des plus grandes clés avec tailles
Grouper par préfixe et sommer

À partir de cet échantillon, groupez les clés par le premier segment délimité par deux-points. Sommez les tailles par groupe pour trouver le pire préfixe.✓ Copié

→ Préfixe → total bytes
Élaguer avec correction du TTL

Pour les clés avec préfixe session: sans TTL (persistantes), définissez EXPIRE à 86400 secondes. Comptez combien ont été mises à jour.✓ Copié

→ Nombre de clés auxquelles un TTL a été attribué

Résultat : Soulagement de la mémoire plus une cause première (EXPIRE manquante sur les écritures de session) à corriger dans le code de l'app.

Pièges

MEMORY USAGE est coûteux sur les grands hashes/zsets — Échantillonnez 5–10k clés via SCAN, pas l'espace clé complet

Combiner avec : sentry

Inspecter un Stream Redis pour les entrées de groupe de consommateurs bloquées

👤 Ingénieurs utilisant Redis Streams pour les files de travail ⏱ ~20 min advanced

Quand l'utiliser : Un groupe de consommateurs est en retard; les messages ne sont pas ack'd; le débit a chuté.

Déroulement

Vérifier le flux et les groupes

Pour le flux jobs, affichez XLEN, les groupes de consommateurs et le nombre d'attente par groupe.✓ Copié

→ Nombres d'arriéré
Regarder les entrées en attente

Pour le groupe workers, énumérez les 20 principales entrées PEL (XPENDING) — affichez le temps d'inactivité et le consommateur.✓ Copié

→ IDs de messages bloqués
Récupérer ou supprimer

XCLAIM idle>300000 les entrées bloquées à un consommateur nouveau; ou XACK-les s'il est sûr de les supprimer. Confirmez avec moi lequel avant d'exécuter.✓ Copié

→ Résumé de récupération/ack

Résultat : Flux débloqué avec une action documentée (réclamation vs ack) par lot.

Pièges

XACK sans inspecter le message peut supprimer silencieusement du travail — Récupérez toujours le corps du message (XRANGE) et confirmez qu'il est sûr de le supprimer avant XACK

Déboguer le déploiement du drapeau de fonctionnalité stocké dans les hashes Redis

👤 Les équipes de plateforme utilisant des drapeaux sauvegardés Redis ⏱ ~10 min beginner

Quand l'utiliser : Un drapeau ne se comporte pas comme prévu pour un sous-ensemble d'utilisateurs.

Déroulement

Inspecter le hash du drapeau

HGETALL flags:new-checkout. Affichez chaque champ et valeur.✓ Copié

→ Définition du drapeau
Vérifier l'ensemble de remplacement

SMEMBERS flags:new-checkout:allowlist et flags:new-checkout:blocklist. L'utilisateur 42 est-il dans l'un ou l'autre ?✓ Copié

→ Réponses d'adhésion
Corriger et vérifier

SADD utilisateur 42 à la liste blanche. Relisez HGETALL pour confirmer que l'état du drapeau est par ailleurs inchangé.✓ Copié

→ Liste blanche mise à jour; les autres champs sont identiques

Résultat : Le drapeau correspond à l'état prévu, avec un enregistrement de modification vérifié.

Pièges

L'écriture dans les clés de drapeau sans coordination casse le test en cours d'un autre administrateur — Annoncez dans #platform avant toute écriture; mieux, utilisez une interface d'administration qui enregistre les modifications

Combiner avec : sentry

Combinaisons

Associez-le à d'autres MCPs pour un effet X10

redis + sentry

Corréler une clé de cache avec l'erreur Sentry qui l'a référencée

L'événement Sentry mentionne la clé de cache user:profile:42 comme manquante. OBTENEZ la clé, vérifiez son TTL et confirmez si elle a été expulsée ou jamais remplie.✓ Copié

redis + postgres

Comparer les nombres en cache à la source de vérité dans Postgres

OBTENEZ stats:active_users:today depuis Redis. Exécutez SELECT COUNT(*) FROM users WHERE last_seen > ... dans Postgres. Signalez la dérive.✓ Copié

redis + filesystem

Exporter un instantané des clés pour une analyse hors ligne

ANALYSEZ chaque clé correspondant à session:*, videz clé+TTL+taille à /tmp/session-audit.jsonl.✓ Copié

Outils

Ce que ce MCP expose

Outil	Entrées	Quand appeler	Coût
scan	pattern: str, count?: int	Découvrez les clés par motif (toujours, jamais utiliser KEYS)	free
type	key: str	Avant toute opération spécifique au type de données sur une clé inconnue	free
get / set / del	key, value?, ex?	Opérations de chaîne — caches, compteurs, verrous	free
hgetall / hset / hdel	key, field?, value?	Enregistrements structurés stockés en tant que hashes	free
sadd / smembers / sismember / srem	key, member(s)	Listes noires, listes blanches, adhésions	free
zadd / zrange / zrangebyscore	key, score+member(s)	Classements, files de priorité	free
xadd / xrange / xread / xpending / xclaim / xack	stream ops	Files de travail sur Redis Streams	free
ttl / expire / persist	key, seconds?	Vérifier ou définir les expirations	free
info / memory_usage	section? / key	Inspection de la capacité et des perf	free

Coût et limites

Coût d'exécution

Quota d'API: Limité par les limites de Redis commande par seconde (votre instance, pas le MCP)
Tokens par appel: La plupart des commandes <200 tokens; HGETALL/LRANGE évoluent avec la taille des données
Monétaire: Gratuit contre votre Redis existant. Tier gratuit Redis Cloud 30MB.
Astuce: Passez toujours un count réaliste à SCAN (par défaut 10 est lent à l'échelle; 1000 est un bon lot).

Sécurité

Permissions, secrets, portée

Portées minimales : Utilisateur ACL avec `~pattern` et `+@read` pour le travail en lecture seule

Stockage des identifiants : REDIS_URL (inclut le mot de passe) dans env; préférez TLS avec rediss://

Sortie de données : TCP direct à votre point de terminaison Redis; aucun proxy tiers

Ne jamais accorder : FLUSHALL FLUSHDB CONFIG SET SHUTDOWN

Créez un utilisateur ACL dédié (user claude on >pass ~* +@read) pour les sessions en lecture seule.
Ne pointez jamais vers le principal de production pour le travail exploratoire — utilisez un réplica si vous en avez un.

Dépannage

Erreurs courantes et correctifs

NOAUTH Authentication required

Mot de passe manquant de REDIS_URL. Utilisez redis://:password@host:6379.

Vérifier : redis-cli -u $REDIS_URL PING

MOVED 1234 other-host:6379 (Redis Cluster)

MCP simple utilise un client autonome. Pointez vers un proxy compatible avec les clusters ou utilisez un point de terminaison Redis non-cluster.

ERR unknown command 'JSON.GET'

C'est Redis Stack uniquement. Soit mettez à niveau vers Redis Stack / Redis Cloud, soit stockez en tant que hashes.

Vérifier : redis-cli MODULE LIST

OOM command not allowed when used memory > 'maxmemory'

Redis est plein. Vérifiez MEMORY STATS, expulsez ou développez l'instance et définissez les TTLs sur les écritures futures.

Vérifier : redis-cli INFO memory

Alternatives

Redis vs autres

Alternative	Quand l'utiliser	Compromis
Memcached MCP	Vous avez des besoins simples de cache KV, pas de structures de données	Surface beaucoup plus petite; pas de listes/ensembles/flux
DragonflyDB MCP	Compatible avec Redis mais multi-thread	Plus récent; tous les modules ne fonctionnent pas

Plus

Ressources

📖 Lire le README officiel sur GitHub

🐙 Voir les issues ouvertes

🔍 Parcourir les 400+ serveurs MCP et Skills