mekayelanik/redis-mcp-server repository overview

⁠Redis MCP Server

⁠Multi-Architecture Docker Image for Redis Data Management

⁠Table of Contents

• Overview⁠
• Supported Architectures⁠
• Available Tags⁠
• Quick Start⁠
• Configuration⁠
• MCP Client Configuration⁠
• Network Configuration⁠
• Updating⁠
• Troubleshooting⁠
• Additional Resources⁠
• Support & License⁠

⁠😎 Buy Me a Coffee ☕︎

Your support encourages me to keep creating/supporting my open-source projects. If you found value in this project, you can buy me a coffee to keep me inspired.

⁠

⁠Overview

Redis MCP Server is a Model Context Protocol server that provides tools for managing and interacting with Redis databases. Built on Alpine Linux for minimal footprint and maximum security, wrapped with mcp-proxy⁠ (replacing supergateway) for StreamableHTTP/SSE transport.

⁠Key Features

• Multi-Architecture Support - Native support for x86-64 and ARM64
• Multiple Transport Protocols - StreamableHTTP and SSE via mcp-proxy (exposed simultaneously)
• Secure by Design - Alpine-based with minimal attack surface
• High Performance - ZSTD compression for faster deployments
• Production Ready - Stable releases with comprehensive testing
• Easy Configuration - Simple environment variable setup

⁠Supported Architectures

⁠Available Tags

⁠System Requirements

• Docker Engine: 23.0+
• RAM: Minimum 512MB
• CPU: Single core sufficient

⁠Quick Start

⁠Docker Compose (Recommended)

services:
  redis-mcp-server:
    image: mekayelanik/redis-mcp-server:stable
    container_name: redis-mcp-server
    restart: unless-stopped
    ports:
      - "8030:8030"
    environment:
      - PORT=8030
      - INTERNAL_PORT=38011
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Dhaka
      - PROTOCOL=SHTTP
      # ENABLE_HTTPS=false is plaintext over the wire. Safe ONLY for loopback
      # / trusted internal networks. Set to "true" for any public, multi-host,
      # or untrusted deployment — HAProxy auto-generates a self-signed cert
      # if none is mounted under /etc/haproxy/certs/.
      - ENABLE_HTTPS=false
      - HTTP_VERSION_MODE=auto
      # mcp-proxy session model. Stateful by default — one stdio child shared
      # across all sessions (multiplexed via JSON-RPC ids). Set to true only
      # if full per-request isolation is required (memory-hostile).
      - MCP_PROXY_STATELESS=false
      # Cap virtual memory of the redis-mcp stdio child (MiB; 0 disables)
      - REDIS_MAX_MEM_MB=1024
      # HAProxy concurrency caps (0 disables)
      - HAPROXY_FRONTEND_MAXCONN=64
      - HAPROXY_SERVER_MAXCONN=16
      # Redis connection settings
      # - REDIS_URL=redis://localhost:6379
      # - REDIS_HOST=localhost
      # - REDIS_PORT=6379
      # - REDIS_USERNAME=
      # - REDIS_PWD=
      # - REDIS_DB=0
      # - REDIS_SSL=false
      # - REDIS_SSL_CA_PATH=
      # - REDIS_SSL_KEYFILE=
      # - REDIS_SSL_CERTFILE=
      # - REDIS_SSL_CERT_REQS=required
      # - REDIS_SSL_CA_CERTS=
      # - REDIS_CLUSTER_MODE=false
      # Optional: require Bearer token auth at HAProxy layer
      # - API_KEY=replace-with-strong-secret
    hostname: redis-mcp-server
    domainname: local

Deploy:

docker compose up -d
docker compose logs -f redis-mcp-server

⁠Docker CLI

docker run -d \
  --name=redis-mcp-server \
  --restart=unless-stopped \
  -p 8030:8030 \
  -e PORT=8030 \
  -e INTERNAL_PORT=38011 \
  -e PUID=1000 \
  -e PGID=1000 \
  -e TZ=Asia/Dhaka \
  -e PROTOCOL=HTTP \
  -e ENABLE_HTTPS=false \
  -e HTTP_VERSION_MODE=auto \
  mekayelanik/redis-mcp-server:stable

⁠Access Endpoints

