Redis

What is Redis?

Redis is an open-source, in-memory data structure store that excels at high-speed data access with sub-millisecond latency. Created in 2009 by Salvatore Sanfilippo, Redis stores data primarily in RAM for ultra-fast read/write operations while offering optional persistence to disk for durability. Unlike traditional databases that store data on disk, Redis keeps the entire dataset in memory, enabling throughput of millions of operations per second. This makes Redis ideal for use cases requiring real-time performance: caching, session storage, leaderboards, real-time analytics, message queuing, and streaming data processing.

Redis supports rich data structures beyond simple key-value pairs—strings, hashes (maps), lists, sets, sorted sets (with scores), bitmaps, hyperloglogs, geospatial indexes, and streams. This versatility allows developers to model complex application requirements directly in Redis rather than transforming data for storage. Redis also provides pub/sub messaging, Lua scripting for server-side logic, transactions, and built-in replication for high availability. With Redis Cluster, it scales horizontally across multiple nodes, and with Redis Sentinel, it provides automatic failover for production resilience.

Core Features and Data Structures

Data Structures

• Strings - Binary-safe strings up to 512MB (caching, counters)
• Hashes - Field-value maps (objects, user profiles)
• Lists - Linked lists for queues and timelines
• Sets - Unordered unique string collections (tags, unique visitors)
• Sorted Sets - Ordered sets with scores (leaderboards, priority queues)
• Bitmaps - Bit-level operations for analytics
• HyperLogLogs - Probabilistic counting for unique elements
• Streams - Append-only logs for event sourcing and messaging
• Geospatial - Location-based data with radius queries

Key Capabilities

• Sub-millisecond latency - Typical response times <1ms
• Persistence - RDB snapshots and AOF (append-only file) for durability
• Replication - Master-replica for read scaling and failover
• Redis Sentinel - Automatic failover and monitoring
• Redis Cluster - Horizontal scaling and automatic sharding
• Pub/Sub - Message broadcasting to subscribed clients
• Lua scripting - Server-side atomic operations
• Transactions - MULTI/EXEC for atomic command sequences
• TTL (Time-To-Live) - Automatic key expiration
• Pipelining - Batch commands for reduced latency

Use Cases and Applications

Redis powers critical infrastructure for applications worldwide:

• Caching - Database query results, API responses, session data
• Session storage - User sessions with automatic expiration
• Real-time analytics - Counting, aggregations, time-series data
• Leaderboards - Gaming scores, rankings with sorted sets
• Message queues - Task queues, job processing with lists
• Pub/Sub messaging - Chat applications, notification systems
• Rate limiting - API throttling with sliding window counters
• Geospatial applications - Location-based services, ride-sharing
• ML model serving - Feature caching, prediction results
• Distributed locking - Coordination across microservices

Redis for AI/ML Applications

Redis plays multiple roles in AI/ML architectures. As a feature store, Redis caches frequently accessed features for real-time inference, reducing latency from hundreds of milliseconds (database lookup) to sub-millisecond (Redis). Redis Streams enable real-time ML pipelines, ingesting data from sources, buffering for batch processing, and distributing to workers. Redis serves as a cache for model predictions, storing recent inference results to avoid redundant computation. The pub/sub system coordinates distributed training workers, and sorted sets manage priority queues for experiment scheduling. With RedisAI module, Redis can even execute ML models directly using TensorFlow, PyTorch, or ONNX.

Redis vs Memcached and Traditional Databases

Compared to Memcached (another in-memory cache), Redis offers richer data structures, persistence options, replication, and pub/sub capabilities. Memcached is simpler and marginally faster for basic key-value caching, but Redis's versatility makes it suitable for far more use cases. Compared to traditional databases (PostgreSQL, MySQL), Redis sacrifices complex queries and ACID guarantees for extreme speed and simplicity. Redis is not a replacement for relational databases but a complement—used for caching, sessions, and real-time workloads while databases handle persistent, transactional data.

Redis Cluster enables horizontal scaling, sharding data across multiple nodes for capacity beyond single-server RAM limits. However, cluster mode restricts certain multi-key operations. For applications requiring strong consistency and complex transactions, traditional databases remain essential. For speed-critical paths (authentication, API caching, real-time features), Redis is indispensable.

Getting Started with Redis

Install Redis locally with package managers (apt, brew, yum) or Docker (`docker run -d -p 6379:6379 redis`). Connect using redis-cli: `redis-cli ping` should return "PONG". Try basic commands: `SET key value`, `GET key`, `INCR counter`, `LPUSH queue item`, `HSET user:1 name John`. Redis clients exist for all major languages (Python: redis-py, Node.js: ioredis, Java: Jedis). For production, use Redis Sentinel for high availability or Redis Cluster for horizontal scaling.

Managed Redis services simplify operations: AWS ElastiCache, Azure Cache for Redis, Google Cloud Memorystore, Redis Enterprise Cloud. These handle clustering, failover, backups, and monitoring. For self-hosted deployments, configure persistence (RDB + AOF), set up replication (master-replica), enable Sentinel for automatic failover, and monitor with Redis built-in INFO command or tools like RedisInsight.

Integration with 21medien Services

21medien uses Redis extensively in AI application architectures. We implement Redis as a feature store for real-time ML inference, reducing latency by caching embeddings and preprocessed features. Our team deploys Redis for caching API responses from LLMs, storing conversation history for chatbots, and managing rate limits for AI services. We provide Redis consulting, architecture design (single-node vs cluster vs Sentinel), performance tuning, and integration with ML pipelines. We specialize in Redis for high-throughput inference systems, real-time recommendation engines, and distributed AI application architectures.

Pricing and Access

Redis is open-source (BSD license) and free to use. Self-hosting costs are just infrastructure (compute + RAM). Managed services pricing: AWS ElastiCache ~$0.017/hour for cache.t3.micro (0.5GB RAM) to $6.80/hour for cache.r6g.4xlarge (104GB RAM). Azure Cache for Redis ~$0.02/hour for Basic C0 (250MB) to $13/hour for Premium P5 (120GB). Google Cloud Memorystore ~$0.049/GB-hour (~$35/month per GB). Redis Enterprise Cloud (by Redis Ltd.) starts ~$0.119/GB-hour with advanced features (active-active replication, modules). For AI workloads, budget $100-1000/month for caching layers, $1000-5000/month for feature stores at scale. Self-hosted on cloud VMs: $50-500/month depending on instance size.