DEV Community: Graphify Labs Inc

Why vector search isn't enough for coding agents

Syed Fahad — Fri, 30 Oct 2026 16:21:05 +0000

Ask a coding agent "where does an expired token get rejected?" and vector search will usually find something that sounds right. The hard part is the next step. The agent has to work out how that code connects to the code it's about to change.

Since our post on code knowledge graphs vs RAG, readers have asked for one thing above all: show it end to end. One question, the code it finds, the dependency path the graph returns, and a label on every hop saying whether it was read from the source or inferred. This post does exactly that. Everything below the "Worked example" heading is real output from open-source Graphify, run on a public repo you can clone yourself.

What others have already shown

We're not the first to look at this, and the best published examples are worth reading in full:

The orphan function. In Codebase Knowledge Base Series (05), WonderLab asks about "process payment". Vector top-5 returns get_payment_history and verify_webhook_signature, which look like payments but don't answer the question. One CALLS hop from process_checkout brings in calculate_order_total, the function that does. In their words, it's "semantically distant but structurally close."
The bug three hops down. Tian Pan's Code-Specific RAG traces processPayment → validateCard → checkFraudScore → fetchUserHistory. A query surfaces the first function, "but the actual bug or context lives in fetchUserHistory. Token-based retrieval stops at the first hop."
Look-alike functions. In CodeBot, InkyLab points out that training and inference preprocessing "look almost identical. A vector search can't tell them apart." Their fix is resolved calls edges over the Ultralytics codebase.
Ranking by references. Aider's repo map uses tree-sitter to pull out definitions and references, then ranks them on a dependency graph to fit a token budget.
On a benchmark. RepoGraph (Ouyang et al.) builds a line-level definition/reference graph and retrieves ego-graphs around keywords. Plugged into four SWE-bench systems, it reports an average relative improvement of 32.8%.

They all land in the same place. Finding the starting point is the easy part. Structure is how you get from there to everything the change touches. What most of these write-ups leave out is the question readers keep asking: how far can you trust each hop? That's where Graphify's labelled edges come in.

Worked example: itsdangerous, one question

The repo is pallets/itsdangerous (commit 672971d), the small library Flask uses to sign cookies and tokens. It's small enough to check every line by hand.

Building the graph uses only the parser, with no LLM call:

$ graphify update src
[graphify watch] Rebuilt: 152 nodes, 346 edges, 7 communities

Step 1: the question finds the relevant code

$ graphify query "where does an expired timestamp raise SignatureExpired"
Graph: src/graphify-out/graph.json (152 nodes) | Traversal: BFS depth=2 |
Start: ['SignatureExpired', 'TimestampSigner', 'Raised if a signature does not match.'] | 64 nodes found

From a plain-language question, Graphify went straight to SignatureExpired and TimestampSigner, the code that handles expiry. A list of matching chunks would stop here. Graphify keeps going.

Step 2: the graph returns the path, with a label on every hop

The same query returns the edges around those start nodes. Here are the ones that answer the question, copied as printed:

EDGE TimestampSigner --method [EXTRACTED]--> .unsign() at=src/itsdangerous/timed.py:L72
EDGE .unsign() --calls [EXTRACTED context=call]--> SignatureExpired at=src/itsdangerous/timed.py:L142
EDGE SignatureExpired --inherits [EXTRACTED]--> BadTimeSignature at=src/itsdangerous/exc.py:L60
EDGE TimestampSigner --inherits [EXTRACTED]--> Signer at=src/itsdangerous/timed.py:L22
EDGE TimestampSigner --uses [INFERRED]--> SignatureExpired at=src/itsdangerous/timed.py:L142
EDGE TimedSerializer --uses [INFERRED]--> SignatureExpired at=src/itsdangerous/timed.py:L213

Then we ask for the shortest route from the serializer most apps actually call:

$ graphify path "TimedSerializer" "SignatureExpired"
Shortest path (1 hops):
  TimedSerializer --uses [INFERRED]--> SignatureExpired

Step 3: check each hop against the source

.unsign() --calls--> SignatureExpired, EXTRACTED, timed.py:L142. The parser read this straight from the call site:

