Memcached: AI-Optimized Technical Reference

Core Function & Architecture

Primary Use Case: In-memory key-value cache to prevent database overload

• Eliminates repetitive database queries (0.1ms vs 5-50ms response times)
• No clustering, replication, or coordination between servers
• Client libraries handle server selection via consistent hashing
• When server dies, cached data is lost (by design - cache is disposable)

Critical Limitation: 1MB value size limit (configurable to ~128MB)

• Silent failure mode: Values >1MB are discarded without error messages
• Production impact: "Small" JSON responses growing to 1.1MB cause cache misses
• Solution: Set -I 5m to increase limit to 5MB preemptively

Performance Reality vs Benchmarks

Environment	Realistic Performance
Cloud VM (shared networking)	50K ops/sec
Dedicated hardware (1Gb network)	100-150K ops/sec
High-end server (10Gb network)	200K+ ops/sec
Latency (typical)	0.1-0.5ms

Performance Bottlenecks:

• Network limits (not CPU) constrain throughput
• Multi-threaded design scales with CPU cores (unlike Redis)
• Memory fragmentation prevented by slab allocation

Production Configuration (Defaults Are Inadequate)

Critical Settings

# Default (useless)
memcached -d -m 64 -p 11211 -u memcached

# Production minimum
memcached -d -m 2048 -p 11211 -u memcached -c 4096 -t 8 -I 5m

Memory (-m): Default 64MB insufficient for any real workload

• Recommendation: 10-20% of total system RAM
• Failure mode: When full, stops caching new data without errors

Connections (-c): Default 1024 inadequate for traffic spikes

• Black Friday scenario: E-commerce sites hit 2000+ connections
• Failure mode: New connections dropped, cache hit rate plummets
• Set to: 4096 minimum

Item Size (-I): Default 1MB causes silent failures

• Set to: 5MB or 10MB to prevent debugging hell

Threads (-t): One per CPU core, max 8

• Above 8: Performance degrades due to lock contention

Security: No Authentication by Design

• Zero built-in security: Anyone reaching port 11211 has full access
• Shodan exposure: Thousands of instances publicly accessible
• Required: Firewall rules limiting access to internal networks
• Binding: Use -l 127.0.0.1 or specific internal IPs, never 0.0.0.0

Monitoring & Failure Detection

Essential Metrics

echo "stats" | nc localhost 11211 | grep -E "(get_hits|get_misses|evictions|curr_connections)"

Critical Thresholds:

• Hit rate: >95% (get_hits / (get_hits + get_misses))
• Evictions: Near 0 (indicates memory pressure)
• Connections: Well below max_connections limit

Common Failure Scenarios:

1. Memory exhaustion: Evictions spike, hit rate drops
2. Connection limit: curr_connections approaches max_connections
3. Silent 1MB failures: Values silently discarded, no error indication
4. Cold cache: After restart, all data lost, database load spikes

Real-World Implementation Patterns

Database Query Caching (Most Common)

def get_user_profile(user_id):
    cache_key = f"user_profile:{user_id}"
    profile = memcached.get(cache_key)
    if profile is None:
        profile = db.query("SELECT * FROM users WHERE id = %s", user_id)
        memcached.set(cache_key, profile, ttl=3600)  # 1 hour
    return profile

Production Scale Examples

• Netflix: Millions of requests/second via EVCache infrastructure
• Facebook: Thousands of servers, custom client libraries
• Wikipedia: 98%+ hit rate serving 500M+ daily page views

Cloud Provider Limitations

• AWS ElastiCache: 3x cost of self-hosted, defaults require tuning
• Google Memorystore: Better pricing, limited regional availability
• Version lag: Cloud providers typically behind latest releases

Technology Comparison Matrix

Aspect	Memcached	Redis	When to Choose Memcached
Performance	50-200K ops/sec	80-150K ops/sec	Need multi-threaded performance
Memory overhead	Minimal	2-3x more	Memory efficiency critical
Setup complexity	45 minutes	30+ minutes	Want simplicity
Debugging	telnet port 11211	redis-cli	Need human-readable debugging
Data types	Key-value only	Multiple structures	Simple caching sufficient
Max item size	1MB (configurable)	512MB default	Small cached values

Critical Operational Intelligence

Installation Gotchas

• Windows: Installer frequently fails, use Docker instead
• macOS: Homebrew doesn't auto-start service
• Linux: Works reliably via package managers

Production Disasters & Prevention

1. 1MB limit discovery: Hours of debugging silent failures

   • Prevention: Set -I 5m preemptively

2. Public exposure: Scraped by bots for days before detection

   • Prevention: Firewall rules mandatory

3. Session storage failure: 80% user logout when server crashed

   • Prevention: Database fallback for critical data

4. Connection exhaustion: Traffic spike caused cache failure

   • Prevention: Monitor curr_connections vs max_connections

Resource Requirements

• Time to productivity: 1 hour for basic setup
• Expertise needed: Minimal (vs 1 week for Redis, 1 month for Hazelcast)
• Memory allocation: Whatever you can spare, more = better hit rates
• Maintenance overhead: Very low once configured

When Not to Use

• Dataset fits in application memory (use HashMap instead)
• <1000 requests/day (premature optimization)
• Need data persistence (cache disappears on restart)
• Complex data structures required (use Redis)

The 3AM Test: If losing all cached data breaks your application, you're using Memcached wrong - it's cache, not storage.

Recommended Client Libraries

Language	Library	Reason
Python	pymemcache	Pinterest-maintained, thread-safe
Java	spymemcached	Battle-tested at scale
PHP	php-memcached	Official PECL extension
Node.js	memcached	Good connection pooling
Go	gomemcache	Written by Memcached creator
Ruby	dalli	Rails integration

Essential Commands & Debugging

Basic Operations

# Test connectivity
telnet localhost 11211

# Essential stats
echo "stats" | nc localhost 11211

# Real-time monitoring
memcached-top

# Load testing
memtier_benchmark

Key Metrics to Alert On

• Hit rate <95%
• Evictions >0 sustained
• Current connections >80% of max
• Memory usage >90%

This technical reference provides all operational intelligence needed for successful Memcached implementation, from initial setup through production scale deployment and troubleshooting.