Redis MCP Server

Una interfaz de lenguaje natural para que aplicaciones agentivas gestionen y busquen datos en Redis.

Documentación

Redis MCP Server

Resumen

El servidor Redis MCP es una interfaz de lenguaje natural diseñada para aplicaciones agénticas que gestionan y buscan datos en Redis de manera eficiente. Se integra perfectamente con clientes MCP (Model Content Protocol), lo que permite que los flujos de trabajo impulsados por IA interactúen con datos estructurados y no estructurados en Redis. Con este servidor MCP, puedes hacer preguntas como:

"Almacenar toda la conversación en un stream"
"Almacenar en caché este elemento"
"Almacenar la sesión con un tiempo de expiración"
"Indexar y buscar este vector"

Características

Consultas en lenguaje natural: Permite a los agentes de IA consultar y actualizar Redis usando lenguaje natural.
Integración perfecta con MCP: Funciona con cualquier cliente MCP para una comunicación fluida.
Soporte completo de Redis: Maneja hashes, listas, conjuntos, conjuntos ordenados, streams y más.
Búsqueda y filtrado: Admite recuperación y búsqueda eficiente de datos en Redis.
Escalable y ligero: Diseñado para operaciones de datos de alto rendimiento.
Autenticación EntraID: Soporte nativo para la autenticación de Azure Active Directory con Azure Managed Redis.
El servidor Redis MCP soporta el transporte stdio transporte. El soporte para el transporte stremable-http se añadirá en el futuro.

Herramientas

Este servidor MCP proporciona herramientas para gestionar los datos almacenados en Redis.

string herramientas para establecer y obtener cadenas con expiración. Útiles para almacenar valores de configuración simples, datos de sesión o respuestas en caché.
hash herramientas para almacenar pares de campo-valor dentro de una sola clave. El hash puede almacenar incrustaciones vectoriales. Útiles para representar objetos con múltiples atributos, perfiles de usuario o información de producto donde los campos se pueden acceder individualmente.
list herramientas con operaciones comunes para añadir y extraer elementos. Útiles para colas, intermediarios de mensajes o mantener una lista de las acciones más recientes.
set herramientas para añadir, eliminar y listar miembros de conjuntos. Útiles para rastrear valores únicos como IDs de usuario o etiquetas, y para realizar operaciones de conjuntos como la intersección.
sorted set herramientas para gestionar datos, por ejemplo, tablas de clasificación, colas de prioridad o análisis basados en tiempo con ordenación por puntuación.
pub/sub funcionalidad para publicar mensajes, crear suscripciones de canal o patrón con estado, y leer mensajes en cola usando los identificadores de suscripción devueltos. Útil para notificaciones en tiempo real, aplicaciones de chat o distribución de actualizaciones a múltiples clientes.
streams herramientas para añadir, leer, eliminar, crear y destruir grupos de consumidores, y confirmar entradas procesadas en flujos de datos. Útiles para event sourcing, feeds de actividad y procesamiento de eventos basado en trabajadores con grupos de consumidores de Redis Streams.
JSON herramientas para almacenar, recuperar y manipular documentos JSON en Redis. Útiles para estructuras de datos anidadas complejas, bases de datos documentales o gestión de configuración con acceso basado en rutas.

Herramientas adicionales.

docs herramienta para buscar documentación, tutoriales y mejores prácticas de Redis usando preguntas en lenguaje natural (respaldada por la API HTTP MCP_DOCS_SEARCH_URL).
query engine herramientas para gestionar índices vectoriales y realizar búsqueda vectorial
server management herramienta para recuperar información sobre la base de datos

Instalación

El servidor Redis MCP está disponible como paquete PyPI y como instalación directa desde el repositorio de GitHub.

Desde PyPI (recomendado)

La configuración de la última versión del servidor Redis MCP desde PyPI, como ejemplo, se puede realizar importando la siguiente configuración JSON en el framework o herramienta deseada. El comando uvx descargará el servidor sobre la marcha (si no está ya en caché), creará un entorno temporal y luego lo ejecutará.

{
  "mcpServers": {
    "RedisMCPServer": {
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "\"redis://localhost:6379/0\""
      ]
    }
  }
}

