Show HN: Graphenium, persistent repo memory for AI coding assistants Graphenium, a new tool for AI coding assistants, provides persistent structural memory by turning a repository into a queryable graph, enabling fast navigation of large codebases without reading files. It addresses issues like cold starts and context window pressure in multi-module projects, and is compatible with MCP-based assistants like Claude and Cursor. Persistent structural memory for AI coding agents. Graphenium turns your repository into a queryable graph so Claude, Cursor, and other MCP-compatible assistants can answer these in ~20 ms, without reading a single file. Especially valuable in large, multi-module, or unfamiliar codebases where grep-and-trace navigation breaks down: - What calls this function? - What depends on this module? - What are the architectural hubs? - What is the shortest path between these components? - Which files belong to the same community? It replaces grep-and-trace navigation, not source-code understanding. AI coding assistants are good at reading code, but they navigate repositories like a human using grep : search for a symbol, open the file, follow imports, open more files, infer relationships. Then do it all again in the next session. In a 50-file project, grep works. In a 5,000-file monorepo with deep import chains, it doesn't. That workflow has five persistent problems: Repeated cold starts. Every new session begins without a durable model of the repository. Context window pressure. Raw source files are large; navigation consumes tokens that could be used for reasoning. No structural memory. After reading files, the assistant has no persisted graph of how modules, functions, and concepts relate. Missed cross-file relationships. Grep surfaces text matches, not architectural topology, hubs, communities, or paths. Scale multiplies the pain. Every new file and dependency makes the grep-and-trace loop slower and more expensive. The graph stays fast regardless of repo size. Graphenium runs analysis once, persists the result as a graph, and exposes it to assistants via an MCP https://modelcontextprotocol.io server. The graph becomes the assistant's long-term memory for your repository. What changes: Orientation in seconds, not minutes. architecture summary gives a 30-second map of the codebase before the assistant reads a single file. Context stays focused. Instead of filling the context window with raw source during navigation, the assistant reasons over compact graph output and reads only the files that matter. Memory survives sessions. The graph persists. A new AI session starts with the same structural knowledge the last one had. Good at Navigating large codebases. In 50+ file repos, monorepos, or unfamiliar projects, grep-and-trace wastes context; the graph replaces it.- AI-assisted code navigation: answer structural questions without repeatedly reading files. - Impact analysis: identify connected nodes before changing a function, class, or module. - Onboarding: get a high-level architectural map of an unfamiliar repo fast. - Refactoring planning: find god nodes, low-cohesion communities, and surprising cross-boundary edges. - Code review: inspect symbols, degrees, and hotspots before reviewing a changed file. - Keeping the graph current with watch mode during active development. Not a replacement for Reading source code. The graph captures structure and relationships, not implementation logic. An assistant still needs to read actual code. A full language server. It does not perform complete type checking or language-specific semantic analysis at LSP depth. Runtime tracing. It is static analysis plus optional LLM extraction; it does not execute the program. Semantic search / embeddings. Graphenium uses keyword scoring and graph traversal, not vector similarity. Security scanning. Relationship graphs are not a substitute for dedicated SAST tools. Without Graphenium: grep → read file → trace imports → read more files → infer architecture With Graphenium: query graph → get neighbors → shortest path → read only the right files Build a graph for your project no API key needed gm run . --no-semantic --no-viz Ask structural questions gm query "what calls build from extraction?" Or connect an AI assistant via MCP and ask directly curl -fsSL https://raw.githubusercontent.com/lambda-alpha-labs/Graphenium/main/install.sh | sh Requires Rust 1.75+ rustup https://rustup.rs . git clone https://github.com/lambda-alpha-labs/Graphenium cd Graphenium cargo install --path . The binary is installed as gm . Build a graph no API key needed gm run . --no-semantic --no-viz Query it gm query "authentication login session" --budget 1000 Check your installation gm doctor Graphenium has two extraction modes. Both are useful; they serve different purposes. | Mode | What you get | Best for | API key | |---|---|---|---| AST-only | Imports, containment, methods, symbols, structural communities | Architecture map, blast radius, orientation | No | Semantic | Uses, conceptual dependencies, rationale, inferred cross-file relationships | Behavioural tracing, richer agent reasoning | Yes | AST-only mode gives the assistant a map. Semantic mode adds the traffic overlay. AST-only, local, no key needed gm run . --no-semantic --no-viz Semantic: adds LLM-inferred relationships export ANTHROPIC API KEY=sk-ant-... gm run . --provider anthropic also: openai, deepseek, openrouter The graph stats tool always reports the edge confidence breakdown, so the assistant knows what it's working with. Add Graphenium to your AI assistant's MCP config. The server uses the standard MCP stdio transport. Or run gm setup