Redis Development
Give your coding agent Redis-specific rules for keys, memory, RQE, vector search, and semantic caching instead of generic cache advice.
Overview
Redis Development is an agent skill most often used in Build (also Ship performance tuning and Operate monitoring) that applies 29 prioritized Redis rules across data modeling, Query Engine, vector search, and semantic c
Install
npx skills add https://github.com/redis/agent-skills --skill redis-developmentWhat is this skill?
- 29 prioritized rules across 11 categories (data structures, memory, connections, JSON, RQE, vectors, LangCache, streams,
- Covers Redis Query Engine (FT.CREATE, FT.SEARCH, FT.AGGREGATE) and RedisVL vector/RAG patterns.
- Semantic caching guidance for LangCache alongside expiration and memory (`ram-`) rules.
- Connection and performance (`conn-`) rules ranked HIGH impact for latency-sensitive solo deployments.
- Prefix-tagged rule families (`data-`, `rqe-`, `vector-`, `semantic-cache-`) for targeted agent lookups.
- 29 rules across 11 categories
- Rule prefixes span data-, ram-, conn-, json-, rqe-, vector-, semantic-cache-, stream-, and cluster families
Adoption & trust: 3.2k installs on skills.sh; 70 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are adding Redis, RQE, or vector search to your app but generic agent answers miss TTL, key, and index pitfalls that waste memory and latency.
Who is it for?
Solo builders implementing caching, sessions, RQE search, RedisVL RAG, or LangCache on a self-managed or cloud Redis instance.
Skip if: Teams that only need a one-line `redis-cli` command with no data-model or search-engine design decisions.
When should I use this skill?
Working with Redis data structures, Redis Query Engine, vector search with RedisVL, semantic caching with LangCache, or optimizing Redis performance.
What do I get? / Deliverables
Your agent generates and reviews Redis code against Redis’s own categorized rule set so models, indexes, and caches align with production-grade patterns.
- Redis-aligned implementation guidance
- Optimization checklist mapped to rule categories
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Redis shows up when solo builders wire backends, sessions, and AI retrieval stacks—canonical shelf is Build because that is when schemas and clients are chosen. Backend subphase covers caching layers, real-time features, and data stores that Redis backs in production APIs and agents.
Where it fits
Model session storage and cache keys with explicit TTL and data-structure rules before shipping auth.
Wire RedisVL embeddings and RQE indexes for a small RAG feature without mis-sized vector fields.
Audit connection pooling and hot-path commands against HIGH-impact `conn-` and `data-` rules pre-launch.
Revisit clustering, replication, and stream rules when traffic growth threatens memory or failover.
How it compares
Use this rule-backed skill instead of asking the model to improvise Redis tuning from blog snippets.
Common Questions / FAQ
Who is redis-development for?
Indie and solo developers building backends or AI features that depend on Redis structures, search indexes, vectors, or semantic cache layers.
When should I use redis-development?
During Build when designing keys and integrations; in Ship when optimizing latency and memory before launch; in Operate when revisiting replication, streams, or cluster behavior in production.
Is redis-development safe to install?
It is documentation-style procedural knowledge with no bundled executables—review the Security Audits panel on this Prism page before trusting any third-party skill package.
SKILL.md
READMESKILL.md - Redis Development
# Redis Best Practices Comprehensive performance optimization guide for Redis, including Redis Query Engine, vector search, and semantic caching. Contains 29 rules across 11 categories, prioritized by impact to guide automated optimization and code generation. ## When to Apply Reference these guidelines when: - Designing Redis data models and key structures - Implementing caching, sessions, or real-time features - Using Redis Query Engine (FT.CREATE, FT.SEARCH, FT.AGGREGATE) - Building vector search or RAG applications with RedisVL - Implementing semantic caching with LangCache - Optimizing Redis performance and memory usage ## Rule Categories by Priority | Priority | Category | Impact | Prefix | |----------|----------|--------|--------| | 1 | Data Structures & Keys | HIGH | `data-` | | 2 | Memory & Expiration | HIGH | `ram-` | | 3 | Connection & Performance | HIGH | `conn-` | | 4 | JSON Documents | MEDIUM | `json-` | | 5 | Redis Query Engine | HIGH | `rqe-` | | 6 | Vector Search & RedisVL | HIGH | `vector-` | | 7 | Semantic Caching | MEDIUM | `semantic-cache-` | | 8 | Streams & Pub/Sub | MEDIUM | `stream-` | | 9 | Clustering & Replication | MEDIUM | `cluster-` | | 10 | Security | HIGH | `security-` | | 11 | Observability | MEDIUM | `observe-` | ## Quick Reference ### 1. Data Structures & Keys (HIGH) - `data-choose-structure` - Choose the Right Data Structure - `data-key-naming` - Use Consistent Key Naming Conventions ### 2. Memory & Expiration (HIGH) - `ram-limits` - Configure Memory Limits and Eviction Policies - `ram-ttl` - Set TTL on Cache Keys ### 3. Connection & Performance (HIGH) - `conn-blocking` - Avoid Slow Commands in Production - `conn-pipelining` - Use Pipelining for Bulk Operations - `conn-pooling` - Use Connection Pooling or Multiplexing - `conn-timeouts` - Configure Connection Timeouts ### 4. JSON Documents (MEDIUM) - `json-partial-updates` - Use JSON Paths for Partial Updates - `json-vs-hash` - Choose JSON vs Hash Appropriately ### 5. Redis Query Engine (HIGH) - `rqe-dialect` - Use DIALECT 2 for Query Syntax - `rqe-field-types` - Choose the Correct Field Type - `rqe-index-creation` - Index Only Fields You Query - `rqe-index-management` - Manage Indexes for Zero-Downtime Updates - `rqe-query-optimization` - Write Efficient Queries ### 6. Vector Search & RedisVL (HIGH) - `vector-algorithm-choice` - Choose HNSW vs FLAT Based on Requirements - `vector-hybrid-search` - Use Hybrid Search for Better Results - `vector-index-creation` - Configure Vector Indexes Properly - `vector-rag-pattern` - Implement RAG Pattern Correctly ### 7. Semantic Caching (MEDIUM) - `semantic-cache-best-practices` - Configure Semantic Cache Properly - `semantic-cache-langcache-usage` - Use LangCache for LLM Response Caching ### 8. Streams & Pub/Sub (MEDIUM) - `stream-choosing-pattern` - Choose Streams vs Pub/Sub Appropriately ### 9. Clustering & Replication (MEDIUM) - `cluster-hash-tags` - Use Hash Tags for Multi-Key Operations - `cluster-read-replicas` - Use Read Replicas for Read-Heavy Workloads ### 10. Security (HIGH) - `security-acls` - Use ACLs for Fine-Grained Access Control - `security-auth` - Always Use Authentication in Production - `security-network` - Secure Network Access ### 11. Observability (MEDIUM) - `observe-commands` - Use Observability Commands for Debugging - `observe-metrics` - Monitor Key Redis Metrics ## How to Use Read individual rule files for detailed explanations and code examples: ``` rules/rqe-index-creation.md rules/vector-rag-pattern.md ``` Each rule file contains: - Brief explanation of why it matters - Correct example(s) with explanation - Either an "In