Especificación de URL

El formato para especificar el argumento --url sigue los esquemas redis y rediss:

redis://user:secret@localhost:6379/0?foo=bar&qux=baz

Como ejemplo, puedes conectarte fácilmente a un servidor localhost con:

redis://localhost:6379/0

Donde 0 es la base de datos lógica a la que deseas conectarte.

Para una conexión cifrada a la base de datos (por ejemplo, conectarse a una base de datos Redis Cloud), usarías el esquema rediss.

rediss://user:secret@localhost:6379/0?foo=bar&qux=baz

Para verificar la identidad del servidor, especifica ssl_ca_certs.

rediss://user:secret@hostname:port?ssl_cert_reqs=required&ssl_ca_certs=path_to_the_certificate

Para una conexión no verificada, establece ssl_cert_reqs a none

rediss://user:secret@hostname:port?ssl_cert_reqs=none

Configura tu conexión usando las opciones disponibles en la sección "Opciones de CLI disponibles".

Probar el paquete PyPI

Puedes instalar el paquete de la siguiente manera:

pip install redis-mcp-server

Y ejecutarlo usando uv el paquete en tu entorno.

uv python install 3.14
uv sync
uv run redis-mcp-server --url redis://localhost:6379/0

Sin embargo, iniciar el servidor MCP es más útil cuando se delega al framework o herramienta donde este servidor MCP está configurado.

Desde GitHub

Puedes configurar la versión deseada del servidor Redis MCP con uvx, lo que te permite ejecutarlo directamente desde GitHub (desde una rama, o usar una versión etiquetada).

Se recomienda usar una versión etiquetada, la rama main está en desarrollo activo y puede contener cambios incompatibles.

Como ejemplo, puedes ejecutar el siguiente comando para ejecutar la versión 0.2.0:

uvx --from git+https://github.com/redis/mcp-redis.git@0.2.0 redis-mcp-server --url redis://localhost:6379/0

Consulta las notas de la versión para la última versión en la sección Releases. Se proporcionan ejemplos adicionales a continuación.

# Run with Redis URI
uvx --from git+https://github.com/redis/mcp-redis.git redis-mcp-server --url redis://localhost:6379/0

# Run with Redis URI and SSL
uvx --from git+https://github.com/redis/mcp-redis.git redis-mcp-server --url "rediss://<USERNAME>:<PASSWORD>@<HOST>:<PORT>?ssl_cert_reqs=required&ssl_ca_certs=<PATH_TO_CERT>"

# Run with individual parameters
uvx --from git+https://github.com/redis/mcp-redis.git redis-mcp-server --host localhost --port 6379 --password mypassword

# See all options
uvx --from git+https://github.com/redis/mcp-redis.git redis-mcp-server --help

Instalación de desarrollo

Para desarrollo o si prefieres clonar el repositorio:

# Clone the repository
git clone https://github.com/redis/mcp-redis.git
cd mcp-redis

# Install dependencies using uv
uv venv
source .venv/bin/activate
uv sync

# Run with CLI interface
uv run redis-mcp-server --help

# Or run the main file directly (uses environment variables)
uv run src/main.py

Una vez que hayas clonado el repositorio, instalado las dependencias y verificado que puedes ejecutar el servidor, puedes configurar Claude Desktop o cualquier otro cliente MCP para usar este servidor MCP ejecutando el archivo principal directamente (usa variables de entorno). Esto suele ser preferido para desarrollo. El siguiente ejemplo es para Claude Desktop, pero lo mismo aplica a cualquier otro cliente MCP.

Especifica tus credenciales de Redis y la configuración TLS
Obtén la ruta completa del comando uv (por ejemplo, which uv)
Edita el archivo de configuración claude_desktop_config.json
- en MacOS, en ~/Library/Application\ Support/Claude/

{
    "mcpServers": {
        "redis": {
            "command": "<full_path_uv_command>",
            "args": [
                "--directory",
                "<your_mcp_server_directory>",
                "run",
                "src/main.py"
            ],
            "env": {
                "REDIS_HOST": "<your_redis_database_hostname>",
                "REDIS_PORT": "<your_redis_database_port>",
                "REDIS_PWD": "<your_redis_database_password>",
                "REDIS_SSL": True|False,
                "REDIS_SSL_CA_PATH": "<your_redis_ca_path>",
                "REDIS_CLUSTER_MODE": True|False
            }
        }
    }
}

