Official agent skill

Redis Connections

by redis in redis/agent-skills

Redis client and connection guidance covering connection pooling, multiplexing, pipelining, client-side caching with RESP3, avoiding slow commands (KEYS, SMEMBERS, HGETALL), and tuning socket…

OfficialMITAuto-check passedDatabases

Install Redis Connections

skills CLI
$ npx skills add redis/agent-skills --skill redis-connections -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install redis/agent-skills redis-connections --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/redis/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/redis-connections .claude/skills/redis-connections && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
redis-connections
GitHub stars
166
Used in
1 other repo
Token cost
~1.3k tokens
SKILL.md length
430 words
Files
6 (incl. references)
Skills in repo
8
Repo updated
First seen
Licence
MIT

At a glance

Redis client and connection guidance covering connection pooling, multiplexing, pipelining, client-side caching with RESP3, avoiding slow commands (KEYS, SMEMBERS, HGETALL), and tuning socket…

  • Works in 5 steps: Pool or multiplex — never one connection… → Pipeline bulk work → Avoid commands that scan everything → …
  • Configuring a Redis client (redis-py
  • SKILL.md covers When to apply, 1. Pool or multiplex — never…, 2. Pipeline bulk work and 3. Avoid commands that scan…, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Redis Connections is an agent skill from redis/agent-skills, published by the product's own GitHub organization. Redis client and connection guidance covering connection pooling, multiplexing, pipelining, client-side caching with RESP3, avoiding slow commands (KEYS, SMEMBERS, HGETALL), and tuning socket timeouts. Use when configuring a Redis client (redis-py, Jedis, Lettuce, NRedisStack), batching commands for throughput, eliminating per-request connection creation, iterating large keyspaces with SCAN, enabling client-side caching for read-heavy workloads, or setting connect and read timeouts.

Its SKILL.md is about 1.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files (for example `references/blocking.md`, `references/client-cache.md` and `references/pipelining.md`).

It sits in Databases, covering Caching and Database administration. It works with Redis. The repository describes itself as: Redis' official collection of agent skills. The licence is MIT.

When your agent uses it

  • Configuring a Redis client (redis-py
  • Batching commands for throughput
  • Eliminating per-request connection creation
  • Iterating large keyspaces with SCAN

Example prompts

  • “/redis-connections”

Requirements

  • Python 3

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Pool or multiplex — never one connection per request
  2. Pipeline bulk work
  3. Avoid commands that scan everything
  4. Client-side caching for hot keys
  5. Set explicit timeouts

What it can do on your machine

Read from SKILL.md and the folder at commit a84871d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are python).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • redis.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Redis Connections loads about 1.3k tokens when it runs, and up to ~3.3k if it reads all its reference files. Until then it costs about 126 tokens; SKILL.md has 430 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~126
When it runs · the whole SKILL.md, loaded when a task matches
~1.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~3.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from redis/agent-skills at commit a84871d, republished under its MIT licence (© redis). 430 words, ~1,278 tokens.

Download SKILL.mdSave it as .claude/skills/redis-connections/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
redis-connections
description
Redis client and connection guidance covering connection pooling, multiplexing, pipelining, client-side caching with RESP3, avoiding slow commands (KEYS, SMEMBERS, HGETALL), and tuning socket timeouts. Use when configuring a Redis client (redis-py, Jedis, Lettuce, NRedisStack), batching commands for throughput, eliminating per-request connection creation, iterating large keyspaces with SCAN, enabling client-side caching for read-heavy workloads, or setting connect and read timeouts.
license
MIT
metadata.author
Redis, Inc.
metadata.version
0.1.0

Redis Connections

Client-side guidance for talking to Redis efficiently: how to share connections, how to batch commands, which commands not to call in production, when to turn on client-side caching, and how to set timeouts that fail fast without breaking healthy traffic.

When to apply

  • Creating or reviewing a Redis client setup (redis-py, Jedis, Lettuce, go-redis, NRedisStack).
  • Making many small Redis calls and wondering where the latency is going.
  • Iterating large keyspaces, sets, hashes, or lists.
  • Enabling client-side caching for hot keys.
  • Tuning connect / read / write timeouts.

1. Pool or multiplex — never one connection per request

The single biggest mistake in Redis client code is opening a new TCP connection for every operation. Always either:

  • Pool — keep N persistent connections that the application leases per call (redis-py ConnectionPool, Jedis JedisPooled, go-redis client).
  • Multiplex — share a single connection across all requests (Lettuce, NRedisStack).
StyleUsed byNote
Poolredis-py, Jedis, go-redisEach lease blocks if pool exhausted; size the pool to your concurrency
MultiplexLettuce, NRedisStackSingle connection; cannot carry blocking commands like BLPOP
python
# redis-py — connection pool
pool = redis.ConnectionPool(host="localhost", port=6379, max_connections=50)
r = redis.Redis(connection_pool=pool)

See references/pooling.md for Python + Java + Lettuce examples.

2. Pipeline bulk work

For N commands that don't depend on each other's results, send them as a single batch with pipelining. One round-trip instead of N.

python
pipe = redis.pipeline()
for user_id in user_ids:
    pipe.get(f"user:{user_id}")
results = pipe.execute()

Use non-transactional pipelining for performance, and pipeline(transaction=True) only when you actually need atomicity (see redis-core's transactions guidance).

See references/pipelining.md.

Show full SKILL.md (204 more words)Show less

3. Avoid commands that scan everything

Anything that walks the whole keyspace (or a whole large container) blocks the server. Use incremental variants instead.

Don'tUse
KEYS patternSCAN cursor loop
SMEMBERS large_setSSCAN
HGETALL large_hashHSCAN
LRANGE 0 -1 on a huge listPaginate (LRANGE 0 100)
python
cursor = 0
while True:
    cursor, keys = redis.scan(cursor, match="user:*", count=100)
    for key in keys:
        process(key)
    if cursor == 0:
        break

Blocking commands (BLPOP, BRPOP, BLMOVE) are different — they intentionally wait for data and are fine for queue consumers, but always pass a timeout, and don't issue them on a multiplexed connection (Lettuce, NRedisStack).

See references/blocking.md.

4. Client-side caching for hot keys

For data that's read often and written rarely (config, feature flags, sessions on every request), enable RESP3 client-side caching. The client keeps a local copy and the server invalidates it on writes — saving the round trip for hot reads.

python
client = redis.Redis(
    host="localhost",
    port=6379,
    protocol=3,                                    # RESP3 is required
    cache_config=redis.CacheConfig(max_size=1000),
)

Skip it for write-heavy workloads or data that changes constantly — the invalidation traffic overruns the savings.

See references/client-cache.md.

5. Set explicit timeouts

Defaults vary by client and may be too generous. Pick values that match the application's failure model:

python
r = redis.Redis(
    host="localhost",
    socket_connect_timeout=2.0,   # fail fast on dead nodes
    socket_timeout=5.0,           # tune to expected operation time
    retry_on_timeout=True,
)

Rule of thumb: connect timeout shorter than read/write timeout. Tight timeouts + retry-on-timeout for latency-sensitive paths; longer timeouts for batch jobs.

See references/timeouts.md.

References

© redis, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (references) in skills/redis-connections of redis/agent-skills.

  • SKILL.md
  • references/blocking.md
  • references/client-cache.md
  • references/pipelining.md
  • references/pooling.md
  • references/timeouts.md

Open the folder on GitHubat commit a84871d

Used in 1 other repository

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in redis/agent-skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Redis Connections next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Redis Connections compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Redis Connections this skillredis/agent-skills1661 repos~1.3kAutomated safety check: PassMIT
AWS Cloudformation Elasticachegiuseppe-trisciuoglio/developer-kit357—~1.5kAutomated safety check: NotesMIT
Redis Inspectorevolution-foundation/evo-nexus545—~1.3kAutomated safety check: NotesCustom licence
Azure Resource Manager Redis Dotnetmicrosoft/skills3.1k5 repos~3kAutomated safety check: PassMIT
Frappe Core DatabaseImpertio-Studio/Frappe_Claude_Skill_Package189—~3.8kAutomated safety check: PassMIT
Upstash Redissickn33/agentic-awesome-skills47k1 repos~1.5kAutomated safety check: PassMIT

Similar skills

  • AWS Cloudformation Elasticache

    giuseppe-trisciuoglio/developer-kit

    Provides AWS CloudFormation patterns for ElastiCache Redis or Memcached infrastructure, including subnet groups, parameter groups, security controls, and cross-stack outputs.

    357 GitHub stars~1.5k tokensUpdated 1 mo ago
    DatabasesAuto-check: notes
  • Redis Inspector

    evolution-foundation/evo-nexus

    Reads keys and server state from Redis instances configured in .env through a read-only Python client, choosing connections by label or index.

    545 GitHub stars~1.3k tokensUpdated 5 mo ago
    DatabasesAuto-check: notes
  • Official

    Azure Resource Manager SDK for Redis in .NET. An agent skill from microsoft/skills.

    3.1k GitHub starsUsed in 5 repos~3k tokens
    DatabasesAuto-check passed
  • Frappe Core Database

    Impertio-Studio/Frappe_Claude_Skill_Package

    A skill your agent uses when performing database operations in ERPNext/Frappe v14-v16.

    189 GitHub stars~3.8k tokensUpdated 23 days ago
    DatabasesAuto-check passed
  • Upstash Redis

    sickn33/agentic-awesome-skills

    Use the @upstash/redis HTTP client for caching, sessions, counters, and Redis data structures from serverless and edge runtimes without connection pooling.

    47k GitHub starsUsed in 1 repo~1.5k tokens
    Backend & APIsAuto-check passed
  • Supabase Load Scale

    jeremylongshore/tons-of-skills-marketplace

    A skill your agent uses when preparing a Supabase project for production load — traffic spikes, connection-limit tuning, read replicas for analytics queries, CDN caching for Storage, regional Edge…

    2.8k GitHub stars~1.7k tokensUpdated today
    DatabasesAuto-check passed

More from redis/agent-skills

All 8 skills in this repo
  • Redis Core

    redis/agent-skills

    Official

    Core Redis modeling guidance — choose the right data structure (String, Hash, List, Set, Sorted Set, JSON, Stream, Vector Set) and use consistent colon-separated key names.

    166 GitHub starsUsed in 2 repos~759 tokens
    Auto-check passed
  • Redis Observability

    redis/agent-skills

    Official

    Redis observability guidance — which metrics to monitor (memory, connections, hit ratio, ops/sec, rejected connections), which built-in commands to reach for during incident triage (SLOWLOG, INFO…

    166 GitHub starsUsed in 2 repos~911 tokens
    Auto-check passed
  • Redis Clustering

    redis/agent-skills

    Official

    Redis Cluster and replication guidance covering hash tags for multi-key operations, avoiding CROSSSLOT errors, and reading from replicas to scale read-heavy workloads.

    166 GitHub starsUsed in 1 repo~1k tokens
    Auto-check passed
  • Redis Search

    redis/agent-skills

    Official

    Redis Search guidance covering FT.CREATE schema design, field type selection (TEXT, TAG, NUMERIC, GEO, GEOSHAPE, VECTOR, JSON path), DIALECT 2 query syntax, FT.SEARCH / FT.AGGREGATE / FT.HYBRID…

    166 GitHub starsUsed in 1 repo~2.9k tokens
    Auto-check passed
  • Redis Security

    redis/agent-skills

    Official

    Redis security guidance covering authentication (requirepass and ACL users), TLS, ACL-based least-privilege access control, restricting network exposure via bind and protected-mode, firewall rules…

    166 GitHub starsUsed in 1 repo~918 tokens
    Auto-check passed
  • Iris Development

    redis/agent-skills

    Official

    Iris is Redis's umbrella for AI-focused products. An agent skill from redis/agent-skills.

    166 GitHub stars~1.1k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Redis Connections

What does Redis Connections do?

Redis client and connection guidance covering connection pooling, multiplexing, pipelining, client-side caching with RESP3, avoiding slow commands (KEYS, SMEMBERS, HGETALL), and tuning socket…. Redis Connections is an agent skill from redis/agent-skills, published by the product's own GitHub organization. Redis client and connection guidance covering connection pooling, multiplexing, pipelining, client-side caching with RESP3, avoiding slow commands (KEYS, SMEMBERS, HGETALL), and tuning socket timeouts.

When should I use Redis Connections?

Redis Connections fits situations like: configuring a Redis client (redis-py; batching commands for throughput; eliminating per-request connection creation; iterating large keyspaces with SCAN.

How do I install Redis Connections in Claude Code?

Run `npx skills add redis/agent-skills --skill redis-connections -a claude-code`. Or copy the skill folder (skills/redis-connections in redis/agent-skills) into .claude/skills/redis-connections in your project. Claude Code loads it when a task matches its description.

How do I install Redis Connections in Codex?

Run `npx skills add redis/agent-skills --skill redis-connections -a codex`. Or copy the skill folder (skills/redis-connections in redis/agent-skills) into .agents/skills/redis-connections in your project. Codex loads it when a task matches its description.

Can I use Redis Connections in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add redis/agent-skills --skill redis-connections -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/redis-connections, .gemini/skills/redis-connections, .github/skills/redis-connections and .opencode/skills/redis-connections in your project.

What does Redis Connections need to run?

SKILL.md names no scripts, command-line tools or credentials: Redis Connections is instructions for the agent only. Our summary lists: Python 3.

Does Redis Connections access the network?

SKILL.md names 1 domain. As links in the text: redis.io. This is read from the text; nothing was executed.

Is Redis Connections safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Redis Connections use?

Redis Connections is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Redis Connections use?

About 1.3k tokens (SKILL.md is roughly 5.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.1k tokens, read only when the agent opens those files.

What are the alternatives to Redis Connections?

Skills that share tags, products or a category with Redis Connections: AWS Cloudformation Elasticache (giuseppe-trisciuoglio/developer-kit, 357 stars), Redis Inspector (evolution-foundation/evo-nexus, 545 stars), Azure Resource Manager Redis Dotnet (microsoft/skills, 3.1k stars) and Frappe Core Database (Impertio-Studio/Frappe_Claude_Skill_Package, 189 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Redis Connections?

redis (a GitHub organization, an official publisher) maintains it in redis/agent-skills, which has 166 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on September 8, 2026.

Source: redis/agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.