Claude Code can read your files. It can grep your functions. What it can't do is remember why your code exists, what was tried before, or what your team decided last month. NeuralGraph Code gives every session the context that makes the difference.
AI coding assistants are powerful code generators. But they start every session blind to the accumulated knowledge of your project. These aren't hypothetical problems — they happen dozens of times a day on real codebases.
Your codebase has three different S3 upload patterns. The original one in pkg/storage/
uses the low-level PutObject API. Six months ago, Sarah refactored the media pipeline to use
multipart uploads because files grew past 5GB. Last month, David added a presigned URL flow
for client-side uploads.
Claude reads the code and sees all three. Without context, it picks one — probably the first one it finds. Maybe it writes a fourth pattern. The team reviews the PR and says "we use the presigned URL flow for this, see the media pipeline."
Without NeuralGraphClaude generates a new upload function using PutObject. PR rejected, 20 minutes wasted.
With NeuralGraphClaude sees the decision history, uses the right pattern, and the PR is clean.
A test in the payment service fails intermittently on CI. It passed locally every time. Three months ago, someone on the team spent two days debugging this exact class of failure and found it was a race condition in the test database setup — the fix was adding a transaction wrapper.
That debugging session happened in a Claude Code conversation that's long gone. The commit message says "fix flaky payment test" with no details. The new developer starts the investigation from scratch.
With NeuralGraphTwo days of debugging reduced to reading one paragraph.
Your team has specific auth conventions — middleware ordering matters, certain endpoints need scope-based checks, the JWT validation library has a known quirk with clock skew. These aren't in a README. They're in the heads of the three engineers who built the auth layer.
With NeuralGraphA cross-team initiative touches fifteen repositories. The architecture decisions, library choices, and migration patterns were discussed across dozens of conversations. A new engineer joins the project and needs to get up to speed.
With NeuralGraphThe new engineer clones the repo and immediately has the full project context.
NeuralGraph Code doesn't index your source files — Claude already reads those. It captures the knowledge that lives between the lines: the reasoning, the history, the decisions that shaped the code.
Why Chi over Gin. Why Postgres over DynamoDB. What was considered and rejected, and what constraints drove the choice.
How your team does error handling. Which testing patterns to follow. Where to put new endpoints. The conventions that aren't in a linter.
The SQLite deadlock that took two days to debug. The API quirk that requires a specific header. Problems solved once, never re-investigated.
How to run the integration tests. The deploy script flags. The docker-compose override for local dev. Commands that work.
What was worked on yesterday. What was accomplished in the last refactor. The narrative of how the codebase evolved, session by session.
Your coding style across all projects. Language preferences. How you like explanations. Carried between repos automatically.
Most memory tools ask you to do something. Tag this. Save that. "Hey AI, remember this for later." NeuralGraph Code asks nothing. You don't tell it what to remember. The LLM doesn't decide what to store. Nobody calls a "save" command.
You code. You talk to Claude. You commit. That's it. You never type "remember this." You never tag a conversation as important. You never organize your memories into folders. The system captures context from the natural lifecycle of your work — conversations that get long enough to compact, commits that land — without any action from you.
Claude doesn't decide what to remember. It doesn't call a tool to store context. It doesn't choose whether to recall — context is injected before Claude even sees your message. The read path is a programmatic hook, not an LLM judgment call. This means retrieval is deterministic, fast, and never forgotten because the model "didn't think to look."
Hooks fire on lifecycle events that already happen. Conversation compacted? Knowledge
extracted. Code committed? Context captured. New prompt? Relevant memories injected.
The write path runs on events. The read path runs on every prompt. Both are automatic.
The only manual action is the initial npx @neuralgraph/code init — after that,
memory accumulates silently.
NeuralGraph Code hooks into Claude Code's lifecycle events. Context flows in before every prompt, knowledge flows out on compaction and commit. No tool calls, no commands, no decisions.
Before Claude sees your message, NeuralGraph searches your project's memory for relevant knowledge. Decisions about the module you're touching. Issues in the file you're editing. Patterns your team follows. Injected as context — Claude doesn't call a tool, it just knows.
When Claude Code compacts a long conversation, the summary is ingested into NeuralGraph. The extraction pipeline identifies decisions, explanations, issues, and patterns — structuring them as searchable knowledge nodes with semantic triggers.
Each git commit is a decision point. NeuralGraph captures the commit message and changed files, linking them to the session's reasoning. Future developers can trace not just what changed, but why.
Memories that keep surfacing get stronger. Memories that stop being relevant fade. The retrieval adapts to your actual workflow — no manual curation needed.
Context lives at different scopes. NeuralGraph Code maintains three memory layers, queried together on every prompt.
One per git repo. Stores the institutional knowledge of that codebase — architecture decisions,
coding patterns, known issues, useful commands. Shared by everyone who works on the repo.
Committed to git via .neuralgraph/spaces.yaml so new engineers get context on clone.
One per cross-repo initiative. When a feature touches multiple services, the decisions and requirements that span repos live here. "All new Kotlin services must use kotlin-auth-lib" appears in every repo that's part of the migration.
One per developer, private and portable. Your coding style, language preferences, tool choices. Follows you across every project. "Prefers early returns" and "senior Go engineer, beginner at React" shape how Claude communicates with you specifically.
NeuralGraph Code is designed for engineering organizations, not just individual developers.
Engineers sign in with their corporate Google account. Domain-based tenant mapping means zero provisioning — if you're @company.com, you're in.
Tenant boundaries are enforced on every API call. Your org's data never leaks to another tenant. Developer preferences are private even within a team.
Every engineer's sessions contribute to the collective knowledge of the codebase. New team members inherit months of context on day one.
Platform-wide decisions, architecture standards, and migration plans surface in every repo they affect. One source of truth.
Install the Claude Code plugin and sign in. Context starts flowing automatically.