Puedes solucionar problemas siguiendo el archivo de registro.

tail -f ~/Library/Logs/Claude/mcp-server-redis.log

Con Docker

Puedes usar un despliegue dockerizado de este servidor. Puedes construir tu propia imagen o usar la imagen oficial Redis MCP Docker.

Si deseas construir tu propia imagen, el servidor Redis MCP proporciona un Dockerfile. Construye la imagen de este servidor con:

docker build -t mcp-redis .

Finalmente, configura el cliente para crear el contenedor al inicio. A continuación se proporciona un ejemplo para Claude Desktop. Edita el claude_desktop_config.json y añade:

{
  "mcpServers": {
    "redis": {
      "command": "docker",
      "args": ["run",
                "--rm",
                "--name",
                "redis-mcp-server",
                "-i",
                "-e", "REDIS_HOST=<redis_hostname>",
                "-e", "REDIS_PORT=<redis_port>",
                "-e", "REDIS_USERNAME=<redis_username>",
                "-e", "REDIS_PWD=<redis_password>",
                "mcp-redis"]
    }
  }
}

Para usar la imagen oficial Redis MCP Docker, simplemente reemplaza el nombre de tu imagen (mcp-redis en el ejemplo anterior) con mcp/redis.

Configuración

El servidor Redis MCP se puede configurar de dos maneras: mediante argumentos de línea de comandos o mediante variables de entorno. La precedencia es: argumentos de línea de comandos > variables de entorno > valores predeterminados.

Redis ACL

Puedes configurar Redis ACL para restringir el acceso a la base de datos Redis. Por ejemplo, para crear un usuario de solo lectura:

127.0.0.1:6379> ACL SETUSER readonlyuser on >mypassword ~* +@read -@write

Configura el usuario mediante argumentos de línea de comandos o variables de entorno.

Configuración mediante argumentos de línea de comandos

Al usar la interfaz CLI, puedes configurar el servidor con argumentos de línea de comandos:

# Basic Redis connection
uvx --from redis-mcp-server@latest redis-mcp-server \
  --host localhost \
  --port 6379 \
  --password mypassword

# Using Redis URI (simpler)
uvx --from redis-mcp-server@latest redis-mcp-server \
  --url redis://user:pass@localhost:6379/0

# SSL connection
uvx --from redis-mcp-server@latest redis-mcp-server \
  --url rediss://user:pass@redis.example.com:6379/0

# See all available options
uvx --from redis-mcp-server@latest redis-mcp-server --help

Opciones de CLI disponibles:

