Unified Memory Across AI Coding Assistants with Hook-Based Neo4j Integration

In the rapidly evolving landscape of AI-assisted coding, developers often toggle between different assistants like Claude Code, Codex, and Cursor. Each tool brings unique strengths, but context is lost when switching. This guide explores how hook-based implementations, coupled with Neo4j, provide a unified persistent memory layer across these harnesses—without locking you into any single ecosystem. Read on to understand the architecture, benefits, and practical steps.

What is unified agentic memory?

Unified agentic memory refers to a shared, persistent storage system that maintains context, conversation history, and learned information across multiple AI coding assistants. Instead of each assistant starting from scratch, hooks intercept and sync data to a central knowledge graph (Neo4j). This means that a project structure discussed in Claude Code can be recalled later in Cursor or Codex. The memory is not just a log but a structured, queryable graph that captures relationships between code entities, user intents, and past decisions. This enables a continuous workflow where every interaction enriches the collective intelligence of all connected assistants.

How do hooks enable persistent memory across harnesses?

Hooks are lightweight, non-invasive callbacks that trigger at key lifecycle events in each AI assistant—such as after a response is generated or before a new query is processed. In this implementation, hooks capture the raw interaction data (prompts, responses, metadata) and push it to a Neo4j instance. The same hook logic is applied to Claude Code, Codex, and Cursor, ensuring a consistent data pipeline. Because hooks run locally or on a dedicated server, they don't modify the core behavior of the assistants. The persistent memory is thus achieved without forking or customizing the official tools—you simply attach the hook to each harness. This design respects the original software's integrity while adding a powerful shared memory layer.

Why choose Neo4j as the underlying database?

Neo4j is a graph database that excels at modeling relationships—exactly what agentic memory needs. Conversations are not flat logs; they are interconnected threads involving code snippets, error messages, user goals, and file dependencies. Neo4j stores this as nodes and edges, allowing queries like “find all suggestions related to authentication module” or “retrieve the last three fixes for this bug.” This graph structure enables fast traversal and pattern matching, which is far more efficient than relational joins for complex context retrieval. Additionally, Neo4j's ACID transactions guarantee data integrity across concurrent hook operations. By using Neo4j, the unified memory becomes not just persistent but also contextually rich and easily searchable.

How does this approach avoid vendor lock-in?

Vendor lock-in often occurs when a platform provides integrated, proprietary memory. Here, the memory layer is wholly external and independent of any assistant. Hooks are generic—they only need to conform to a simple schema for push/pull operations. If tomorrow a new AI coding assistant emerges, you can write a slim hook plugin (often less than 50 lines of code) to connect it to the same Neo4j instance. The centralized memory graph remains unchanged. Conversely, if you decide to stop using Cursor, its data stays in the graph for other assistants to leverage. This separation of concerns means you are never forced to stick with one tool; your accumulated knowledge follows you across platforms. The hooks act as adapters, making the ecosystem modular and future-proof.

What are the key benefits for team workflows?

For teams, unified memory transforms collaboration. When multiple developers use different assistants (or the same assistant with different accounts), hooks sync all interactions to a shared Neo4j graph. This means team members can query “how did we solve the memory leak last week?” and get consistent answers regardless of who was using which tool. Onboarding new hires becomes faster because historical context is instantly accessible. Moreover, the graph can be integrated into CI/CD pipelines: all code discussions and decisions are automatically archived and linkable to commits. This creates a living documentation that grows organically. The result is reduced duplication of effort, fewer context switches, and a collective intelligence that scales with the team's usage.

What are the steps to set up hooks with Neo4j?

Setting up the system involves three main stages. First, deploy a Neo4j instance (local Docker or AuraDB cloud). Create a graph schema with nodes like Session, Prompt, Response, CodeEntity, and relationships such as LEADS_TO or REFERENCES. Second, for each assistant (Claude Code, Codex, Cursor), write a small hook script in your language of choice (Python or Node.js). The script listens to the assistant's output stream, extracts relevant fields, and executes Cypher queries to insert/update nodes. Third, configure the assistant to call this hook via its plugin or extension mechanism—for instance, Claude Code's custom actions or Cursor's event system. Once running, you can test by asking a question in one assistant and verifying that the memory appears in another. Detailed templates are available in the official GitHub repository.

What challenges might arise and how to overcome them?

One common challenge is data duplication: multiple hooks may write the same interaction if the same assistant is used on different machines. To mitigate this, include a unique session ID and deduplicate via Cypher’s MERGE clause. Another issue is latency—if the Neo4j instance is remote, hook writes can slow down the assistant's response. A solution is to use async hooks that fire and forget, or implement a local message queue (RabbitMQ) to batch writes. Privacy is also a concern; ensure that hooks are deployed in a secure environment and that sensitive code is sanitized before storage. Finally, when working with large codebases, the graph can grow quickly. Regular cleanup and archiving strategies (e.g., time-to-live on old sessions) keep performance optimal. By anticipating these obstacles, teams can enjoy robust unified memory without friction.