When HTTPS is enabled (ENABLE_HTTPS=true), use TLS endpoints:

⁠Configuration

⁠Environment Variables

⁠HTTPS and HTTP Version Notes

• If ENABLE_HTTPS=true and cert files are missing, the container auto-generates a self-signed certificate.
• If TLS_CERT_PATH and TLS_KEY_PATH exist, they are merged into TLS_PEM_PATH and used directly.
• HTTP_VERSION_MODE=h3 (or auto) enables HTTP/3 only when HAProxy build includes QUIC; otherwise it safely falls back.

⁠API Key Authentication Notes

• Set API_KEY to enforce authentication at reverse proxy level.
• Expected header format: Authorization: Bearer <API_KEY>.
• Localhost health checks remain accessible for liveness/readiness.

⁠Rate Limiting and IP Access Control

• Rate limiting: Set RATE_LIMIT=100 to allow 100 requests per RATE_LIMIT_PERIOD (default 10s) per IP. Exceeding the limit returns HTTP 429 with a Retry-After header.
• Connection limiting: Set MAX_CONNECTIONS_PER_IP=50 to cap concurrent connections per IP. Exceeding returns HTTP 429.
• IP blocklist: Set IP_BLOCKLIST=192.0.2.0/24,198.51.100.5 to block specific IPs/CIDRs. Blocked IPs receive HTTP 403.
• IP allowlist: Set IP_ALLOWLIST=10.0.0.0/8,192.168.1.0/24 to allow only listed IPs/CIDRs. All others receive HTTP 403. Localhost is always allowed.
• All features default to disabled. Combine as needed — blocklist is checked before allowlist.

⁠Memory & Concurrency Tuning

mcp-proxy runs the Redis MCP backend as a single long-lived stdio child and multiplexes all client sessions through it via JSON-RPC ids. This caps the expected memory footprint; the knobs below cap the worst case:

• MCP_PROXY_STATELESS=false (default) — share one backend child across all sessions. Recommended for almost every deployment. Flip to true only when you genuinely need per-request isolation.
• REDIS_MAX_MEM_MB=1024 — caps the virtual-memory size of the redis-mcp child via prlimit --as. A runaway backend gets OOM-killed by the kernel before it exhausts the host.
• HAPROXY_FRONTEND_MAXCONN=64 + HAPROXY_SERVER_MAXCONN=16 — bound concurrent connections at the HAProxy layer so a burst cannot saturate the upstream stdio bridge.
• /healthz is answered directly by HAProxy with a local 200 — Docker's container healthcheck no longer depends on upstream MCP readiness.

⁠User & Group IDs

Find your IDs and set them to avoid permission issues:

id username
# uid=1000(user) gid=1000(group)

⁠Timezone Examples

- TZ=Asia/Dhaka        # Bangladesh
- TZ=America/New_York  # US Eastern
- TZ=Europe/London     # UK
- TZ=UTC               # Universal Time

⁠MCP Client Configuration

⁠Transport Support

⁠VS Code (Cline/Roo-Cline)

Configure in .vscode/settings.json:

{
  "mcp.servers": {
    "redis-mcp": {
      "url": "http://host-ip:8030/mcp",
      "transport": "http"
    }
  }
}

⁠Claude Desktop App/Claude Code

With API_KEY:

claude mcp add-json redis-mcp '{"type":"http","url":"http://localhost:8030/mcp","headers":{"Authorization":"Bearer <YOUR_API_KEY>"}}'

Without API_KEY:

claude mcp add-json redis-mcp '{"type":"http","url":"http://localhost:8030/mcp"}'

⁠Codex CLI

Configure in ~/.codex/config.json:

{
  "mcpServers": {
    "redis-mcp": {
      "transport": "http",
      "url": "http://host-ip:8030/mcp"
    }
  }
}

⁠Codeium (Windsurf)

Configure in .codeium/mcp_settings.json:

{
  "mcpServers": {
    "redis-mcp": {
      "transport": "http",
      "url": "http://host-ip:8030/mcp"
    }
  }
}

⁠Cursor

Configure in ~/.cursor/mcp.json:

{
  "mcpServers": {
    "redis-mcp": {
      "transport": "http",
      "url": "http://host-ip:8030/mcp"
    }
  }
}

