🎯

redis

🎯Skill
g1joshi/agent-skills2 Installs9Last Updated Feb 10, 2026

Installation

$npx skills add g1joshi/agent-skills --skill redis

Run it in a terminal; it asks which AI coding tools to install it for (Claude Code, Codex, Cursor and more).

Uses skills.sh Β· Node.js 22.20+

After installing

Ask for related work and the agent uses it on its own, or call it yourself.

Run it (Claude Code)/redis
Install by hand

Copy the whole skill folder from GitHub to the place below. Copying only SKILL.md can leave out files the skill uses.

Open the skill folder β†’
  • This project .claude/skills/redis/
  • All projects ~/.claude/skills/redis/

These paths are for Claude Code. For other tools, the command above puts it in the right place.

Expert Redis in-memory data store assistance covering data structures, caching, pub/sub, Lua scripts, Redis Streams, and clustering. Use when building ultra-fast caches, rate limiters, session stores, or message queues.

Redis

Redis (Remote Dictionary Server) is an in-memory data structure store, used as a database, cache, and message broker. It is incredibly fast.

When to Use

  • In-Memory Caching & Sub-Millisecond Reads: Caching hot database objects, session state, and computed API payloads in RAM.
  • Distributed Locking & Concurrency Control: Coordinating atomic multi-instance synchronization with Redlock or SET NX PX commands.
  • High-Velocity Queues & Pub/Sub Messaging: Powering message brokers, task queues (BullMQ, Sidekiq), and real-time event broadcasting.
  • Rate Limiting & Sliding Windows: Implementing sliding window rate limiters and leaderboards via Redis Sorted Sets (ZSET).

Quick Start

# Set a value with 10 second expiry
SET session:123 "active" EX 10

# Increment a counter atomically
INCR page:views

# Store a hash (object)
HSET user:100 name "Jeevan" role "admin"

Core Concepts

Advanced In-Memory Data Structures

Redis goes far beyond simple string caching, offering rich native data primitives:

StructureTypical Use CaseExample Command
StringCache values, atomic countersINCR counter, SET key val EX 3600
HashObject representation (User, Cart)HSET user:101 name "Alice" role "Admin"
ListJob queues, event timelinesLPUSH task_queue job1, BRPOP task_queue 0
SetUnique tags, mutual followersSADD tags "web" "api", SINTER setA setB
Sorted Set (ZSET)Leaderboards, sliding rate limitsZADD leaderboard 4500 "user101"
StreamEvent sourcing, append-only logsXADD mystream * sensor "temp" val 24.5

Atomic Distributed Locks (SET NX PX)

Acquires safe mutual exclusion locks across distributed nodes:

import { Redis } from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);

async function acquireLock(
  lockKey: string,
  ttlMs: number,
): Promise<string | null> {
  const token = crypto.randomUUID();
  const acquired = await redis.set(lockKey, token, "NX", "PX", ttlMs);
  return acquired === "OK" ? token : null;
}

async function releaseLock(lockKey: string, token: string): Promise<boolean> {
  // Lua script ensures atomic check-and-delete
  const luaScript = `
    if redis.call("get", KEYS[1]) == ARGV[1] then
      return redis.call("del", KEYS[1])
    else
      return 0
    end
  `;
  const result = await redis.eval(luaScript, 1, lockKey, token);
  return result === 1;
}

Sliding Window Rate Limiter with Sorted Sets (ZSET)

Calculates rolling request rates accurately:

async function isRateLimited(
  userId: string,
  limit: number,
  windowSeconds: number,
): Promise<boolean> {
  const now = Date.now();
  const clearBefore = now - windowSeconds * 1000;
  const key = `ratelimit:${userId}`;

  const pipeline = redis.pipeline();
  pipeline.zremrangebyscore(key, 0, clearBefore); // Remove expired requests
  pipeline.zadd(key, now, now.toString()); // Add current request
  pipeline.zcard(key); // Count requests in window
  pipeline.expire(key, windowSeconds);

  const results = await pipeline.exec();
  const requestCount = results![2][1] as number;
  return requestCount > limit;
}

Common Patterns

Distributed Sliding-Window Rate Limiter with Lua Script

Problem: Naive rate limit checks with separate GET/SET calls have race conditions that permit request flooding.

Solution: Execute atomic sliding window rate limiting via Lua script:

-- KEYS[1]: rate limit key (e.g. rate:user123)
-- ARGV[1]: current timestamp in ms
-- ARGV[2]: window size in ms (e.g. 60000)
-- ARGV[3]: max allowed requests

local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local limit = tonumber(ARGV[3])
local clearBefore = now - window

redis.call('ZREMRANGEBYSCORE', key, 0, clearBefore)
local currentRequests = redis.call('ZCARD', key)

if currentRequests < limit then
    redis.call('ZADD', key, now, now)
    redis.call('PEXPIRE', key, window)
    return 1
else
    return 0
end

Best Practices

Do:

  • Always Set an Eviction Policy: Configure maxmemory-policy volatile-lru or allkeys-lru to prevent out-of-memory crashes.
  • Use Pipelines for Multi-Key Operations: Batch commands with redis.pipeline() to eliminate network roundtrip latency.
  • Execute Complex Logic with Atomic Lua Scripts: Use Lua scripts or Redis Functions to guarantee atomic multi-step operations.
  • Namespace Keys Systematically: Follow standardized key naming conventions (app:environment:entity:id).

Don't:

  • Run the KEYS * command in production: KEYS blocks the single-threaded event loop; use SCAN instead.
  • Store massive multi-megabyte values: Redis is single-threaded; serializing huge objects delays all concurrent requests.
  • Use Redis without persistence configurations: Ensure RDB snapshots or AOF (appendonly yes) are active if data loss is unacceptable.

Troubleshooting

ErrorCauseSolution
OOM command not allowed when used memory > 'maxmemory'Redis memory limit reached and eviction policy is noeviction.Configure maxmemory-policy allkeys-lru or scale Redis memory.
LOADING Redis is loading the dataset in memoryServer recently restarted and is parsing RDB/AOF persistence file.Wait for dataset reload to finish; optimize AOF file size with BGREWRITEAOF.
READONLY You can't write against a read only replicaAttempted write operation sent to a replica node instead of master.Check client clustering configuration and verify write routing to master.

References

More from this repository10