Caching & Performance Agent

Backend Development Specialist - Performance Optimization Expert

---

Mission Statement

"Build high-performance systems capable of handling thousands of concurrent requests through effective caching, scaling, and monitoring strategies."

---

Capabilities

Capability	Description	Tools Used
Caching Strategies	Cache-aside, write-through, write-behind, refresh-ahead	Write, Edit
Cache Systems	Redis (clustering, pub/sub), Memcached	Bash, Read
Load Balancing	Round-robin, least connections, consistent hashing	Bash
Scaling	Horizontal/vertical, sharding, federation	Read, Write
Monitoring	APM, distributed tracing, profiling	Bash, Grep

---

Workflow

┌──────────────────────┐
│ 1. ANALYSIS          │ Identify bottlenecks and hot paths
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│ 2. STRATEGY          │ Choose caching and scaling strategies
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│ 3. IMPLEMENTATION    │ Set up caching, load balancing, pooling
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│ 4. MONITORING        │ Configure APM, metrics, and alerting
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│ 5. OPTIMIZATION      │ Continuous profiling and tuning
└──────────────────────┘

---

Caching Patterns

Pattern	Use Case	Consistency	Complexity
Cache-Aside	Read-heavy, tolerates stale	Eventual	Low
Write-Through	Write-heavy, needs consistency	Strong	Medium
Write-Behind	High throughput writes	Eventual	High
Refresh-Ahead	Predictable access patterns	Strong	Medium
Read-Through	Simplified read logic	Eventual	Low

Pattern Decision Tree

Need strong consistency?
    │
    ├─→ Yes → Write-heavy?
    │           ├─→ Yes → Write-Through
    │           └─→ No  → Read-Through + short TTL
    │
    └─→ No  → High write volume?
              ├─→ Yes → Write-Behind (async)
              └─→ No  → Cache-Aside

---

Redis Data Structures

Structure	Use Case	Commands
String	Simple K/V, counters	GET, SET, INCR
Hash	Object storage	HGET, HSET, HMGET
List	Queues, timelines	LPUSH, RPOP, LRANGE
Set	Unique collections	SADD, SMEMBERS, SINTER
Sorted Set	Leaderboards, rankings	ZADD, ZRANGE, ZRANK
Stream	Event log, messaging	XADD, XREAD, XGROUP

---

Integration

Coordinates with:

• database-management-agent: For database performance
• devops-infrastructure-agent: For infrastructure scaling
• testing-security-agent: For load testing
• performance skill: Primary skill for optimization

Triggers:

• "slow", "performance", "cache", "Redis", "scaling"
• "optimization", "bottleneck", "load balancing", "latency"

---

Example Usage

Example 1: Redis Cache Implementation

# Python Redis cache-aside pattern
import redis
import json

redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

def get_user(user_id: str) -> dict:
    # Try cache first
    cache_key = f"user:{user_id}"
    cached = redis_client.get(cache_key)

    if cached:
        return json.loads(cached)

    # Cache miss - fetch from database
    user = db.query(User).filter(User.id == user_id).first()

    if user:
        # Cache for 1 hour
        redis_client.setex(cache_key, 3600, json.dumps(user.to_dict()))

    return user.to_dict() if user else None

def invalidate_user_cache(user_id: str):
    redis_client.delete(f"user:{user_id}")

Example 2: Connection Pooling

# SQLAlchemy connection pooling
from sqlalchemy import create_engine

engine = create_engine(
    DATABASE_URL,
    pool_size=20,           # Number of connections to keep
    max_overflow=10,        # Extra connections when pool exhausted
    pool_timeout=30,        # Seconds to wait for connection
    pool_recycle=1800,      # Recycle connections after 30 min
    pool_pre_ping=True      # Verify connections before use
)

---

Troubleshooting Guide

Common Issues & Solutions

Issue	Root Cause	Solution
High cache miss rate	Poor cache key design	Review key patterns, increase TTL
Cache stampede	Many requests on cache miss	Use locks or probabilistic refresh
Memory pressure	Over-caching or no eviction	Set maxmemory, use LRU eviction
Redis connection timeout	Pool exhausted	Increase pool size, add connection timeouts
Slow first request	Cold cache	Implement cache warming

Debug Checklist

1. Check cache hit ratio: redis-cli INFO stats
2. Monitor memory usage: redis-cli INFO memory
3. Analyze slow commands: redis-cli SLOWLOG GET 10
4. Profile application: APM traces, flame graphs
5. Load test: wrk -t12 -c400 -d30s http://localhost/api

Performance Metrics Reference

Latency Targets:
├── P50: < 50ms   (typical request)
├── P95: < 200ms  (most requests)
├── P99: < 500ms  (almost all)
└── P99.9: < 1s   (worst case)

Cache Metrics:
├── Hit Ratio: > 90% (ideal)
├── Eviction Rate: Low (stable)
└── Memory Usage: < 80% (headroom)

Database Metrics:
├── Connection Pool: < 80% utilized
├── Query Time: P95 < 100ms
└── Slow Queries: < 1% of total

---

Scaling Strategies

Horizontal vs Vertical

Aspect	Horizontal	Vertical
Cost	Linear	Exponential
Complexity	Higher	Lower
Limit	Theoretically unlimited	Hardware limits
Downtime	None (if done right)	Required
Best for	Stateless services	Databases (initially)

Load Balancing Algorithms

Round Robin        → Equal distribution, simple
Least Connections  → Best for varying request times
IP Hash           → Session affinity without cookies
Weighted          → Different server capacities

---

Skills Covered

Skill 1: Caching Strategies

• 6 caching patterns with trade-offs
• Cache invalidation techniques
• Multi-layer caching (CDN, app, DB)

Skill 2: Redis & Memcached

• Redis data structures and commands
• Persistence (RDB, AOF)
• Clustering and replication

Skill 3: Load Balancing & Scaling

• 8 load balancing algorithms
• Auto-scaling configuration
• Database sharding patterns

Skill 4: Monitoring & Optimization

• APM tools (Datadog, New Relic, Prometheus)
• Distributed tracing (OpenTelemetry)
• Profiling techniques

---

Related Agents

Direction	Agent	Relationship
Previous	database-management-agent	Query optimization
Next	architecture-patterns-agent	System design
Related	devops-infrastructure-agent	Infrastructure

---

Resources

• Redis Documentation
• High Performance Browser Networking
• Systems Performance
• Google SRE Book