Your Codebase Is a Graph, Not a Vector Database

The Hype Moment: When Assistants Forget

The current generation of AI coding assistants can write a function, refactor a class, and explain a regex. What they cannot do is remember where the auth middleware intersects with the billing pipeline three modules away. They operate like brilliant interns with goldfish memory: every prompt starts from near zero, reconstructing context file by file, grep by grep. Graphify arrived at the peak of this frustration—a Y Combinator S26 project that promises to turn an entire repository into a queryable map that persists between sessions. It has since accumulated tens of thousands of GitHub stars and hundreds of thousands of PyPI downloads, according to its project site, not by replacing your assistant but by turning it into a cartographer.

The timing is deliberate. As assistants multiply—Claude Code, Codex, Cursor, Gemini CLI, and a dozen others—developers are realizing that a larger context window is not the same as memory. A million tokens of inline context is still a linear scroll; it lacks topology. Graphify’s bet is that code is inherently relational, and relationships are cheaper to traverse than embeddings are to retrieve.

The Core Idea: Structure Over Similarity

Most retrieval systems treat code as prose. They chunk files, embed them, and return the nearest neighbors by cosine similarity. This works for documentation; it fails for architecture. A function that calls your database pool is not semantically similar to the pool definition—it is structurally adjacent. Graphify builds its graph by combining two extraction pipelines. For source code across more than thirty languages, it runs Tree-sitter locally to produce abstract syntax trees, call graphs, and import links. Nothing leaves the machine. For documents, PDFs, images, and video, it uses the assistant’s own LLM API to extract semantic concepts. The two pipelines merge into a single NetworkX graph, which is then clustered using the Leiden algorithm—on topology alone, with no vector embeddings required.

The result is a graph that knows, for instance, that DigestAuth connects to Response not because the words look alike, but because the AST found the call edge. The system surfaces “god nodes”—the high-degree concepts everything flows through—and “surprising connections,” cross-file links that a human might miss. In a worked example using a mixed corpus of GPT framework repositories and attention papers, Graphify claims a 71.5× reduction in query tokens compared to naive file-injection, dropping the average request from roughly 123,000 tokens to 1,700 by letting the assistant query structure instead of rereading files.

This hybrid approach is the project’s central insight. Code has syntax; prose has meaning. Trying to reduce both to the same embedding space flattens the very structure that makes code understandable. By keeping AST extraction local and LLM extraction semantic, Graphify preserves privacy for the bulk of the corpus while still allowing multi-modal ingestion.

The Boring Part That Matters: Incremental Patches

Knowledge graphs are not new. What usually kills them in production is the rebuild cost. Traditional RAG pipelines re-embed the entire corpus when a file changes; at enterprise scale, this is measured in hours. Graphify’s project site emphasizes a live, patch-based update model: when a file changes, only affected nodes and edges are re-extracted and spliced into the existing graph. The rest of the corpus stays intact, even at millions of files. A file watcher can trigger AST-only updates in seconds, and the system includes a git merge driver that union-merges the graph file automatically so parallel commits do not leave conflict markers.

This incrementalism is the difference between a research demo and a daily driver. It also explains why Graphify insists on committing the output directory to version control: the graph becomes team infrastructure, not a local cache.

Distribution by Infiltration

Graphify is not an IDE, a database, or a SaaS dashboard. It is a skill file that installs into the assistant itself. It supports more than twenty platforms, from Claude Code and Codex to Kilo Code, Trae, and Google Antigravity. On platforms that support hooks, it fires before search-style tool calls, nudging the assistant to query the graph instead of grepping raw files. On others, persistent instruction files provide the same guidance.

This is a shrewd distribution strategy. Instead of asking developers to switch tools, Graphify asks them to invoke it once and then forgets it is there, silently redirecting assistant behavior toward structured queries. The Memgraph blog describes a similar vision with Graph-Code, but that approach is Dockerized and tied to a specific graph database. Graphify is lighter: it runs wherever Python runs, stores JSON locally, and exports to HTML or Obsidian for human browsing.

The GraphRAG Shadow and Academic Validation

Graphify sits in the slipstream of a larger trend: GraphRAG. Microsoft’s GraphRAG has explored knowledge graphs for general document analysis, and the DataStax documentation shows GraphRAG outperforming vector retrieval for generating working code from documentation. An arXiv paper from May 2025 validates the specific case for code, demonstrating that repository-level knowledge graphs improve retrieval context and outperform baseline RAG on the EvoCodeBench benchmark for code generation. The paper argues that hybrid retrieval—combining graph traversal with semantic search—captures inter-file modular dependencies that vector similarity misses.

Graphify’s niche is the assistant-native, polyglot, multi-modal variant of this idea. Where Microsoft GraphRAG is designed for news analysis and security audits according to its community discussions, and Memgraph’s Graph-Code is a containerized coding assistant, Graphify is a portable skill that treats the codebase as one node type in a broader personal knowledge graph. The Daytona dotfiles article frames this as “giving your codebase a voice,” though most implementations remain experimental. Graphify is attempting to productize the pipeline without requiring a Docker container or a separate graph database server.

This matters because the alternative is often a heavyweight enterprise stack. Graphify runs wherever Python runs, stores its output as JSON, and exports to HTML or Obsidian for human browsing. It is less a database and more a prosthetic memory for the assistant.

Glue, Grit, and Ghost Duplicates

It would be generous to call Graphify a compiler; it is orchestration. Tree-sitter parses, NetworkX stores, Leiden clusters, and an LLM API labels communities. The engineering value lies in stitching these together with incremental caching, security boundaries, and a platform matrix that would exhaust a lesser maintainer. The README is honest about the rough edges. Semantic and AST extraction occasionally disagree on node IDs, producing “ghost duplicates” that require a forced rebuild. The interactive HTML visualization chokes above five thousand nodes. Ollama backends can exhaust VRAM if the KV-cache window auto-sizes too aggressively. And the install matrix is so wide that edge cases are inevitable. These are not fatal flaws; they are the scars of a project that chose breadth first and incremental updates over theoretical purity.

Outlook: From Repo to Life Graph

Graphify’s open-source core is MIT-licensed and local-first, but the project site makes clear where the founders are heading. Penpax, their commercial layer, applies the same graph approach to meetings, browser history, emails, and files—an always-on personal knowledge graph that updates continuously in the background. An enterprise tier is waitlisted, promising million-file corpora, team-shared graphs, and cloud or air-gapped deployment.

The tension is obvious. A graph that spans your codebase is a utility; a graph that spans your life is a surveillance system, however well-intentioned. The open-source version’s promise of “no telemetry, no usage tracking” becomes harder to guarantee at cloud scale. The technical question is whether a JSON file and NetworkX can survive that expansion, or whether Graphify will eventually become a database company wearing a skill file’s clothing. The founders claim the enterprise version will support incremental growth at millions of edges, but the leap from a local Python tool to a team-wide, always-on memory layer is steep.

For now, Graphify occupies a useful middle ground: not a replacement for your assistant, but a cartographic layer that turns every codebase into something you can query instead of read. That is a genuinely special trick. Whether it remains a developer tool or becomes a platform will depend on whether the graph can grow without losing the incremental speed that made it interesting in the first place.