Memory Limits

Capped memory storage with auto-eviction

Agents can accumulate lots of data. Memory limits cap storage and auto-evict old entries.

Basic Usage

from splinter.control import MemoryStore

store = MemoryStore(
    max_size_bytes=10*1024*1024,  # 10 MB
    max_entries=1000,
)

# Store data
store.set("researcher", "findings", large_data)

# Retrieve data
data = store.get("researcher", "findings")

Eviction Policies

from splinter.control import MemoryStore, EvictionPolicy

# LRU: Evict least recently used
store = MemoryStore(
    max_entries=1000,
    policy=EvictionPolicy.LRU,
)

# FIFO: Evict oldest first
store = MemoryStore(
    max_entries=1000,
    policy=EvictionPolicy.FIFO,
)

# LFU: Evict least frequently used
store = MemoryStore(
    max_entries=1000,
    policy=EvictionPolicy.LFU,
)

Per-Agent Limits

store = MemoryStore(
    max_size_bytes=50*1024*1024,  # 50 MB total
)

# Per-agent caps
store.set_agent_limit("researcher", max_size_bytes=20*1024*1024)
store.set_agent_limit("writer", max_size_bytes=10*1024*1024)

Memory Usage

# Check usage
usage = store.get_usage()
print(f"Total: {usage.total_bytes / 1024 / 1024:.1f} MB")
print(f"Entries: {usage.total_entries}")

# Per-agent usage
agent_usage = store.get_agent_usage("researcher")
print(f"Researcher: {agent_usage.bytes / 1024 / 1024:.1f} MB")

TTL (Time to Live)

Auto-expire old entries:

# Expire after 1 hour
store.set("researcher", "cache", data, ttl_seconds=3600)

# Check if expired
if store.is_expired("researcher", "cache"):
    # Refresh data
    pass

Memory Warnings

from splinter.exceptions import MemoryLimitError

try:
    store.set("researcher", "huge_data", very_large_data)
except MemoryLimitError as e:
    print(f"Memory limit exceeded: {e.current_bytes} / {e.limit_bytes}")

Cleanup

# Clear specific agent
store.clear_agent("researcher")

# Clear all
store.clear_all()

# Force garbage collection
store.gc()

Best Practices

Set appropriate limits

10-50 MB per agent is usually enough. More = slower performance.

Use TTL for caches

Don’t keep stale data forever.

Monitor memory usage

If you’re hitting limits often, optimize what you’re storing.

Choose the right eviction policy

LRU for caches, FIFO for logs, LFU for frequently accessed data.