EngramAtlas

EngramAtlas maps your knowledge like a brain. It uses advanced AI agents to connect, organize, and surface your data instantly, turning scattered information into actionable, structured intelligence.

Comment

Inspiration

Human thoughts are messy, non-linear, and fluid—essentially "cognitive noise" like raw voice memos, sketches, and sporadic web links. Yet, modern tools force us to organize them into rigid, static folder hierarchies, which breaks our natural cognitive flow. Inspired by cellular membranes and biological metabolism, we wanted to build a knowledge engine that treats the input interface as a membrane, letting fuzzy thoughts self-organize and form dynamic, evolving memory networks just like the human brain.

What it does

EngramAtlas is a bio-inspired knowledge engine that ingests diverse multimodal inputs (text, voice, hand-drawn images, PDFs, URLs) and dynamically projects them into a shared 3,072-dimensional semantic vector space. We leverage Google Cloud Agent Builder (ADK) as the core brain powered by Gemini 3.5. When new information enters, the system autonomously measures vector similarity against existing knowledge (threshold: 0.55) to spin bi-directional connections, complete with Agent-generated contextual reasoning of why they relate. It features an interactive 3D Memory Map powered by a custom Force-Directed Canvas layout, an autonomous "conversational forget" mechanism to prune dead links surgically, and a triage-based resilience system that handles API rate limits (HTTP 429) using exponential backoff.

How we built it

We designed a decoupled gateway-agent architecture:

  • Core Brain: Implemented via Google Cloud Agent Builder (Vertex AI Agent Engine ADK) to manage agent routing, system instructions, and high-level reasoning.
  • Gateway Server: Built on Node.js and Express to manage Firebase authentication, security headers, SSRF network sanitization, and spawn the agent session dynamically.
  • Storage & Graph: Integrated MongoDB Atlas as the primary semantic graph database.
  • Dynamic Failover: Implemented a dynamic failover system; if the MongoDB Atlas connection experiences issues or is offline, the gateway instantly switches to a zero-config in-memory Mock DB fallback, preserving graph integrity.

Challenges we ran into

Integrating a Python-based Google Cloud Agent Builder into a lightweight Node.js gateway without adding heavy HTTP container overhead. We overcame this by building a stream-based communication protocol supporting UTF-8 BOM parsing and base64 multimodal payloads. Additionally, managing database unavailability (e.g. firewall DNS blocks) required us to implement isMongoActive real-time state updates across all endpoints. If a database query throws a connection exception, the engine seamlessly downgrades to mock operations, preventing application crashes.

Accomplishments that we're proud of

We are proud of achieving a perfect 100/100 on our rigorous Evaluation Driven Development (EDD) suite, verifying all 9 core assertions for autonomous linking, resilience, ADK integration, and semantic integrity. Optimizing the Docker container to package both Python 3 dependencies (google-genai) and the Node runtime allows us to deploy the entire stack to Google Cloud Run with a single command. Also, building a fully functional 3D graph visualization from scratch on HTML5 Canvas without relying on bloated external libraries was a major engineering victory.

What we learned

We learned the power of separating the input/output gateway from the agent brain. Delegating intent analysis and multimodal ingestion to Google Cloud Agent Builder simplified our Express routing logic while maintaining high cognitive reasoning. We also discovered that pairing Agent Builder with a self-healing database fallback makes agentic applications enterprise-ready and robust against external outages.

What's next for EngramAtlas

Next, we aim to register actual OpenAPI schemas and MongoDB Atlas MCP servers directly into the Google Cloud console's Agent Builder Tools to let the Agent perform database writes autonomously at the model level. We also plan to optimize the underlying force-directed physics engine using WebGL to seamlessly handle tens of thousands of simultaneous memory nodes.

Built With

Share this project:

Updates