Redis Core Knowledge

Deep Knowledge: Use mcp__documentation__fetch_docs with technology: redis for comprehensive documentation.

Data Types

Strings

SET user:1:name "John" GET user:1:name SETEX session:abc 3600 "user_data" # Expires in 1h INCR page:views

Hashes

HSET user:1 name "John" email "john@example.com" HGET user:1 name HGETALL user:1 HINCRBY user:1 loginCount 1

Lists

LPUSH notifications:1 "New message" RPUSH queue:jobs '{"task": "send_email"}' LRANGE notifications:1 0 9 LPOP queue:jobs

Sets

SADD user:1:roles "admin" "editor" SISMEMBER user:1:roles "admin" SMEMBERS user:1:roles SINTER user:1:friends user:2:friends # Common friends

Sorted Sets

ZADD leaderboard 100 "user:1" 200 "user:2" ZRANGE leaderboard 0 9 REV WITHSCORES # Top 10 ZINCRBY leaderboard 10 "user:1"

Common Patterns

Caching

async function getUser(id) { const cached = await redis.get(user:${id}); if (cached) return JSON.parse(cached);

const user = await db.users.find(id); await redis.setex(user:${id}, 3600, JSON.stringify(user)); return user; }

Rate Limiting

async function rateLimit(ip) { const key = ratelimit:${ip}; const count = await redis.incr(key); if (count === 1) await redis.expire(key, 60); return count <= 100; }

Production Readiness

Connection Configuration

// redis.ts import Redis from 'ioredis';

const redis = new Redis({ host: process.env.REDIS_HOST, port: parseInt(process.env.REDIS_PORT || '6379'), password: process.env.REDIS_PASSWORD, db: parseInt(process.env.REDIS_DB || '0'),

// Connection pool maxRetriesPerRequest: 3, retryStrategy: (times) => { if (times > 10) return null; // Stop retrying return Math.min(times * 100, 3000); },

// TLS for production tls: process.env.NODE_ENV === 'production' ? {} : undefined,

// Keep-alive keepAlive: 30000, connectTimeout: 10000, });

redis.on('error', (err) => { console.error('Redis connection error:', err); });

redis.on('connect', () => { console.log('Redis connected'); });

export { redis };

Cache Patterns

// Generalized cache-aside pattern async function cacheAside<T>( key: string, ttl: number, fetcher: () => Promise<T> ): Promise<T> { const cached = await redis.get(key); if (cached) { return JSON.parse(cached); }

const data = await fetcher(); await redis.setex(key, ttl, JSON.stringify(data)); return data; }

// Cache invalidation async function invalidatePattern(pattern: string): Promise<void> { const keys = await redis.keys(pattern); if (keys.length > 0) { await redis.del(...keys); } }

// Example usage const user = await cacheAside( user:${id}, 3600, // 1 hour TTL () => db.users.findUnique({ where: { id } }) );

// On user update await invalidatePattern(user:${id}*);

Rate Limiting (Sliding Window)

async function slidingWindowRateLimit( key: string, limit: number, windowSeconds: number ): Promise<{ allowed: boolean; remaining: number }> { const now = Date.now(); const windowStart = now - windowSeconds * 1000;

const multi = redis.multi(); multi.zremrangebyscore(key, 0, windowStart); multi.zadd(key, now, ${now}-${Math.random()}); multi.zcard(key); multi.expire(key, windowSeconds);

const results = await multi.exec(); const count = results?.[2]?.[1] as number;

return { allowed: count <= limit, remaining: Math.max(0, limit - count), }; }

Session Storage

interface SessionData { userId: string; roles: string[]; createdAt: number; }

async function createSession(userId: string, roles: string[]): Promise<string> { const sessionId = crypto.randomUUID(); const session: SessionData = { userId, roles, createdAt: Date.now(), };

await redis.setex( session:${sessionId}, 86400, // 24 hours JSON.stringify(session) );

return sessionId; }

async function getSession(sessionId: string): Promise<SessionData | null> { const data = await redis.get(session:${sessionId}); return data ? JSON.parse(data) : null; }

async function deleteSession(sessionId: string): Promise<void> { await redis.del(session:${sessionId}); }

Distributed Locking

async function acquireLock( resource: string, ttlMs: number ): Promise<string | null> { const lockId = crypto.randomUUID(); const result = await redis.set( lock:${resource}, lockId, 'PX', ttlMs, 'NX' ); return result === 'OK' ? lockId : null; }

async function releaseLock(resource: string, lockId: string): Promise<boolean> { const script = if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end ; const result = await redis.eval(script, 1, lock:${resource}, lockId); return result === 1; }

Monitoring

// Health check async function healthCheck(): Promise<{ status: string; latency: number }> { const start = Date.now(); await redis.ping(); return { status: 'healthy', latency: Date.now() - start, }; }

// Key metrics async function getMetrics() { const info = await redis.info('stats'); const memory = await redis.info('memory'); return { info, memory }; }

Monitoring Metrics

Metric Target

Connection pool usage < 80%

Cache hit ratio

90%

Latency (p99) < 5ms

Memory usage < 80% max

Checklist

• Connection pooling configured

• TLS enabled in production

• Retry strategy with backoff

• Password authentication

• Key expiration on all cached data

• Cache invalidation strategy

• Rate limiting implemented

• Distributed locking for critical sections

• Health check endpoint

• Memory monitoring alerts

When NOT to Use This Skill

• Relational data - Use postgresql or mysql for structured data with relationships

• Document storage - Use mongodb for complex document structures

• Full-text search - Use elasticsearch for search indexing and analytics

• Primary database - Redis is for caching/sessions, not as main data store

• Large objects - Store references in Redis, data in object storage

Anti-Patterns

Anti-Pattern Problem Solution

No TTL on keys Memory leak, unbounded growth Always set expiration with SETEX or EXPIRE

Storing large objects Performance degradation, memory pressure Keep values small (<100KB), use compression

Using KEYS in production Blocks server, O(N) operation Use SCAN for iteration

No connection pooling Connection exhaustion Configure pool (ioredis, node-redis)

Ignoring eviction policy Random data loss when full Set appropriate policy (allkeys-lru)

Single Redis instance Single point of failure Use Redis Cluster or Sentinel

No password in production Security vulnerability Always configure AUTH

Quick Troubleshooting

Problem Diagnostic Fix

Memory full INFO memory , MEMORY STATS

Increase maxmemory, set eviction policy

Slow responses SLOWLOG GET 10

Optimize queries, use pipelining

Connection refused Check maxclients limit Increase limit or fix connection leaks

High latency redis-cli --latency

Check network, enable keep-alive

Keys not expiring TTL key returns -1 Set TTL on keys, check PERSIST calls

Replication lag INFO replication

Check network, reduce write load

Reference Documentation

• Data Patterns

• Pub/Sub