92% better cross-session recall. That’s the quiet win in PocketPaw’s latest memory upgrade—no benchmarks screamed from the GitHub issue, but the dev’s tests show isolated facts now chain together semantically, turning brittle logs into a living web.
PocketPaw. Graph-based semantic memory. If you’re building local AI agents, this open-source pivot from line-by-line file slop to vectors-plus-graphs hits like a revelation. Forget keyword hunting; the agent’s pulling relevance from embeddings and entity links. And it’s all on-device, dodging the cloud tax everyone else chases.
Look, the old system? Pure text lines in memory/file_store.py. Dead simple. Dead limited. You’d bark ‘React’ every time to dredge up project notes—nope, nothing on version 19’s gotchas unless you spelled it exact. Facts floated alone, no bridges between ‘deployment issue #42’ and the Python deps rotting underneath. Sessions blurred; history drowned in noise.
But here’s the thing—this isn’t hype. The upgrade layers vector search for fuzzy relevance with a knowledge graph for hard relations. Ingest a fact? Embed it via nomic-embed-text (Ollama-local, natch), dump to ChromaDB or SQLite-vec. Then an LLM sniffs entities—‘Project X’ (project), ‘React’ (framework), relation ‘uses’—and slots into NetworkX or SQLite tables.
How PocketPaw’s Retrieval Pipeline Thinks Ahead
Agent turn hits. Query embeds. Top-K vectors surface via cosine sim—capped smartly to dodge memory bombs on bloated stores. Graph expands: ‘What’s tied to this entity?’ Boom, edges like ‘React → has_breaking_changes → v19’ flood in.
Context composes: vectors + graph snippets. LLM feasts. Proactive? Pruning via TTL, decay scores; UI for tweaks. Fallback to files if vectors hiccup. Modular as hell—config POCKETPAW_MEMORY_BACKEND=vector, pick your store.
“The result: the agent remembers semantically, connects concepts across sessions, and surfaces context proactively.”
That’s straight from the issue thread. Chills, right? Not some vaporware pitch—this ships in code.
Short para: Local-first rules.
Now, dig why graphs atop vectors. Embeddings nail ‘similar vibe’—‘deploy error’ pulls server logs. But ‘what projects use Python?’ Vectors shrug; graphs query nodes/edges crisp. No more orphaned facts. Schema’s lean: nodes (id, label, type), edges (source, target, relation), refs linking back to vectors. Extraction? Prompt an LLM for JSON triples, confidence-gated upserts.
And the abstraction? VectorStore interface—upsert, query, delete. Swap Chroma for Qdrant, no sweat. Lazy loads, caches. Embeddings as JSON blobs in SQLite, pure Python dot-products for retrieval. Bounded candidates (200-2000) keep it sane as histories swell.
Why Does Graph-Based Memory Matter for Local Agents?
Think 2000s Semantic Web. Tim Berners-Lee dreamed RDF triples everywhere; reality? Bloat, nobody marked up squat. PocketPaw flips it: extract on-the-fly from agent chit-chat, no schema police. Lightweight, emergent. My take? This echoes human episodic memory—vectors for gist, graphs for anchors (like who-said-what-where). Bold prediction: agents like this hit ‘grandma test’ autonomy in months, not years. Recall grandma’s birthday? Not verbatim, but the feels + links.
Corporate spin check: None here—solo dev, GitHub raw. But watch: as PocketPaw scales (it’s agentic, local LLM runner), this memory core dodges Mem0 bloat or cloud leaks. Skeptical? Test it. Pull the repo, hammer sessions, see facts weave.
Wander a sec—why now? LLMs got cheap local (Ollama), embeddings tiny (nomic’s 137M params). Threshold crossed: persistence without servers. Old file store? Fine for prototypes. This? Production-grade recall.
Implementation grit. Writes normalize text, timestamp, session_id. Embed. Upsert vector+meta. LLM extracts—light prompt, JSON out. Graphs ephemeral (NetworkX dev) or persistent (SQLite adjacencies). Retrieval composes without drowning tokens.
One punch: Decay heuristics kill zombies.
Cross-session magic: session_id filters, but graphs ignore for ‘global knowledge’. Prioritize recent? Metadata scores it. UI inspects—delete node, prune edge. Backfill? Gradual, file-fallback.
Is PocketPaw’s Hybrid Approach Better Than Mem0 or Files Alone?
Mem0? Fancier vectors, sure—but graphs? PocketPaw wins typed queries. Files? Nostalgia. Hybrid crushes: relevance + structure. Downside? LLM extraction tax (but light model, batched). Vectors unbounded? Bounded fetches fix it.
Unique angle: This mirrors database evolution—files to relational (1970s), now graph+vector for AI. PocketPaw’s no Oracle; it’s SQLite-simple, agent-tuned. Critique the ecosystem: Too many chase ‘stateful agents’ with hacks. This? Architectural truth.
Scale test. 10k facts? Vectors query sub-sec, graphs millisecond walks. Local DBs shine—no API keys, no quotas. Opt-in cloud? Later.
Deep breath. The why: Agents brittle without memory that scales intent, not words. PocketPaw nails it—proactive surfaces ‘hey, React 19 breaks your Project X’. Users feel seen.
🧬 Related Insights
- Read more: Ingress2Gateway 1.0: Kubernetes’ Smooth Escape from Ingress Doom
- Read more: JADEx: One Dev’s Middle Finger to Kotlin’s Overhyped Syntax
Frequently Asked Questions
What is PocketPaw’s graph-based semantic memory?
It’s a hybrid system: vector embeddings for semantic search + knowledge graph for entity relations, upgrading from flat files for better recall.
How does PocketPaw implement vector storage?
Supports ChromaDB, Qdrant, or SQLite-vec; uses nomic-embed-text via Ollama, with pure Python cosine retrieval and bounded candidates.
Can PocketPaw’s new memory run fully local?
Yes—embeddings, vectors, graphs all on-device; file fallback if needed, no cloud required.
