redis-development_skill

Overview

This skill provides practical Redis performance optimization and best-practice guidance for development teams. It consolidates prioritized rules across data modeling, memory management, query optimization, vector search, and semantic caching. Use it to make targeted, high-impact improvements to Redis-based applications and to avoid common production pitfalls.

How this skill works

I inspect typical Redis usage patterns and recommend concrete changes: right data structures, key naming, TTL strategies, connection handling, and index configuration for the Redis Query Engine. The skill includes focused advice for vector search (RedisVL) and semantic caching with LangCache, plus security and observability checks. Each rule is prioritized by impact so you can apply high-value fixes first.

When to use it

• Designing data models, key namespaces, or choosing Redis data types.
• Implementing caching layers, session stores, or real-time features.
• Building RQE-based queries and managing FT.CREATE/FT.SEARCH/FT.AGGREGATE indexes.
• Developing vector search or RAG applications with RedisVL.
• Adding semantic caching for LLM responses using LangCache.
• Tuning production Redis for memory, latency, and connection performance.

Best practices

• Choose the smallest, semantically correct data structure (string, hash, list, set, zset, JSON) for each use case to minimize memory and CPU.
• Apply consistent key naming and TTL policies; set TTLs for cache keys and use eviction policies with configured memory limits.
• Avoid blocking commands in hot paths; use pipelining, connection pooling or multiplexing and tune timeouts.
• Index only fields you query in RQE, use DIALECT 2, and plan zero-downtime index updates.
• For vectors, pick HNSW vs FLAT based on latency and accuracy needs; use hybrid search when combining embeddings with metadata.
• Enforce ACLs, authentication, secure network access, and monitor Redis metrics and command patterns for anomalies.

Example use cases

• Converting a cache built from large JSON blobs into compact hashes or selective JSON fields with TTLs to reduce RAM.
• Rewriting slow aggregation queries using RQE best practices and selective indexing to cut query latency.
• Configuring a LangCache layer to cache LLM outputs with semantic keys and appropriate eviction habits.
• Choosing HNSW index parameters for a production vector search to balance recall and storage footprint.
• Implementing connection pooling and pipelining for a bulk import job to minimize round-trips and timeouts.