Agent Memory Systems

1. Install Ollama → ollama pull nomic-embed-text (for vector memory) + ollama pull llama3.1:8b (for generation).
2. pip install mem0ai (Mem0 — open-weight agent memory layer).
3. Configure Mem0 to use Ollama:

from mem0 import Memory
m = Memory.from_config({
    "vector_store": {"provider": "chroma"},
    "llm": {"provider": "ollama", "config": {"model": "llama3.1:8b"}},
    "embedder": {"provider": "ollama", "config": {"model": "nomic-embed-text"}}
})
m.add("User's name is Alex and they prefer Python over JavaScript.", user_id="user_1")
results = m.search("What language does Alex prefer?", user_id="user_1")
print(results)  # [{"memory": "Alex prefers Python over JavaScript"}]

1. First memory stored and recalled in <1 second. Mem0 handles deduplication, conflict resolution, and temporal decay.
2. Alternative: Letta (letta.com) for more sophisticated agent memory with persistent state management.

Memory systems are lightweight. Mem0 or Letta with Nomic Embed Text + Llama 3.2 3B run entirely on CPU on a $300 laptop. 100K memories stored and retrieved at sub-100ms latency. ChromaDB (embedded) handles vector storage with zero infrastructure. For a dedicated build: used Dell Optiplex ($150) + 16 GB RAM ($30) + 512 GB NVMe ($35). Total: ~$215. Memory is an infra-light workload — the bottleneck is storage I/O, not compute. If you need the LLM to summarize/consolidate memories, add a used GTX 1060 6 GB ($60).

Used RTX 3060 12 GB (~$200-250, see /hardware/rtx-3060-12gb) handles production agent memory for 100K+ concurrent users. Letta + Qdrant for persistent state + BGE-M3 embeddings for high-quality semantic recall + Llama 3.1 8B for memory consolidation. Memory write latency <200ms, recall <50ms. Pair with Ryzen 7 7700X + 64 GB DDR5 + 2TB NVMe. Total: ~$900-1,100. For multi-agent systems with shared memory pools, increase RAM to 128 GB. Memory systems are I/O-bound, not GPU-bound.

The mistake: Building "agent memory" by stuffing all conversation history into the LLM context window and calling it done. Why it fails: Context windows fill up fast — 128K tokens sounds like a lot but 100 conversations later, you're past the limit. The LLM reads every message on every query, making each call progressively slower and more expensive. You've built a log, not a memory. The fix: Use a proper memory architecture: (1) recent messages stay in context, (2) older messages get embedded and stored in a vector DB, (3) relevant past memories are retrieved on each query, (4) periodic consolidation summarizes redundant memories. This gives infinite memory duration at constant cost. Tools like Mem0 and Letta implement this pattern out of the box.