What it actually does
Vector search over a codebase gives you fuzzy similarity. Graphify gives you structure: it parses your project deterministically with AST parsing and tree-sitter, and builds a knowledge graph where every edge is explained rather than inferred from an embedding.
That distinction matters when the question is "what breaks if I change this function?" A vector store returns things that look similar. A graph returns what actually calls it.
It ingests more than code — documentation, SQL schemas, configuration, PDFs, images, and video all become part of the same graph. You type `/graphify` in Claude Code, Cursor, Codex, or Gemini CLI and query the project instead of grepping it.
It is local and deterministic, uses Leiden community detection for clustering, and is documented in over thirty languages. Apache 2.0, 105,000 stars, with a hosted platform in early access.
Who it's for
- 01
Engineers working in a large codebase nobody fully understands anymore
- 02
Teams onboarding people into unfamiliar systems
- 03
Anyone whose agent gives confidently wrong answers about how their code fits together
- 04
Architects assessing blast radius before a significant change
Where it earns its keep
- Answering impact questions before a refactor with real call graphs
- Onboarding an engineer into a system with a queryable map instead of tribal knowledge
- Connecting code to the SQL schema and documentation that explain it
- Auditing an inherited or acquired codebase quickly
- Giving an agent structural grounding so it stops inventing relationships
Use it, or skip it
Reach for it when
- The codebase is large enough that nobody holds it in their head
- You need deterministic answers about structure, not similarity matches
- Documentation, schemas, and code need to be queried together
- You want it local rather than uploading your codebase somewhere
Skip it when
- Your codebase is small and everyone knows it
- Your languages are not well supported by the underlying parsers
- You genuinely need semantic similarity rather than structural relationships
- You have no time to maintain the graph as the codebase changes
10 automations
Ideas, not tutorials. Each one is work a team does by hand today.
- 01Engineering
Pre-refactor blast radius
Before any significant change, query what depends on the target and attach the impact list to the ticket.
- 02Operations
Onboarding map
Generate a personalised tour of the subsystems a new hire will own, grounded in real structure.
- 03Engineering
Schema-to-code tracing
Answer which code paths touch a given database column before you migrate it.
- 04Engineering
Dead code identification
Find modules with no inbound edges and propose them for deletion with the evidence attached.
- 05Founders
Acquisition due diligence
Map an acquired codebase in days rather than months and produce a structured risk summary.
- 06Engineering
Documentation gap detection
Find heavily-connected modules with no documentation and prioritise writing it.
- 07Engineering
Agent grounding layer
Give coding agents graph access so their answers about your architecture are checked rather than guessed.
- 08Operations
Ownership assignment
Use community detection clusters to propose sensible code ownership boundaries between teams.
- 09Engineering
Incident context assembly
During an incident, query everything connected to the failing component and assemble context fast.
- 10Engineering
Architecture drift review
Compare the graph quarterly to see where the real structure has diverged from the intended design.
Want one of these running by Friday?
LimeDock builds these as real workflows inside your stack — deployed to your cloud, wired into your Slack and CRM, with the code in your repo. You pay a build fee and your own API keys, nothing else.
Source
Repository stats were read from the GitHub API and reflect the last time we refreshed this entry. The editorial breakdown above is LimeDock’s own analysis — we are not affiliated with Graphify-Labs.
https://github.com/Graphify-Labs/graphify