--url - URI de conexión de Redis (redis://user:pass@host:port/db)
--host - Nombre de host de Redis (predeterminado: 127.0.0.1)
--port - Puerto de Redis (predeterminado: 6379)
--db - Número de base de datos de Redis (predeterminado: 0)
--username - Nombre de usuario de Redis
--password - Contraseña de Redis
--ssl - Habilitar conexión SSL
--ssl-ca-path - Ruta al archivo de certificado CA
--ssl-keyfile - Ruta al archivo de clave SSL
--ssl-certfile - Ruta al archivo de certificado SSL
--ssl-cert-reqs - Requisitos del certificado SSL (predeterminado: requerido)
--ssl-ca-certs - Ruta al archivo de certificados CA
--cluster-mode - Habilitar modo de clúster de Redis

Configuración mediante variables de entorno

Si lo deseas, puedes usar variables de entorno. Se proporcionan valores predeterminados para todas las variables.

Nombre	Descripción	Valor predeterminado
`REDIS_HOST`	IP o nombre de host de Redis	`"127.0.0.1"`
`REDIS_PORT`	Puerto de Redis	`6379`
`REDIS_DB`	Base de datos	0
`REDIS_USERNAME`	Nombre de usuario de base de datos predeterminado	`"default"`
`REDIS_PWD`	Contraseña de base de datos predeterminada	""
`REDIS_SSL`	Habilita o deshabilita SSL/TLS	`False`
`REDIS_SSL_CA_PATH`	Certificado CA para verificar el servidor	None
`REDIS_SSL_KEYFILE`	Archivo de clave privada del cliente para autenticación del cliente	None
`REDIS_SSL_CERTFILE`	Archivo de certificado del cliente para autenticación del cliente	None
`REDIS_SSL_CERT_REQS`	Si el cliente debe verificar el certificado del servidor	`"required"`
`REDIS_SSL_CA_CERTS`	Ruta al archivo de certificados CA de confianza	None
`REDIS_CLUSTER_MODE`	Habilitar modo de clúster de Redis	`False`

Autenticación EntraID para Azure Managed Redis

El servidor Redis MCP admite autenticación EntraID (Azure Active Directory) para Azure Managed Redis, lo que permite la autenticación basada en OAuth con gestión automática de tokens.

Proveedores de autenticación

Autenticación de principal de servicio - Autenticación basada en aplicación usando credenciales de cliente:

export REDIS_ENTRAID_AUTH_FLOW=service_principal
export REDIS_ENTRAID_CLIENT_ID=your-client-id
export REDIS_ENTRAID_CLIENT_SECRET=your-client-secret
export REDIS_ENTRAID_TENANT_ID=your-tenant-id

Autenticación de identidad administrada - Para aplicaciones alojadas en Azure:

# System-assigned managed identity
export REDIS_ENTRAID_AUTH_FLOW=managed_identity
export REDIS_ENTRAID_IDENTITY_TYPE=system_assigned

# User-assigned managed identity
export REDIS_ENTRAID_AUTH_FLOW=managed_identity
export REDIS_ENTRAID_IDENTITY_TYPE=user_assigned
export REDIS_ENTRAID_USER_ASSIGNED_CLIENT_ID=your-identity-client-id

Credencial de Azure predeterminada - Descubrimiento automático de credenciales (recomendado para desarrollo):

export REDIS_ENTRAID_AUTH_FLOW=default_credential
export REDIS_ENTRAID_SCOPES=https://redis.azure.com/.default

Variables de configuración de EntraID

Nombre	Descripción	Valor por defecto
`REDIS_ENTRAID_AUTH_FLOW`	Tipo de flujo de autenticación	None (EntraID deshabilitado)
`REDIS_ENTRAID_CLIENT_ID`	ID de cliente del Service Principal	None
`REDIS_ENTRAID_CLIENT_SECRET`	Secreto del cliente del Service Principal	None
`REDIS_ENTRAID_TENANT_ID`	ID de inquilino de Azure	None
`REDIS_ENTRAID_IDENTITY_TYPE`	Tipo de identidad administrada	`"system_assigned"`
`REDIS_ENTRAID_USER_ASSIGNED_CLIENT_ID`	ID de cliente de identidad administrada asignada por el usuario	None
`REDIS_ENTRAID_SCOPES`	Ámbitos de OAuth para Default Azure Credential	`"https://redis.azure.com/.default"`
`REDIS_ENTRAID_RESOURCE`	Identificador de recurso de Azure Redis	`"https://redis.azure.com/"`

Características clave

Renovación automática de tokens - Actualización de tokens en segundo plano sin intervención manual
Respaldo elegante - Vuelve a la autenticación estándar de Redis cuando EntraID no está configurado
Múltiples flujos de autenticación - Admite Service Principal, Managed Identity y Default Azure Credential
Listo para empresas - Diseñado para Azure Managed Redis con gestión de identidad centralizada

Ejemplo de configuración

Para desarrollo local con Azure CLI:

# Login with Azure CLI
az login

# Configure MCP server
export REDIS_ENTRAID_AUTH_FLOW=default_credential
export REDIS_URL=redis://your-azure-redis.redis.cache.windows.net:6379

Para producción con Service Principal:

export REDIS_ENTRAID_AUTH_FLOW=service_principal
export REDIS_ENTRAID_CLIENT_ID=your-app-client-id
export REDIS_ENTRAID_CLIENT_SECRET=your-app-secret
export REDIS_ENTRAID_TENANT_ID=your-tenant-id
export REDIS_URL=redis://your-azure-redis.redis.cache.windows.net:6379

Para aplicaciones alojadas en Azure con Managed Identity:

export REDIS_ENTRAID_AUTH_FLOW=managed_identity
export REDIS_ENTRAID_IDENTITY_TYPE=system_assigned
export REDIS_URL=redis://your-azure-redis.redis.cache.windows.net:6379

Hay varias formas de establecer variables de entorno:

Usando un archivo .env: Coloque un archivo .env en el directorio de su proyecto con pares clave-valor para cada variable de entorno. Herramientas como python-dotenv, pipenv y uv pueden cargar automáticamente estas variables al ejecutar su aplicación. Esta es una forma conveniente y segura de gestionar la configuración, ya que mantiene los datos sensibles fuera del historial de su shell y del control de versiones (si .env está en .gitignore). Por ejemplo, cree un archivo .env con el siguiente contenido del archivo .env.example proporcionado en el repositorio:

cp .env.example .env

Luego edite el archivo .env para configurar su Redis:

Configurando variables en el shell: Puede exportar variables de entorno directamente en su shell antes de ejecutar su aplicación. Por ejemplo:

export REDIS_HOST=your_redis_host
export REDIS_PORT=6379
# Other variables will be set similarly...

Este método es útil para anulaciones temporales o pruebas rápidas.

Registro de eventos

El servidor utiliza el registro estándar de Python y se configura al inicio. Por defecto registra en WARNING y superior. Puede cambiar la verbosidad con la variable de entorno MCP_REDIS_LOG_LEVEL.

Valores aceptados (sin distinción de mayúsculas): DEBUG, INFO, WARNING, ERROR, CRITICAL, NOTSET
Alias admitidos: WARN → WARNING, FATAL → CRITICAL
También se aceptan valores numéricos, incluidos con signo (por ejemplo, "10", "+20")
Valor por defecto cuando no se establece o no se reconoce: WARNING

Comportamiento del manejador

Si el host (por ejemplo, uv, VS Code, pytest) ya instaló manejadores de consola, el servidor NO agregará los suyos; solo reduce los umbrales de manejadores demasiado restrictivos para que su nivel elegido no se filtre. Nunca aumentará el umbral de un manejador.
Si no hay manejadores presentes, el servidor agrega un único StreamHandler de stderr con un formato simple.

Ejemplos

# See normal lifecycle messages
MCP_REDIS_LOG_LEVEL=INFO uv run src/main.py

# Very verbose for debugging
MCP_REDIS_LOG_LEVEL=DEBUG uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0

En configuraciones de cliente MCP que admiten env, agréguelo junto con sus configuraciones de Redis. Por ejemplo:

{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": ["--from", "redis-mcp-server@latest", "redis-mcp-server", "--url", "redis://localhost:6379/0"],
      "env": {
        "REDIS_HOST": "localhost",
        "REDIS_PORT": "6379",
        "MCP_REDIS_LOG_LEVEL": "INFO"
      }
    }
  }
}