⁠Testing Configuration

Verify with MCP Inspector⁠:

npm install -g @modelcontextprotocol/inspector
mcp-inspector http://host-ip:8030/mcp

⁠Network Configuration

⁠Comparison

⁠Bridge Network (Default)

services:
  redis-mcp-server:
    image: mekayelanik/redis-mcp-server:stable
    ports:
      - "8030:8030"

Benefits: Container isolation, easy setup, works everywhere Access: http://localhost:8030/mcp

⁠Host Network (Linux Only)

services:
  redis-mcp-server:
    image: mekayelanik/redis-mcp-server:stable
    network_mode: host

Benefits: Maximum performance, no NAT overhead, no port mapping needed Considerations: Linux only, shares host network namespace Access: http://localhost:8030/mcp

⁠MACVLAN Network (Advanced)

services:
  redis-mcp-server:
    image: mekayelanik/redis-mcp-server:stable
    mac_address: "AB:BC:CD:DE:EF:01"
    networks:
      macvlan-net:
        ipv4_address: 192.168.1.100

networks:
  macvlan-net:
    driver: macvlan
    driver_opts:
      parent: eth0
    ipam:
      config:
        - subnet: 192.168.1.0/24
          gateway: 192.168.1.1

Benefits: Dedicated IP, direct LAN access Considerations: Linux only, requires additional setup Access: http://192.168.1.100:8030/mcp

⁠Updating

⁠Docker Compose

docker compose pull
docker compose up -d
docker image prune -f

⁠Docker CLI

docker pull mekayelanik/redis-mcp-server:stable
docker stop redis-mcp-server && docker rm redis-mcp-server
# Run your original docker run command
docker image prune -f

⁠One-Time Update with Watchtower

docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower \
  --run-once \
  redis-mcp-server

⁠Troubleshooting

⁠Pre-Flight Checklist

• Docker Engine 23.0+
• Port 8030 available
• Sufficient startup time (ARM devices)
• Latest stable image
• Correct configuration

⁠Common Issues

⁠Container Won't Start

# Check Docker version
docker --version

# Verify port availability
sudo netstat -tulpn | grep 8030

# Check logs
docker logs redis-mcp-server

⁠Permission Errors

# Get your IDs
id $USER

# Update configuration with correct PUID/PGID
# Fix volume permissions if needed
sudo chown -R 1000:1000 /path/to/volume

⁠Client Cannot Connect

# Test connectivity
curl http://localhost:8030/mcp
curl http://host-ip:8030/mcp
curl -k https://localhost:8030/mcp
curl -k https://host-ip:8030/mcp

# Check firewall
sudo ufw status

# Verify container
docker inspect redis-mcp-server | grep IPAddress

⁠Slow ARM Performance

• Wait 30-60 seconds after start
• Monitor: docker logs -f redis-mcp-server
• Check resources: docker stats redis-mcp-server
• Use faster storage (SSD vs SD card)

⁠Debug Information

When reporting issues, include:

# System info
docker --version && uname -a

# Container logs
docker logs redis-mcp-server --tail 200 > logs.txt

# Container config
docker inspect redis-mcp-server > inspect.json

⁠Additional Resources

⁠Documentation

• Redis MCP Upstream⁠
• PyPI Package⁠
• mcp-proxy (stdio<->HTTP/SSE bridge)⁠
• MCP Inspector⁠

⁠Docker Resources

• Docker Compose Best Practices⁠
• Docker Networking⁠
• Docker Security⁠

⁠Monitoring

• Diun - Update Notifier⁠
• Watchtower⁠

⁠😎 Buy Me a Coffee ☕︎

Your support encourages me to keep creating/supporting my open-source projects. If you found value in this project, you can buy me a coffee to keep me inspired.

⁠

⁠Support & License

⁠Getting Help

Docker Image Issues:

• GitHub: redis-mcp-server-docker/issues⁠

Redis MCP Issues:

• GitHub: redis/mcp-redis/issues⁠

⁠Contributing

We welcome contributions:

1. Report bugs via GitHub Issues
2. Suggest features
3. Improve documentation
4. Test beta releases

⁠License

GPL License. See LICENSE⁠ for details.

Redis MCP server has its own license - see upstream repository⁠.