if age > max_age:
    raise SignatureExpired(

That's the answer to the question, and it's backed by a line number.

SignatureExpired --inherits--> BadTimeSignature, EXTRACTED. It's in the class definition. It also matters for the change: any except BadTimeSignature or except BadSignature will catch expiry too.

TimedSerializer --uses--> SignatureExpired, INFERRED, timed.py:L213. No line has TimedSerializer calling SignatureExpired. The resolver linked them because the class body refers to the exception. Open line 213 and you'll find it isn't raised there. It's caught and re-raised:

except SignatureExpired:
    # The signature was unsigned successfully but was
    # expired. Do not try the next signer.
    raise

The inferred edge points at exactly the right line, and the label tells the agent this is the one hop worth a quick look before it edits. That's the point of provenance. Without labels, every hop looks equally certain. With Graphify, the agent knows which hops are read straight from the source and which one to verify.

What the agent ends up knowing

Say the task is "make expired tokens return a 401 instead of a 500." Here's what each approach hands the agent:

Graphify, with labelled hops:
- The exact raise site (L142, parser-backed).
- The exception hierarchy that decides which except blocks catch it (parser-backed).
- The one place a serializer deliberately re-raises it (inferred, flagged to verify).

Every hop comes with a file, a line number and a label, so the agent can make the change with the whole path in view.

Why the graph matters

Finding the code answers "where is the code about X?"
A code knowledge graph answers "what does X call, what calls X, and what catches it?" That's the question behind most risky changes, and the one WonderLab, Tian Pan, InkyLab, Aider and RepoGraph all show similarity alone can't answer.
Provenance labels tell the agent when it can move on and when to read the source first. EXTRACTED means the edge was read directly from the source. INFERRED means Graphify resolved it.

Graphify gives the agent all three in one answer.

Try it on your own repo

The fastest way to try this is the hosted Graphify app.

To run it locally, use the Graphify CLI:

uv tool install graphifyy
graphify install          # sets up the skill for Claude Code; use --platform for other assistants
graphify update .         # build the code graph
graphify query "where does an expired token get rejected?"
graphify path "TimedSerializer" "SignatureExpired"

Codex uses $graphify instead of /graphify.

Over MCP, the same operations are available as query_graph, shortest_path and get_node, so any MCP client can use them. The source is at github.com/Graphify-Labs/graphify.

What's next

Next, we want to run the same trace on a larger repo with hundreds of inferred edges, and measure how often an INFERRED hop holds up when you check it against the source. If you have a repo where vector search keeps sending your agent to the wrong place, tell us in the comments or on Discord, and we'll trace it.

Thanks to the authors linked above for publishing examples we could build on.

Syed Fahad and the Graphify team

Graphify made it to GitHub's Octoverse 2026

Syed Fahad — Wed, 28 Oct 2026 20:19:56 +0000

We're in GitHub's Octoverse 2026. I had to read it twice.

Octoverse is GitHub's yearly look at what happened in open source. This year's report has a list of the most-engaged open source repositories, and Graphify-Labs/graphify is No. 7 on the single-vendor and product-led side. That's next to microsoft/vscode, anomalyco/opencode, and BerriAI/litellm. The report covers 1 October 2025 to 30 September 2026.

Our first commit was 5 April 2026. Six months later, GitHub put us in its year-in-review.

Octoverse, built by the community

Engagement means people. You starred the repo, filed issues, sent pull requests, answered questions in Discord, and wrote about Graphify on your own blogs. That's what this list counted.

As of 29 October 2026, the repo has more than 137,000 stars and more than 13,000 forks. The graphifyy package was downloaded from PyPI more than 1.6 million times in the last month.

Two weeks ago we wrote about 125,000 GitHub stars, and before that about 8 million PyPI downloads. Octoverse is GitHub telling the same story.

What doesn't change

If you're new here: Graphify turns your codebase into a map your AI assistant can read, so its answers come from your actual code.

Your code is parsed on your machine.
Every relationship is tagged EXTRACTED or INFERRED.
You get a knowledge graph your assistant can query and walk.
Graphify stays Apache 2.0.

Type /graphify in Claude Code, Cursor, Gemini CLI, or Copilot ($graphify in Codex), and you get a map of your codebase.

Beyond the repo: what's on graphify.com

The open source engine runs on your machine, and that stays. graphify.com is where the same graph runs hosted, kept current for you.

The hosted Graphify MCP server gives Claude Code, Cursor, Codex, Copilot, and other agents one endpoint with an OAuth sign-in, so they query the graph instead of re-reading files. The Graphify integrations page lists the assistants it works with and the tools your code comes in from. Hosted plans add pull request reviews and formal verification, and a workspace can hold more than code, like a Google Drive folder.

Graphify pricing starts with a free plan for one developer, then Pro, Teams, and Enterprise. Graphify Enterprise runs self-hosted or air-gapped, with SAML single sign-on. Pre-seed and seed teams can apply to the Graphify for Startups program for 50% off Teams.

If you'd rather help build, GraphGuild is our community program for people who answer questions, write, and host events.

Thank you

This one belongs to every contributor, every bug report, and everyone who told a teammate about Graphify. Thanks also to the GitHub team for the recognition and the artwork.

If Graphify has helped you, star it on GitHub. It's the easiest way to tell us to keep going.

Syed Fahad and the Graphify team

Grounded answers: how Graphify tags what it knows

Syed Fahad — Wed, 28 Oct 2026 12:27:07 +0000

Confidence tags on a Graphify graph say how each edge was established, before an agent follows it. EXTRACTED means tree-sitter found the call, import, or definition in the syntax tree. INFERRED means a model connected it. AMBIGUOUS means the evidence did not resolve, and the edge stays flagged. Read the tag before you trust the hop.

What do the confidence tags mean?

A code knowledge graph stores functions, classes, and docs as nodes. Calls, imports, and references are the edges between them. The edge is the claim the assistant walks. Confidence tags are the label on that claim. How Graphify works builds the graph in two stages, and the tag says which stage produced the edge.

EXTRACTED comes from the syntax tree. Graphify parses code on the machine with tree-sitter. The parser finds the call, the import, or the definition, and that edge is deterministic. Parse the same file again and the parser finds the same edge. No model sits in that step. The Cursor integration describes this tag as parsed from the AST.

INFERRED is a connection a model made. Docs, PDFs, and recordings are not a tree of calls. (SQL schemas and Terraform are parsed, so their edges are EXTRACTED.) The model you configure joins a doc page to the service it describes, or a runbook to the Terraform resource it covers. Those edges are usually right. They are still a judgment, and the tag says so. A plausible link can be wrong. The tag is how you see that the link was proposed.

AMBIGUOUS means Graphify found evidence and could not resolve it. The cases named in the glossary are dynamic dispatch, reflection, and an import built from a string. The edge stays in the graph with the flag, so the unresolved link is visible as unresolved.

graphify explain shows how each connection on a node was established. GRAPH_REPORT.md separates the architecture the parser extracted from the connections the model proposed. Over MCP, graph_stats and the confidence audit in the report break the graph down by the three tags, so you can see how much of the map is parsed fact.

Why should an agent read the tag before the next hop?

An answer from the graph is a path. Each hop names a file and a line, and the edge on that hop carries one tag. The tags are different evidence. A caller the parser found and a doc the model attached can both appear in the same path, and the output keeps them distinct.

Treat every hop as fact and an INFERRED link gets the same weight as an EXTRACTED call. That is how a guessed connection becomes an edit. The glossary uses this picture: the payment worker depends on the sessions table. You want to see whether the parser found that, or a model inferred it, before you change the code.

Lean on an EXTRACTED hop when you change code. Treat an INFERRED hop as a lead, and open the doc and the symbol. Treat an AMBIGUOUS hop as a place to read the source, because the evidence stopped short of a resolved link.

A similarity score says two chunks resemble each other. It does not record whether a relationship was parsed or proposed. That difference is the subject of Code knowledge graph vs RAG.

Where do confidence tags not help?

The tag describes an edge. It does not answer "find this string." Grep returns the lines that contain the string. A misspelled word in a comment, or a URL in a config file, is that question. Grep answers the hop you can phrase as a string. A tag will not.

Fuzzy search over a large body of prose is the other miss. Embeddings are the better tool there, and Graphify does not try to beat them. A tag will not find the paragraph that only resembles the question.

What runs on the machine?

The open-source engine is Apache 2.0. Code parsing happens on your machine. There is no telemetry. INFERRED edges use the model backend you configure, and that backend can be a local one, so the judgment can stay on the machine too. The graph is files in graphify-out/: graph.html, GRAPH_REPORT.md, and graph.json.

Graphify Cloud hosts the same kind of graph and keeps it current. It is a different product.

uv tool install graphifyy

The package on PyPI is graphifyy (two y's). pipx install graphifyy also works. Then graphify install, and in the assistant /graphify .. The command reference is in the docs.

Why graphs beat vectors for agent memory

Syed Fahad — Wed, 28 Oct 2026 12:26:57 +0000

A code graph stores the calls and imports in a codebase, and the assistant still has them next session. A vector database stores text that resembles the question, then searches again. The code graph vs vector database difference is what the assistant remembers.

How does a code graph differ from a vector database?

A code graph stores typed entities and the relationships between them. A Knowledge graph is that structure. The entities are the things in the repo. The edges are how they connect, and an assistant can traverse them. A vector database stores embeddings and metadata filters. A filter limits which vectors return. The relationship lives on the graph as an edge, and that edge is still there when the assistant starts again.

How similarity and structure compare as ways to fetch an answer is in Code knowledge graph vs RAG.

What does a query return?

A graph query is a typed, multi-hop traversal. The assistant follows edges of a given type, one hop after another. A vector query is approximate nearest-neighbour search, a top-k of the chunks whose embeddings sit nearest the question.

Graphify vs vector databases sets the two side by side. Pinecone, Weaviate, and pgvector return the most similar vectors. The graph returns the entities and the relationships between them. For an assistant, that result is the memory.

What happens on the second hop?

The gap shows up when a question has two steps. A top-k lookup is one round of nearest-neighbour search, so a second hop needs the first answer before it can even be phrased. The model is left stitching disconnected chunks together.

On a graph the second hop is one more edge. A later session follows that same edge, because the edge was stored with the graph.

What stays when a file changes?

Changing a file means re-embedding and upserting every chunk it touched before any of it can be retrieved again. Graphify re-parses that one file and updates its nodes. The edges that did not change stay. The cost of keeping current is the size of the change, not the size of the repository.

Inside the assistant, the command is /graphify . --update.

How can you check an answer?

A vector result comes with a similarity score. The score measures how near two vectors were. A graph result is the path the answer took. Every edge on that path carries a confidence tag: EXTRACTED, INFERRED, or AMBIGUOUS.

The tag is stored on the edge, so the next session can read that path.

Where does the text go?

Vector data is often shipped to an embedding API. Graphify is on-device, and it sends no telemetry.

Where does a vector database still win?

Graphify vs vector databases has nine rows. Eight of them are a real difference. The ninth is the one they win. A vector index answers what looks like this, and for fuzzy similarity over large volumes of prose it is still the better tool.

Can you run both?

You can run both. Some teams keep a vector index for semantic recall and use Graphify for structure. Graphify can store embeddings as node attributes, so similarity stays one signal inside a traversal.

Hybrid search blends keyword and vector scores. What comes back is still a ranked list of disconnected chunks. A graph returns connected entities, and the structure survives retrieval. Graphify vs RAG is that choice for a retrieval pipeline. After the session ends, those connections are on the graph.

Does Graphify replace Pinecone, Weaviate, or pgvector?

As coding-assistant memory, retrieval becomes a traversal over typed edges. The answer arrives as connected entities, and the path is there to read. Graphify does not replace Pinecone, Weaviate, or pgvector for every workload. Those products keep their place for pure similarity, and Graphify runs alongside them.

Is Graphify a graph database like Neo4j?

Graphify is a memory layer. It builds the graph from your codebase and serves it over MCP and the CLI. There is no schema to model and no queries to write. If you already run Neo4j or FalkorDB, it exports into them.

Proof

Steve Scargall, at MemVerge, reported 79× fewer tokens on a 496K-token codebase, with no vector database in the stack. That is his measurement, not a Graphify benchmark.

Install

The package on PyPI is graphifyy. Install the CLI, then register it with your assistant.

uv tool install graphifyy
graphify install

In the project, build the graph.

/graphify .

How to give GitHub Copilot codebase context that persists

Syed Fahad — Wed, 28 Oct 2026 12:26:29 +0000

GitHub Copilot codebase context vanishes when the chat ends, because each session starts from zero and Copilot searches the repo again. A graph built once on your machine is a map Copilot can query the next time. Graphify builds that graph and registers it with Copilot.

How do you give GitHub Copilot codebase context?

The GitHub Copilot integration page wires this in two commands, then a graph of the repo. The package on PyPI is graphifyy (two y's).

uv tool install graphifyy

pipx install graphifyy also works.

graphify install

graphify install registers the /graphify skill and an MCP server, so Copilot can query the graph. Graphify speaks the Model Context Protocol. Any MCP client talks to the same server and the same ten graph tools. The integration page points at the docs for how to point Copilot at that server.

Build the graph on the project you have open. In Copilot, run:

/graphify .

Tree-sitter parses the code locally, so call and import edges come from the syntax tree. Docs and other non-code files are read by the model you already use. The map lands in graphify-out/ as graph.html, GRAPH_REPORT.md, and graph.json. The next session queries those files. The architecture is already on disk.

A knowledge graph here means entities and the typed relationships between them. The same shape of setup for Cursor is How to give Cursor a code knowledge graph.

What can Copilot ask once the graph exists?

The questions on the integration page are the ones that used to mean reading a large slice of the repo. What calls chargeCustomer, and what breaks if the signature changes. The path from a checkout endpoint to the table it writes. Which modules read a config value such as STRIPE_KEY. How the auth subsystem hangs together before you touch it.

You can run the same questions from the shell. The page names these commands:

graphify query "what calls chargeCustomer"
graphify path "checkout" "database"
graphify explain "AuthService"
graphify prs

graphify query returns a scoped piece of the graph. graphify path walks the hops between two nodes. graphify explain lists the edges on one symbol. graphify prs is the pull-request command listed beside them. The docs cover its flags.

Every edge Copilot gets back carries a confidence tag. EXTRACTED was parsed from the AST with tree-sitter. INFERRED means a model connected non-code material, such as a doc to the service it describes, and the tag marks that judgment. AMBIGUOUS means there was evidence and it could not be fully resolved, as with dynamic dispatch or an import built from a string. The edge is kept and flagged.

When Copilot returns a path, open the file and line on the hop you are about to trust, and read the tag on that edge. An EXTRACTED edge is the parser. An INFERRED edge is the model joining a doc or a schema to code. It can be wrong and still sound plausible. An AMBIGUOUS edge is unresolved evidence, kept so the gap stays visible. The integration page describes the return value as connected structure, a path, which still holds past one or two hops. A pile of matching files, with the links guessed in the chat, is the loop this replaces.

What does the graph leave to you?

The graph does not update itself. After the code changes, run /graphify . again, or /graphify . --update to re-scan only what changed. From the shell, graphify update . does that pass. graphify hook install adds post-commit and post-checkout git hooks that refresh the changed files. Until you refresh, Copilot is reading the last map you built.

Grep still wins when the question is "find this string." The graph is for relationships. A literal string in a comment is still a search.

The open-source engine runs on your machine. Code parsing is local. There is no telemetry. Graphify Cloud is the hosted graph. This guide is the on-device setup. Cloud is a different product.

How do you confirm it is wired?

uv tool install graphifyy
graphify install

Then, in Copilot:

/graphify .

The command reference is in the docs. Copilot-specific notes stay on the GitHub Copilot integration page.

Best codebase-context tools for AI coding assistants (2026)

Syed Fahad — Wed, 28 Oct 2026 12:26:19 +0000

The best codebase context tools depend on the question you are asking. Grep finds a string. Embeddings, RAG, and a vector database find prose that resembles the question. A code knowledge graph follows a relationship you can open. Hosted search and review tools serve a person, or a pull request.

Question	A tool that fits
Find this string	grep
Prose that resembles the question	Embeddings, RAG, or a vector database
What calls what, hop by hop	A code knowledge graph
Search across the organisation	Sourcegraph
Comments on an open pull request	Greptile or CodeRabbit
Code that looks like this, inside Cursor	Cursor's own index

What is grep best at?

Grep is best when the question is "find this string." It returns the lines that contain the text. One hop is usually in reach too: the direct callers of a function, when the name in the call matches the name you searched.

Past that hop, text search gets worse. A question such as what breaks if this schema changes runs through the table, the queries, the services, and the endpoints. Each hop adds name collisions, re-exports, and files that mention the symbol without touching it.

What are embeddings, RAG, and a vector database best at?

They are best at fuzzy recall over prose. Graphify vs RAG describes retrieval-augmented generation the way Lewis et al. (2020) introduced it: split documents into chunks, embed them, and pull back the top-k most similar. That works for lookup, when the answer sits in one passage.

A relationship is a different shape. Chunking drops the link between a function and its caller. A two-hop question needs the first answer before the second can be asked, which is why benchmarks such as HotpotQA exist. Graphify vs vector databases names Pinecone, Weaviate, and pgvector: nearest-neighbour search returns similar vectors. A metadata filter narrows that search. Hybrid search still comes back as a ranked list of disconnected chunks.

A changed file is re-embedded before those chunks can be retrieved again. A similarity score measures resemblance, and you judge the answer yourself. Chunks in a typical embedding pipeline go to an embedding API.

Keep the vector index when the corpus is prose. Some teams run both: vectors for semantic recall, a graph for relationships. Graphify can store an embedding as one signal on a node, and retrieval is still a walk. If you already run Neo4j or FalkorDB, the graph exports into them. The essay form of this argument is Code knowledge graph vs RAG.

What is a code knowledge graph best at?

A code knowledge graph is best when the assistant needs a relationship: what calls this, what a change reaches, the path from one symbol to another. Graphify builds that graph from the repo. Code is parsed on the machine with tree-sitter, and each edge carries a confidence tag: EXTRACTED from the syntax tree, INFERRED by a model, or AMBIGUOUS when the evidence did not resolve. An answer is a path you can open.

There is no telemetry on the open-source engine. Graphify Cloud is the hosted graph. It is a different product.

Graphify is the wrong tool for two of the jobs in the table. Fuzzy prose still belongs to embeddings. "Find this string" still belongs to grep.

What are hosted search and review tools best at?

Graphify vs Sourcegraph is a code search platform people use. The index covers the organisation, every repository, cloud or self-hosted, under a commercial licence. Search across thousands of repositories is the job that page says Sourcegraph is built for. Graphify maps the repositories you point it at, on the machine where you work, and the assistant walks that map. The two can run together.

Greptile is hosted review and codebase chat. It indexes your code, and you see pull-request comments plus its own chat. Managed review on every pull request is its core product. graphify prs is on demand. A managed bot that fits your policies is Greptile's job. A graph on the machine fits when the code cannot leave, or when you want each claim auditable.

Graphify vs Cursor indexing is the page whose answer is to use both. Cursor's index is embedding similarity inside the editor, automatic, with indexing through Cursor's servers. It surfaces code that looks like what you half remember, and there is nothing to set up. Connected questions are where it runs out. "What breaks if I change this" is a caller of a caller, and the model stitches similar snippets. You also cannot inspect why a snippet was pulled in. Graphify registers as an MCP server, the built-in index stays on, and the agent uses the graph when the question is structural.

Graphify vs CodeRabbit acts after the pull request opens: comments in GitHub or GitLab, through a hosted service, once the change is already written. Graphify is for the assistant writing the code, so it can ask what calls this before the edit. Graph-aware review in Graphify is Enterprise, early access, running in your own infrastructure. For a managed bot on every pull request today, that page says a service is the right shape. A common setup is the graph on the machine while code is written, and a hosted reviewer on the pull requests that follow.

How to give Cursor a code knowledge graph (2026 guide)

Syed Fahad — Wed, 28 Oct 2026 12:26:10 +0000

Out of the box, Cursor answers codebase questions by searching. It greps for a symbol, opens the files that match, reads them into context, and assembles an answer. That works, and it is expensive in a specific way. The exploration repeats every session, the same files get re-read, and the architectural picture the agent builds is gone the moment you close the window.

A code knowledge graph changes the move available to the agent. Instead of re-deriving structure from text, Cursor queries a persistent map of your repo: functions, classes, tables, and config as nodes; calls, imports, and references as typed edges. The graph is built once and stored on your machine. Graphify is the open-source (Apache 2.0) tool that builds that graph and hands it to Cursor. The whole setup is four commands.

How it works

Install the CLI. The package on PyPI is graphifyy (two y's). That puts the graphify command on your path.

uv tool install graphifyy

Wire Cursor. graphify install detects Cursor and registers Graphify over the Model Context Protocol, the open standard Cursor already speaks for external tools. Cursor's agent can then call the graph mid-conversation: query the structure, trace a path between two nodes, explain why a node matters. No config files to hand-edit. The Cursor integration page has the specifics.

graphify install

Map the repo. In your next agent session, or from the shell, run /graphify . in the project. Graphify parses your code locally across about 40 languages, including SQL, Postgres schemas, and Terraform, so the call and import edges come from real AST extraction. No model is involved in reading your source. Docs and PDFs are folded in by whichever model you choose.

A few minutes later, three files sit in graphify-out/:

graph.html: an interactive map you can open in a browser
GRAPH_REPORT.md: a written brief covering god nodes, subsystem communities, and suggested questions
graph.json: the raw structure

Ask structural questions. Try the ones that used to trigger long search-and-read loops: what calls this function, what is the blast radius of renaming this column, how does the webhook handler reach the database. Cursor answers by traversing the graph (a handful of nodes and edges rather than the full text of every matching file). Every edge carries a provenance tag: EXTRACTED from the AST, INFERRED by the model, or AMBIGUOUS when the evidence could not be resolved. Why that tagging matters is in concepts.

You can run the same queries yourself:

graphify query "what calls this handler"
graphify path "webhook" "database"
graphify explain "APIRouter"

The command reference lives in the docs.

The limit

The open-source engine runs on your machine. Code parsing is local. There is no telemetry. The only optional network call is the model used to fold non-code sources into the graph, and that can stay local with Ollama.

Re-run /graphify . when the code changes meaningfully, or graphify . --update to re-scan only what changed. Between refreshes the graph is plain files in graphify-out/. It does not update itself.

Graphify Cloud is the hosted, always-on graph: the same map, kept current across repos, queryable from any assistant. This guide is the on-device setup. Cloud is a different product.

This does not replace Cursor's grep. It gives the agent a map to consult first. For a question that is really "find this string," grep is still the right tool.

Proof

Graph answers are small, and the graph persists, so context stops being spent on re-discovery. Actual savings depend on your repo and your questions. One community user reported 71.5× fewer tokens on their workload. That is their measurement, not a Graphify benchmark. The claim underneath it is that a traversal sends less text than a file dump.

The other change is qualitative. Because every answer traces to a path through real files, you can audit what Cursor tells you instead of taking a plausible-sounding reconstruction on faith. Open GRAPH_REPORT.md once. The god nodes and subsystem communities it names are usually worth knowing about even before the agent starts using them.

Install

uv tool install graphifyy
graphify install

Then, in Cursor:

/graphify .

First-graph walkthrough: docs.graphify.com/guides/first-graph. Cursor-specific notes: graphify.com/integrations/cursor.

How to give Claude Code a code knowledge graph (2026 guide)

Syed Fahad — Wed, 28 Oct 2026 12:26:00 +0000

Claude Code starts each session by searching the repo. It greps for a name, opens the files that match, and reads them into the conversation. A code knowledge graph for Claude Code gives it a map it can query instead, so the session starts from structure that already exists on your machine.

What does graphify install write for Claude Code?

The package on PyPI is graphifyy, with two y's. Install the CLI first.

uv tool install graphifyy

pipx install graphifyy also works. If the shell then says graphify is not found, run uv tool update-shell and open a new terminal. ~/.local/bin is not on PATH until you do.

The bare graphify install targets Claude Code. It writes the /graphify skill to ~/.claude/skills/graphify/SKILL.md, adds a graphify section to ~/.claude/CLAUDE.md, and writes PreToolUse hooks to .claude/settings.json. When you type /graphify, that section tells Claude Code to follow the skill before it does anything else.

graphify install --project writes those pieces inside the repo, so a team can commit them. The skill path there is .claude/skills/graphify/SKILL.md, and the hook settings go in .claude/settings.json. The command prints a git add hint. Teammates need the graphifyy CLI installed.

If you see ModuleNotFoundError: No module named 'graphify', the usual cause on Mac or Windows is a plain pip install. The skill resolves Python from graphify-out/.graphify_python, which can point at a different environment than pip used. Use the uv or pipx install above. Both isolate the package.

The registration block is on Graphify + Claude Code: a code knowledge graph.

How do you build the graph?

In a Claude Code session, type /graphify .. The skill maps the project into graphify-out/. graph.html is the interactive view, GRAPH_REPORT.md has the highlights and suggested questions, and graph.json is the queryable graph.

On PowerShell, type graphify .. The leading slash in /graphify . is parsed as a path separator there.

If /graphify does nothing, check that ~/.claude/skills/graphify/SKILL.md exists and that the graphify section is in CLAUDE.md. Start a new Claude Code session so both are picked up.

The background is in What is a code knowledge graph?. The glossary page is Knowledge graph.

How does Claude Code query the graph?

Before Claude Code greps or opens files one by one, the hook-guard reminds it to try the graph. graphify query returns a scoped subgraph for a question. graphify path returns the dependency path between two symbols. graphify explain returns everything connected to a node. Ask what calls chargeCustomer, and what breaks if you change its signature.

graphify query "what calls chargeCustomer, and what breaks if I change its signature?"
graphify path "A" "B"
graphify explain "chargeCustomer"

Results include file:line citations. Every edge is tagged EXTRACTED, INFERRED, or AMBIGUOUS. The tags separate what was found from what was guessed.

What does strict mode change?

A normal install nudges Claude Code toward the graph. graphify install --project --strict blocks the first raw source read of a session and redirects that read to the graph. After that one block, the hook goes back to the soft nudge.

GRAPHIFY_HOOK_STRICT=1 or 0 toggles strict mode at runtime. No reinstall.

How does the graph stay current?

graphify update . re-extracts changed files. That pass is AST-only. graphify hook install adds post-commit and post-checkout git hooks that run the update on commit and checkout. The graph does not update itself.

Hook commands store an absolute path to the interpreter at install time. After you upgrade, run graphify hook install again so the embedded interpreter path stays fresh. If the PreToolUse hooks stop firing after an upgrade, run graphify install again.

Do you need the MCP server?

The skill plus the CLI is the complete default. The MCP server is optional. Add .mcp.json at the project root when you want the graph as native tools, or when several assistants should share one graph.

{
  "mcpServers": {
    "graphify": {
      "command": "python",
      "args": ["-m", "graphify.serve", "graphify-out/graph.json"]
    }
  }
}

You can call query_graph, shortest_path, god_nodes, graph_stats, and a PR-triage set. The rest are in the MCP tools reference.

When should you use grep?

Grep wins when the question is "find this string."

Code is parsed locally across about 40 languages, 34 of them with tree-sitter grammars. The model you already use in Claude Code reads docs and PDFs. There is no telemetry.

The installer replaces or appends only its own graphify section and leaves the rest of CLAUDE.md alone. graphify claude uninstall removes the Claude Code pieces. graphify uninstall removes every platform at once. It also removes the graphify section from CLAUDE.md, and deletes that file only if graphify created it. graphify uninstall --purge also deletes graphify-out/.

How do you install it?

uv tool install graphifyy
graphify install

Then open the repo in Claude Code and run /graphify ..

100,000 GitHub stars

Syed Fahad — Wed, 28 Oct 2026 12:25:48 +0000

We hit 100,000 GitHub stars. github.com/Graphify-Labs/graphify

That is 117 days after the first commit. Graphify has now been downloaded more than 4 million times, forked more than 10,000 times, and runs inside more than 20 AI coding assistants.

That still feels surreal.

I am a knowledge graph researcher. When Andrej Karpathy posted about using LLMs to build personal knowledge bases, something clicked: a coding assistant should not have to grep its way through a codebase every time you ask it a question. It should have a map. I built the first version that weekend and pushed it to GitHub on 5 April. One person and a tree-sitter parser.

We had 4,000 stars on day one and 10,000 by day two, almost entirely because people we had never met posted about it on X. We never optimised for stars. We optimised for one thing: type /graphify in your assistant and get something useful back in thirty seconds. Stars are a side effect of that. But a milestone is a good moment to stop and look back, and this one is really about a community that showed up, stuck around, and built things we never planned for.

What hasn't changed

The principles are the same ones I wrote down that first weekend.

Your code stays on your machine. Code is parsed locally and deterministically. No LLM call, nothing sent anywhere.
Every edge is explained. Each relationship is tagged EXTRACTED or INFERRED, so you always know what was read straight from the source and what Graphify resolved.
A graph, not a vector index. No embeddings, no vector store. Something you can traverse, query, and trace from one concept to the next.
Simple enough to onboard yourself. Two commands to install, one to run.

Standing on open source

Graphify is built on top of other people's work, and we would not be here without it.

tree-sitter. Every code relationship in Graphify starts life as a tree-sitter AST, across dozens of languages.
Leiden community detection. This is how a codebase splits into the subsystems you see in every graph.
faster-whisper and yt-dlp. They let Graphify pull videos, talks, and recordings into the same graph as your code, transcribed locally.
Model Context Protocol. MCP turned Graphify from a report you read into a set of tools any assistant can call.
uv. The reason install takes thirty seconds instead of thirty minutes.

And thank you to the teams behind Claude Code, Cursor, Codex, Gemini CLI, Copilot, and every other assistant we plug into. You built the place where developers now work. We just try to give it a better map.

The community

The numbers that matter most to me are not the stars. More than 130 people have contributed code, and we have shipped more than 150 releases. Nearly every fix that went out this month came from an issue or a pull request someone in the community opened. People have written tutorials, recorded videos, and posted reels about Graphify that we only found out about afterwards. This month we hit #3 on GitHub's global trending list.

To everyone who starred the repo, opened an issue, sent a pull request, answered a question in Discord, or wrote about Graphify somewhere: thank you. And thank you to Andrej for the post that started all of this.

We are not done

Graphify the open-source project stays open source. That is not changing.

The thing you have asked for most is the always-on version: your code, docs, and meetings mapped continuously in the background, updated as you work, and queryable from anywhere instead of only on demand. That is what we have been building at graphify.com, and as of today early access is open at app.graphify.com, ahead of the public v1 launch.

We think every AI assistant should work from a real map of your world, not a guess. We are going to keep building until that is the default.

Thanks for all the stars.

Safi and the Graphify team

Graphify is now a ChatGPT plugin

Syed Fahad — Wed, 28 Oct 2026 12:25:18 +0000

Graphify is now a ChatGPT plugin. The same plugin works in Codex and in Dots. It connects them to the repositories you have already indexed in Graphify Cloud, through the hosted server at https://api.graphify.com/mcp. You install it from the plugin directory, sign in, and ask about a repository you are allowed to see. There is no API key to paste, and neither ChatGPT, Codex, nor a Dot builds the graph on your computer.

What does the ChatGPT plugin do?

The listing is Graphify, by Graphify Labs, under Developer Tools. The server it connects is named graphify.

Once you are signed in, ChatGPT, Codex, and a Dot can explore the indexed repositories your account is allowed to open. It can trace call paths and dependencies, assess the static impact of a change, find tests linked to that code, and keep workspace-specific engineering knowledge for later questions. A code knowledge graph is the map underneath: functions, calls, and imports, with a file and a line on each hop.

The same hosted server is what the VS Code and JetBrains installs use. The plugin is the install package ChatGPT, Codex, and Dots understand. MCP is the connection.

How do you install the ChatGPT plugin?

You need a repository whose status in Graphify Cloud is Indexed. Use ChatGPT on the web or in the desktop app, Codex in the desktop app, or a Dot. On a work workspace, an admin may have to allow the plugin before Connect is available.

Open Graphify in the ChatGPT plugin directory. You can also go to Settings, then Plugins, and choose Graphify by Graphify Labs. The sidebar has a Plugins entry too.
Select Install plugin if ChatGPT shows it, then Connect.
Your browser opens so you can sign in to Graphify and choose the workspace that holds the repository. Read the access ChatGPT asks for before you approve it.

Codex uses that same listing. In the desktop app, switch to Codex, open Plugins, and install Graphify. Connect and sign in the same way, then start a new chat and mention Graphify.

Installing the plugin does not sign you in. The connection is ready only after that Graphify sign-in finishes.

How does a Dot use the plugin?

Dots are OpenAI's always-on agents in ChatGPT. They use the plugins you have already connected. You choose which apps a Dot can open, and which actions it may run on its own.

Create the Dot in the ChatGPT desktop app, or on chatgpt.com in a desktop browser.
Open Settings, then Customize, then Plugins, and choose Graphify.
Decide which Graphify actions the Dot may run on its own, and which ones it has to ask you about.

Ask it the same questions you would ask in ChatGPT. When a Dot is researching in the background, OpenAI keeps connected apps read-only. It will not save a note or switch workspace until you ask it to, and you approve that request.

What should you ask first?

In ChatGPT, mention Graphify in the message, or choose it from +, then More, before you send. In Codex, and when you talk to a Dot, mention it the same way.

@Graphify Show my indexed repositories and help me choose one to explore.

Pick a repository from that answer, then ask one of the questions on the listing:

@Graphify Explain how authentication works in my selected repository, with supporting code locations.

@Graphify Help me assess the likely impact of a code change and find linked tests in my selected repository.

Open the file and line an answer cites before you change code. The graph tags each edge EXTRACTED, INFERRED, or AMBIGUOUS, which is what Grounded answers is about. Some tools save a note for the workspace or change which workspace is selected. Read the tool request and approve it only when that is what you meant.

What this plugin does not do

It does not search the public web, run SQL, or deploy anything. It answers from repositories indexed in your workspace. A repository that is still building, or that sits in another workspace, comes back empty. Check its status, then ask Graphify to list repositories again.

The open-source engine is a different setup. uv tool install graphifyy and graphify install register a skill with an editor on your machine. The ChatGPT plugin does not replace that, and that install does not connect ChatGPT, Codex, or a Dot. The package name on PyPI is graphifyy, with two y's.

If Graphify is missing under Settings, then Plugins, it may be unavailable on this plan, region, or workspace. If you cannot create a Dot, OpenAI is still rolling them out by plan and region, and a work workspace admin may have to turn them on. An admin turns plugins on under Workspace settings, then Plugins. If Connect says an admin disabled it, ask them to enable Graphify for your role and connect again. If ChatGPT never asked you to sign in, open Settings, then Plugins, select Graphify, and choose Connect.

Privacy and terms for the app are on graphify.com/privacy and graphify.com/terms. ChatGPT tells you, on the listing, that connecting may share relevant chats with the app. That use is covered by those pages.

OpenClaw MCP: how to connect Graphify

Syed Fahad — Wed, 28 Oct 2026 12:25:09 +0000

OpenClaw MCP is the Graphify plugin you install from ClawHub. It connects OpenClaw to the repositories you have already indexed in Graphify Cloud, through the hosted server at https://api.graphify.com/mcp. You sign in through the browser, then ask about a repository you are allowed to see. There is no API key to paste. OpenClaw does not build the graph on your computer.

What does the OpenClaw MCP plugin do?

Graphify Labs publishes @graphify-labs/graphify-mcp. The listing is Graphify MCP on ClawHub. The steps below match Graphify MCP for OpenClaw.

Once you are signed in, OpenClaw can search those indexed repositories, follow callers and dependencies, and judge what a change reaches. The map underneath is a code knowledge graph: functions, calls, and imports, with a file and a line on each hop.

The same hosted server is what Graphify MCP uses for VS Code and JetBrains, and what the ChatGPT plugin uses. The plugin is the package OpenClaw installs. MCP is the connection.

What do you need before you install?

OpenClaw with remote MCP, OAuth, and Claude-format bundle support. The package was prepared for OpenClaw 2026.9.8. Older releases may differ. The install flags are in OpenClaw's plugin install guide.
A model enabled in OpenClaw, with permission to call tools. That access is separate from your Graphify plan.
A repository indexed in your Graphify workspace. Sign in at Graphify Cloud, connect a repository, and wait until its status is Indexed. Status lives on Repositories and builds.

How do you install the OpenClaw plugin?

Open Graphify MCP on ClawHub, then install the published package and confirm OpenClaw sees it:

openclaw plugins install clawhub:@graphify-labs/graphify-mcp
openclaw plugins inspect graphify-mcp

If you already cloned graphify-mcp, the same bundle is in integrations/openclaw:

openclaw plugins install ./integrations/openclaw
openclaw plugins inspect graphify-mcp

Installing the plugin does not sign you in. If the install stops and asks you to accept capabilities, review the Graphify MCP server on that screen and accept it. On a noninteractive install, add --accept-capabilities to the same command.

How do you sign in to Graphify?

openclaw mcp set graphify '{"url":"https://api.graphify.com/mcp","transport":"streamable-http","auth":"oauth"}'
openclaw mcp login graphify
openclaw mcp doctor graphify --probe

If a server named graphify already exists, run openclaw mcp show graphify first and keep any settings you meant to keep.

The same connection, merged into your OpenClaw configuration:

{
  "mcp": {
    "servers": {
      "graphify": {
        "url": "https://api.graphify.com/mcp",
        "transport": "streamable-http",
        "auth": "oauth"
      }
    }
  }
}

Use one connection named graphify. A second name for the same URL shows the tools twice. Do not put a password or token in the configuration. OpenClaw stores the OAuth credentials.

Start a new agent session after this. If OpenClaw prints a restart instruction, follow that instruction.

What should you ask first?

Ask OpenClaw to list what the connection can see:

List my Graphify workspaces and repositories.

Pick a repository from that answer, then ask:

In my selected repository, find the function that handles authentication.

Show its callers and the linked tests, with file paths as evidence.

A connection check includes a repository lookup. Tool discovery alone does not show that the index is reachable.

Open the file and line an answer cites before you change code. These results are static. They do not run the code or the tests. Some tools save a repository note or change the selected workspace. Read each tool request and approve it only when that is what you meant.

What if the OpenClaw connection fails?

What you see	What to do
The install stops and asks you to accept capabilities	Review the Graphify MCP server on that screen and accept it. On a noninteractive install, run the same install command again with `--accept-capabilities`.
Graphify tools are hidden	Check that the plugin is enabled and that your tool policy allows it. A `bundle-mcp` denial hides these tools.
Sign-in fails	Run `openclaw mcp doctor graphify --probe`, then `openclaw mcp login graphify` again.
No repositories, or empty answers	That repository is not indexed yet, or it is in a different workspace. Check its status on Repositories and builds, then ask OpenClaw to list repositories again.
Two copies of the Graphify tools	Keep a single server named `graphify`. Remove the extra connection to the same URL.

What this plugin does not do

graphify install --platform claw installs the local skill for a graph on your machine. That path is on Other coding assistants. The OpenClaw plugin on this page connects OpenClaw to Graphify Cloud. The local command does not install the ClawHub plugin. The ClawHub plugin does not build the graph on your machine.

The package name on PyPI, for the local engine, is graphifyy, with two y's.

JetBrains MCP: how to connect Graphify

Syed Fahad — Wed, 28 Oct 2026 12:24:59 +0000

Graphify MCP is on the JetBrains Marketplace. JetBrains AI Assistant can ask about a repository you have already indexed in Graphify Cloud. You install the plugin, copy a connection from a tool window, paste it into AI Assistant, and sign in through the browser. There is no API key. The plugin does not build the graph on your computer.

The connection uses https://api.graphify.com/mcp, the same hosted server as Graphify MCP. Graphify Labs publishes the plugin as Graphify MCP. The id is com.graphify.graphify-mcp. The walkthrough below follows Graphify MCP for JetBrains.

AI Assistant gets a map of the code

AI Assistant can search the project you have open. With this connection it can also follow a code knowledge graph: which function calls which, and which file and line each hop sits on. Graphify MCP is how you give AI Assistant that map.

The Marketplace lists the plugin as free. AI Assistant is still the chat. The plugin does not upload the project you have open, and it does not keep a password of its own. Your Graphify plan is separate from Assistant access.

What you need first

A JetBrains IDE on the 2025.3 release. The published plugin accepts platform build 253 through 253.*, so it does not install on 2025.2 or on a later release.
JetBrains AI Assistant, with access to MCP.
A repository indexed in Graphify Cloud. Wait until its status is Indexed. That status is on Repositories and builds.
Node.js and npm on the IDE's PATH, only for the browser sign-in below. The direct connection does not need them.

Install the JetBrains MCP plugin

Install Graphify MCP from the Marketplace, or search for Graphify MCP by Graphify Labs under Settings, then Plugins. Restart the IDE if it asks.

Open View, then Tool Windows, then Graphify. From that window you copy the connection, open IDE settings, open your workspace, or open the setup guide.

Choose how AI Assistant signs in

Pick a method in the tool window and click Copy configuration. If a later release changes the text, copy it from the window.

Browser sign-in

Use this when AI Assistant cannot sign in to a remote server on its own. The configuration runs mcp-remote@0.14.3. That package opens a browser for Graphify sign-in and stores the credentials on your machine. Turning the configuration on is what downloads the bridge, so Node.js and npm have to be on the IDE's PATH.

{
  "mcpServers": {
    "graphify": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@0.14.3",
        "https://api.graphify.com/mcp",
        "--transport",
        "http-only"
      ]
    }
  }
}

Direct connection

Use this when the client can finish Graphify's sign-in itself. If the browser never opens, switch back to the bridge above and paste that configuration instead.

{
  "mcpServers": {
    "graphify": {
      "url": "https://api.graphify.com/mcp"
    }
  }
}

Paste it into AI Assistant

Open Settings, then Tools, then AI Assistant, then Model Context Protocol (MCP). On macOS the menu is Settings or Preferences, then the same path. Open Settings in the tool window opens the IDE settings dialog. You still have to open the MCP page yourself.

Click Add, paste the JSON, and choose this project or every project. Click OK, then Apply.

Settings, then Tools, then MCP Server is a different page. That page lets other applications use the IDE. This configuration goes on the AI Assistant MCP page.

Ask about an indexed repository

List my Graphify repositories.

Pick a repository from the answer, then try one of these:

Find the implementation of this function.
What calls this symbol, and which tests are linked to it?
Find this function and show its callers.

Open the file an answer cites before you rely on it. Some tools save notes on a repository or change the workspace you have selected. Read the request, and approve it only when that is what you meant.

If the connection fails

The plugin will not install unless the IDE is on the 2025.3 release.
If npx or Node.js is missing, install both, put them on the IDE's PATH, and restart the IDE. The browser sign-in needs them.
If the direct connection never signs in, switch the tool window to the OAuth bridge, copy that configuration, and replace the server entry.
If the answer lists no repositories, the repository is not indexed yet, or it is in another workspace. Check Repositories and builds.
If you cannot find an MCP page under AI Assistant, confirm AI Assistant is installed and that your JetBrains account can use it.

A graph that stays on your own machine is a separate setup, on Graphify MCP. This plugin talks to the hosted server, and only to repositories already indexed in Graphify Cloud.