Integraciones

La integración de este MCP Server con marcos de desarrollo como OpenAI Agents SDK, o con herramientas como Claude Desktop, VS Code o Augment se describe en las siguientes secciones.

OpenAI Agents SDK

Integre este MCP Server con el OpenAI Agents SDK. Lea los documentos para obtener más información sobre la integración del SDK con MCP.

Instale el SDK de Python.

pip install openai-agents

Configure el token de OpenAI:

export OPENAI_API_KEY="<openai_token>"

Y ejecute la aplicación.

python3.14 redis_assistant.py

Puede solucionar problemas de sus flujos de trabajo de agentes utilizando el panel de OpenAI.

Augment

La forma preferida de configurar el Redis MCP Server en Augment es usar la función Easy MCP.

También puede configurar el Redis MCP Server en Augment manualmente importando el servidor mediante JSON:

{
  "mcpServers": {
    "Redis MCP Server": {
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "redis://localhost:6379/0"
      ]
    }
  }
}

Claude Desktop

La forma más sencilla de configurar clientes MCP es usando uvx. Agregue el siguiente JSON a su claude_desktop_config.json, recuerde proporcionar la ruta completa a uvx.

Conexión básica de Redis:

{
  "mcpServers": {
    "redis-mcp-server": {
        "type": "stdio",
        "command": "/Users/mortensi/.local/bin/uvx",
        "args": [
            "--from", "redis-mcp-server@latest",
            "redis-mcp-server",
            "--url", "redis://localhost:6379/0"
        ]
    }
  }
}

