Graphify

Questions like “how does a request reach the database?” or “what breaks if I change parseConfig?” usually cost an agent a long chain of greps and file reads. The Graphify plugin maps your workspace into a knowledge graph with graphify , an open-source tool by Graphify-Labs: files, functions, classes, calls, imports, Markdown sections and NOTE: / WHY: comments, grouped into subsystems. A connected agent asks the graph in plain words or by symbol name and gets the relevant part of it in one call, with file and line for every hit.

The card draws the graph as a map, and every query an agent makes plays on it live: you see what the agent asked, which nodes it started from, how the search spread and what it found.

How to use it

In the add-card menu choose Plugin…, open Graphify in the Plugins tab and press Add to canvas.
Press Install on the card (once per computer). NeuroSquad downloads uv 0.12.22 from GitHub and checks it against the checksum pinned in the app, uv sets up a private Python 3.12, and then installs graphify 0.9.74 from PyPI with every package pinned by hash (--require-hashes, binary wheels only). About 250 MB, all in the app’s data folder. Your own Python, uv or pip settings are not used and not changed.
The card then builds the graph of the whole workspace by itself. It shows the files read so far, the total and an estimate of the time left.
Draw an arrow from an agent to the card.

The agent now has the graph tools. Most CLIs pick them up without a restart; remove the arrow and they are gone.

What the agent can do

Tool	What it answers
`graphify_query`	A question in words or symbol names → the relevant subgraph (symbols, files with lines, calls/imports edges)
`graphify_neighbors`	Everything one symbol calls, is called by, imports or is imported by, with the file:line of each use
`graphify_path`	The shortest chain of calls/imports between two things
`graphify_affected`	The blast radius of a change: everything that depends on a symbol or file, transitively
`graphify_node`	Where one symbol is, its type and its subsystem
`graphify_community`	Every member of one subsystem
`graphify_god_nodes`	The most connected symbols: the core of the codebase
`graphify_stats`	Size of the graph and how many links were read directly from the code
`graphify_reindex`	Update the graph now, after edits made a moment ago

While the first build is still running, the tools answer with how far it is (“still building: 37%, 170 of 461 files…”), so the agent can carry on with its usual search and ask again later.

How agents are guided to the graph

An agent that has a graph tool does not always use it: models are used to grep. Graphify adds three light layers, none of which blocks anything:

Tool descriptions say when the graph is the better choice (“use this before grep when the question is about structure”) and when text search is still right (string literals, log messages, config values). In Claude Code, graphify_query, graphify_neighbors and graphify_affected are always loaded instead of waiting behind a tool search.
A note on the first turn. The first turn of a session that has the arrow carries one short, factual note: what the graph is, which tool answers which question, and when grep is still the right tool. Later turns carry a one-line reminder when the prompt is about code structure (and every fifth turn regardless). When you remove the arrow, the next turn gets one note that the tools are gone. Claude Code, Codex and Qwen Code receive it through their prompt hook; OpenCode, Kilo Code, pi, omp and Gemini CLI through NeuroSquad’s plugin, extension or hook bridge. Other CLIs get the tools only.
A hint before a text search (Claude Code). When the agent is about to run Grep, Glob, or a grep / rg / find command for something that looks like a symbol name, it gets one line of context pointing at graphify_neighbors and graphify_query. The search still runs exactly as requested: no permission decision is made, your allow and deny rules and prompts work as before. The hint stays quiet for two minutes after the agent used the graph, and comes at most every 45 seconds and every fourth search.

Turn Guide agents to the graph off in the card’s settings to keep only the tools.

The map

Files are drawn as dots sized by how much they contain and coloured by subsystem. Zoom in (or press Show symbols) to see the functions and classes around each file.
Live queries. When an agent asks the graph, its starting nodes ripple, the search spreads hop by hop along the links it followed, and the results panel lists what was found with file and line. Press a result to centre the map on it, or open the file in your editor.
Timeline at the bottom: recent queries with who asked them. Press one to replay it.
Search the graph yourself from the box in the corner; the matches light up the same way.
Click a node for its details and links; Fit the map brings everything back into view.
Expand the card for a large view of the map.

Pan with the mouse, zoom with the wheel; the map pauses its animations while you zoom the canvas or when the card is off screen.

Always up to date

With Auto-update on (the default), the card notices changed files and updates the graph about 4 seconds after the last change. It also updates after a connected agent finishes a turn, and once when you open the app. graphify keeps a cache of every file it has read, so an update re-reads only what changed. Turn it off to update by hand with Update now.

Settings

The settings button on the card’s header:

Auto-update and Guide agents to the graph (see above).
Languages: leave whole languages out of the graph.
Also ignore: extra patterns, one per line, in .gitignore syntax. .gitignore and .graphifyignore in the project are always respected.
Include git-ignored files: for generated code that belongs in the graph.

Changing what is indexed rebuilds the graph.

WSL and SSH workspaces

WSL: graphify runs on Windows and reads the distro’s files through their Windows path. For a project on a Windows drive (/mnt/c/…) the card watches the files as usual; for one on the distro’s own disk it updates after a connected agent’s turn and on Update now.
SSH: not supported; the card says so. Use the Code Graph plugin, which runs its engine on the SSH host.

Graphify or Code Graph?

Both index your code; they answer different questions well, and you can use both at once.

	Code Graph	Graphify
Best at	Exact navigation: callers and callees, code snippets, read-only Cypher, semantic search	Questions in words → the relevant subgraph, how things connect, what a change affects
Also maps	Routes, packages	Subsystems, Markdown sections, `NOTE:` / `WHY:` comments
On the card	Index stats and a search box	The live map with every query animated
WSL / SSH	Runs inside WSL and on SSH hosts	WSL through Windows paths; no SSH

The graph is built from the workspace’s folder. An agent working in an isolated worktree still queries the graph of the main folder.

Privacy and storage

Everything runs on your computer. Graphify reads code only (no documents, images or other content that would need a language model), no language model backend is ever used and no API key reaches it. graphify has no telemetry, and its optional query log is switched off. The engine lives in the app’s data folder, and each graph in graphify/projects/<folder>-<hash>/ there. Nothing is written into your project or your home folder. Deleting the last card of a folder deletes its graph.

graphify is made by Graphify-Labs and published under the Apache License 2.0.

Troubleshooting

Install fails behind a proxy. uv uses HTTPS_PROXY / HTTP_PROXY from the app’s environment; set it before starting NeuroSquad and press Install again.
Install fails with “no matching distribution”. One of the packages has no binary wheel for your system; graphify is not built from source. The card shows uv’s message.
“Still building”. The first build of a very large workspace takes a while; the card shows the progress. Agents get the same progress when they ask.
The agent keeps grepping. Check that the arrow is there, that Guide agents to the graph is on, and that the agent’s CLI is one of those that get the guidance (the card marks the others as tools only). Asking it once (“use graphify to find…”) also works.
The map is empty or misses files. Check Languages and Also ignore in the settings, and the project’s .gitignore.
The card says SSH is not supported. Use the Code Graph plugin for SSH workspaces.