MemoriaGraph Lite

Autonomous Cognitive Memory & Decision Hub for AI Coding Agents

Comment

Inspiration

As developers orchestrating autonomous AI coding agents (such as Google Antigravity, Claude Code, and Cursor) on daily engineering tasks, we constantly faced one frustrating bottleneck: agent session amnesia.

Whenever an agent switches sessions or starts a new conversation context, it forgets hard-won architectural decisions and repeats the exact same debugging mistakes. Existing solutions typically dump raw, noisy conversation transcripts into context windows, which wastes tokens, distracts the LLM, and triggers hallucinations.

We were inspired to build a lightweight, purpose-built "second brain" for coding agents that discards conversational noise and distills engineering experience into a structured cognitive triad: Problem ➔ Mitigation ➔ Solution.

What it does

MemoriaGraph Lite is a lightweight, zero-dependency cognitive memory engine and interactive 2D graph visualizer:

  • The Cognitive Triad Engine: Instead of logging raw chat messages, it stores structured technical episodes (Problem Roadblock ➔ Mitigation Heuristic ➔ Verified Solution + Domain Tags) in an embedded local SQLite database.
  • Dynamic Knowledge Graph: It automatically derives directional relationship edges (HAS_PROBLEM, MITIGATED_BY, SOLVED_BY) and connects disparate incidents through shared domain tags into an interactive knowledge cluster.
  • Cyber-Cockpit Visualizer: A single-screen, zero-build web interface (running at http://localhost:8000) featuring glowing 2D physics graph navigation (Vis-Network), real-time search filtering, a sliding inspection drawer, and a manual "+ Teach Memory" modal so humans can also train their agent's second brain.
  • Dual-Tool Model Context Protocol (MCP) Server: Ships with a native stdio JSON-RPC server (mcp_server.py) exposing memoria_record and memoria_recall. External AI agents can autonomously query past proven fixes and store newly discovered solutions without human intervention.
  • 1-Click Sample Seeder: Includes 3 sanitized generic developer troubleshooting cases (JWT 401 Expiration, React SSR Hydration, Docker OOMKilled 137) so anyone can evaluate the graph instantly with zero setup.

How we built it

We built MemoriaGraph Lite using the official Devpost Learn "Plan-First" Skill Pack (1-start through 6-ship) in pair-programming collaboration with Google Antigravity:

  1. Planning First: We established the core kernel and trimmed all bloat in devpost/scope.md, crafted the exact user journey in devpost/prd.md, and drafted the technical architecture in devpost/spec.md before writing code.
  2. Tech Stack: Python 3.12, FastAPI for high-performance REST endpoints, embedded SQLite for 100% portable zero-config persistence, Vis-Network for zero-compile responsive canvas physics, and stdio JSON-RPC for MCP.
  3. Thin Verifiable Slices: Implementation was broken into 4 thin, testable slices. Each slice was verified with automated assertion test suites (test_slice1.py, test_slice2.py, test_slice3.py) before committing to Git.

Challenges we ran into

  • Zero-Build Graph Topology: We wanted hackathon judges to be able to run the project in seconds without dealing with complex database installations (like Neo4j) or npm build pipelines (node_modules). Deriving rich graph relations directly inside a lightweight SQLite engine while maintaining an instant Vis-Network CDN interface solved this cleanly.
  • Cross-Platform CLI Compatibility: Ensuring seamless execution across Linux/macOS (python3 server.py) and Windows environments (py server.py) required careful handling of stdio encoding and command paths in the MCP documentation.
  • Zero-Leakage Privacy Guardrails: Guaranteeing that preloaded demo cases remained strictly generic and sanitized, ensuring zero private operational data or credentials ever entered the public repository.

Accomplishments that we're proud of

  • True 1-Command Startup: Anyone can clone the repo and launch the full interactive cockpit in under 30 seconds (pip install -r requirements.txt && python3 server.py or py server.py).
  • Interoperable MCP Server: AI coding agents (Google Antigravity, Claude Code, Cursor) can immediately plug into MemoriaGraph Lite via standard stdio JSON-RPC to autonomously record and recall memories.
  • 100% Verified Codebase: Every slice was empirically tested with zero broken builds, verified by regression test scripts.
  • Complete Plan-First Artifacts: Full adherence to Devpost Learn curriculum, complete with an interactive architectural guide (devpost/app-map.html).

What we learned

  • The Power of Spec-Driven Boundaries: Spending time up front defining the Problem ➔ Mitigation ➔ Solution triad and explicitly cutting non-essential features saved hours of refactoring.
  • Slices Over Layers: Delivering vertical end-to-end slices (database + API + UI + test) at each step proved infinitely more reliable than building horizontal layers in isolation.

What's next for MemoriaGraph Lite

  • Adding local vector embeddings for semantic hybrid search alongside keyword matching.
  • Implementing automated passive transcript harvesting from IDE sessions.
  • Exporting memory graphs to Markdown and Obsidian vault formats.

Built With

Share this project:

Updates

Submission history