Azure Managed Redis con autenticación EntraID:

{
  "mcpServers": {
    "redis-mcp-server": {
        "type": "stdio",
        "command": "/Users/mortensi/.local/bin/uvx",
        "args": [
            "--from", "redis-mcp-server@latest",
            "redis-mcp-server",
            "--url", "redis://your-azure-redis.redis.cache.windows.net:6379"
        ],
        "env": {
            "REDIS_ENTRAID_AUTH_FLOW": "default_credential",
            "REDIS_ENTRAID_SCOPES": "https://redis.azure.com/.default"
        }
    }
  }
}

VS Code con GitHub Copilot

Para usar el Redis MCP Server con VS Code, debe habilitar las herramientas del modo agente. Agregue lo siguiente a su settings.json:

{
  "chat.agent.enabled": true
}

Puede iniciar la versión deseada de GitHub del servidor Redis MCP usando uvx agregando el siguiente JSON a su archivo mcp.json:

"servers": {
  "redis": {
    "type": "stdio",
    "command": "uvx",
    "args": [
      "--from", "redis-mcp-server@latest",
      "redis-mcp-server",
      "--url", "redis://localhost:6379/0"
    ]
  },
}

Suprimir mensajes de instalación de uvx

Si desea suprimir los mensajes de instalación de uvx que pueden aparecer como advertencias en los registros del cliente MCP, use la bandera -qq:

"servers": {
  "redis": {
    "type": "stdio",
    "command": "uvx",
    "args": [
      "-qq",
      "--from", "redis-mcp-server@latest",
      "redis-mcp-server",
      "--url", "redis://localhost:6379/0"
    ]
  },
}

La bandera -qq habilita el modo silencioso, que suprime los mensajes "Installed X packages" que uvx escribe en stderr durante la instalación de paquetes.

Alternativamente, puede iniciar el servidor usando uv y configurar su mcp.json. Esto suele ser deseable para desarrollo.

// mcp.json
{
  "servers": {
    "redis": {
      "type": "stdio",
      "command": "<full_path_uv_command>",
      "args": [
        "--directory",
        "<your_mcp_server_directory>",
        "run",
        "src/main.py"
      ],
      "env": {
        "REDIS_HOST": "<your_redis_database_hostname>",
        "REDIS_PORT": "<your_redis_database_port>",
        "REDIS_USERNAME": "<your_redis_database_username>",
        "REDIS_PWD": "<your_redis_database_password>",
      }
    }
  }
}

Para obtener más información, consulte la documentación de VS Code.

Consejo: Puede indicar al chat de Copilot que use las herramientas de Redis MCP incluyendo #redis en su mensaje.

Nota: A partir de VS Code v1.102, los servidores MCP ahora se almacenan en un archivo dedicado mcp.json en lugar de settings.json.

Pruebas

Puede usar el MCP Inspector para la depuración visual de este MCP Server.

npx @modelcontextprotocol/inspector uv run src/main.py

Casos de uso de ejemplo

Asistentes de IA: Permite que los LLM obtengan, almacenen y procesen datos en Redis.
Chatbots y agentes virtuales: Recupere datos de sesión, gestione colas y personalice respuestas.
Búsqueda y análisis de datos: Consulte Redis para información en tiempo real y búsquedas rápidas.
Procesamiento de eventos: Gestione flujos de eventos con Redis Streams.

Contribuciones

Haga un fork del repositorio
Cree una nueva rama (feature-branch)
Confirme sus cambios
Envíe a su rama y envíe un PR.

Licencia

Este proyecto está licenciado bajo la Licencia MIT.

Insignias

Contacto

Para preguntas o soporte, comuníquese a través de GitHub Issues.

Alternativamente, puede unirse al servidor de Discord de Redis y preguntar en el canal #redis-mcp-server.