redis-development
redis/agent-skills
Redis performance optimization and best practices for data structures, query engines, vector search, and semantic caching.
What is redis-development?
Comprehensive guide for optimizing Redis deployments across data modeling, memory management, and advanced features like Redis Query Engine, vector search with RedisVL, and semantic caching with LangCache. Use this skill when designing Redis architectures, implementing caching strategies, or building RAG and vector search applications.
- Reference 29 prioritized optimization rules across 11 categories (data structures, memory, connections, JSON, RQE, vector search, semantic caching, streams, clustering, security, observability)
- Provides best practices for Redis Query Engine (FT.CREATE, FT.SEARCH, FT.AGGREGATE) and index management
- Guides vector search implementation with algorithm selection (HNSW vs FLAT) and hybrid search patterns
- Covers semantic caching configuration and LangCache integration for LLM response caching
- Includes connection pooling, pipelining, and performance tuning strategies
- Addresses security (ACLs, authentication, network access) and observability for production deployments
How to install redis-development
npx skills add https://github.com/redis/agent-skills --skill redis-developmentHow to use redis-development
- 1.Install the skill using: npx skills add https://github.com/redis/agent-skills --skill redis-development
- 2.Reference the 11 rule categories by priority (data structures, memory, connections, JSON, RQE, vector search, semantic caching, streams, clustering, security, observability)
- 3.Read individual rule files (e.g., rules/rqe-index-creation.md, rules/vector-rag-pattern.md) for detailed explanations and code examples
- 4.Apply correct examples and anti-patterns from each rule to your Redis implementation
- 5.Consult the full compiled document (AGENTS.md) for complete expanded guidance on all 29 rules
Use cases
- Designing Redis data models and key naming conventions for large-scale applications
- Optimizing memory usage with TTL policies and eviction strategies in cache-heavy systems
- Building RAG (Retrieval-Augmented Generation) applications with vector search and semantic caching
- Implementing full-text search and aggregations using Redis Query Engine
- Setting up Redis clusters with hash tags for multi-key operations and read replicas for scaling
- Backend engineers building caching layers and real-time features
- Data engineers implementing vector search and RAG pipelines
- DevOps engineers optimizing Redis cluster deployments
- AI/ML engineers integrating semantic caching with LLM applications
- Database architects designing Redis data models
redis-development FAQ
Use RQE when you need full-text search, filtering, or aggregations on structured data. The skill covers field type selection, index creation, and query optimization for RQE-based workloads.
The vector-algorithm-choice rule guides this decision based on your dataset size, latency requirements, and accuracy needs. HNSW is typically better for large datasets; FLAT for smaller ones.
Semantic caching stores LLM responses based on semantic similarity rather than exact key matching. Use it with LangCache to reduce redundant API calls and improve response times for similar queries.
The skill covers TTL configuration, eviction policies, choosing appropriate data structures, and memory limits. Rules like ram-ttl and ram-limits provide specific guidance.
The security category covers ACLs for fine-grained access control, authentication requirements, and network access restrictions. Always enable authentication and use ACLs in production.
Full instructions (SKILL.md)
Source of truth, from redis/agent-skills.
name: redis-development description: Redis performance optimization and best practices. Use this skill when working with Redis data structures, Redis Query Engine (RQE), vector search with RedisVL, semantic caching with LangCache, or optimizing Redis performance. license: MIT metadata: author: redis version: "1.0.0"
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 Structuredata-key-naming- Use Consistent Key Naming Conventions
2. Memory & Expiration (HIGH)
ram-limits- Configure Memory Limits and Eviction Policiesram-ttl- Set TTL on Cache Keys
3. Connection & Performance (HIGH)
conn-blocking- Avoid Slow Commands in Productionconn-pipelining- Use Pipelining for Bulk Operationsconn-pooling- Use Connection Pooling or Multiplexingconn-timeouts- Configure Connection Timeouts
4. JSON Documents (MEDIUM)
json-partial-updates- Use JSON Paths for Partial Updatesjson-vs-hash- Choose JSON vs Hash Appropriately
5. Redis Query Engine (HIGH)
rqe-dialect- Use DIALECT 2 for Query Syntaxrqe-field-types- Choose the Correct Field Typerqe-index-creation- Index Only Fields You Queryrqe-index-management- Manage Indexes for Zero-Downtime Updatesrqe-query-optimization- Write Efficient Queries
6. Vector Search & RedisVL (HIGH)
vector-algorithm-choice- Choose HNSW vs FLAT Based on Requirementsvector-hybrid-search- Use Hybrid Search for Better Resultsvector-index-creation- Configure Vector Indexes Properlyvector-rag-pattern- Implement RAG Pattern Correctly
7. Semantic Caching (MEDIUM)
semantic-cache-best-practices- Configure Semantic Cache Properlysemantic-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 Operationscluster-read-replicas- Use Read Replicas for Read-Heavy Workloads
10. Security (HIGH)
security-acls- Use ACLs for Fine-Grained Access Controlsecurity-auth- Always Use Authentication in Productionsecurity-network- Secure Network Access
11. Observability (MEDIUM)
observe-commands- Use Observability Commands for Debuggingobserve-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 "Incorrect" example (for anti-patterns that cause real harm) or "When to use / When NOT needed" guidance (for optional features)
- Additional context and references
Full Compiled Document
For the complete guide with all rules expanded: AGENTS.md
Related skills
More from redis/agent-skills and the wider catalog.
redis-connections
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.
redis-core
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. Use when designing a Redis data model, caching objects, deciding between Hash and JSON, building counters, leaderboards, membership sets, or session stores, or when reviewing/cleaning up Redis key naming.
agent-ci
Run GitHub Actions CI locally with Agent CI to validate changes before pushing. Use when testing, running checks, or validating code changes.
refero-design
Research-first design skill for UI, product, web, and landing pages—grounded in real references, not generic AI taste.
ai-evals
Design and run systematic evaluations for AI products to measure model quality and output performance.
ai-product-strategy
Strategic guidance for building AI products using frameworks from 94 product leaders.