GRAFEMA·v0.4.2·FSL-1.1-Apache-2.0·Open source

Your codebase
as a queryable graph.

Code, infrastructure, observability and related knowledge in a single place.//Define guarantees, track dependencies, catch violations before they ship.

Nodes indexed
2.35M
Edges
1.31M
Languages
11+
L4 accuracy
+10%
CTA · Drop in your agent or shell   Tools · 30+
// Paste into Claude Code, Cursor, Codex, Aider — anything that listens. I want to onboard onto this codebase with Grafema — graph-based code intelligence with an MCP server. It treats the repo as a queryable knowledge graph (entities, calls, dataflow, contracts) instead of a pile of text files. Do a full onboarding pass for me: 1) Install the CLI: npm install -g grafema 2) Configure & index this repo. Work out the right config for the project, then index it (auto-detects language, ~30s on a mid-size repo): grafema analyze --quickstart Then tell me the coverage — what got indexed, and what didn't. 3) Register Grafema as an MCP server so you can query the graph from here. Add to .mcp.json (or .cursor/mcp.json): { "mcpServers": { "grafema": { "command": "npx", "args": ["grafema-mcp", "--project", "."] } } } No need to restart — the grafema CLI runs the same analyses, so you can do this whole first pass via the CLI right now; the MCP tools come online next session. 4) Build a high-level picture. Run the ontology crawler (grafema crawl) to learn the project's ontology and general shape, then explain in plain language what this project is, what it does, and how it's structured. 5) Use the graph — not grep — to find what matters: • bottlenecks, dead code, and room to refactor • systemic fragility: what's most dangerous to change (blast_radius) • the real features, contracts, and interfaces between parts • where parts/microservices connect, and which plugins would need writing to link them in the graph 6) Read the version-control history to spot the places that break again and again, and the fragile code around them. 7) Propose a handful of guarantees (invariants / contracts) that would stop those bugs from recurring or those fragile spots from breaking — with graph evidence for each. 8) Then ask me what I actually care about and where my pain is right now, and dig into that. If anything goes wrong — an install error, a tool you don't recognize, output that looks off — read the docs at https://grafema.dev/docs before guessing, and consult the source at https://github.com/Disentinel/grafema for internals or to file an issue. Don't silently fall back to grep — tell me what failed and we'll fix it together.
// PAYLOAD
2270 chars · 8 steps
// TARGET
Claude · Cursor · Codex
02 //Manifest

Code as text is just form.
Structure is what matters.

Code is NOT
  • ×A sequence of bytes you grep through
  • ×A pile of files an LLM has to read end-to-end
  • ×Documentation that drifts the moment it ships
  • ×A string-matching game with cargo-cult heuristics
→
Code IS
  • ▸A graph of entities and relations
  • ▸A system of invariants, goals, and effects
  • ▸Executable knowledge — already there, in the AST
  • ▸A structure you can navigate, query, and reason about
// So what shiftsFour concrete moves once the graph exists.
01
grep→walk
grep dies
Text search never understood structure. The graph does. Walk edges, not lines.
02
200 files→7 edges
Agents stop reading
An LLM reads everything to answer one thing. Grafema brings back the seven hops that matter.
03
find→explain
Questions get bigger
"Where is X used" becomes "how does X flow through the system" — with citations.
04
files→graph
Code shows its shape
The thing your codebase always was underneath: an executable graph of relations.
03 //Atlas

The agent sees the system.
So can you.

Atlas is the visual layer over the graph — a deterministic map of your codebase, projected from real imports and real calls. Open it on Grafema's own source, or pipe in yours.

LIVE · grafema/grafema · analyze → storage
Grafema Atlas — navigatorclick a node (A), then another (B) to route
overlay
call 0data 0cross-boundary 0integration 0
analyze → storage…
04 //Quick start

Three commands. Forty-five seconds.

No account. No telemetry. The graph lives in .grafema/ next to your repo — so the LLM you trust does the talking, and Grafema just hands it the right facts. Or skip the LLM part entirely and use the CLI or VS Code extension — learn more in the docs.

01
Install
$npm install -g grafema
Node 18+. Also available via brew, cargo, or as a single static binary.
02
Index
$grafema analyze --quickstart
Auto-detects language, indexes the repo into a local graph (~30s on a 200k-LOC project).
03
Trace
$grafema wtf req.user
Where does this value come from? Also: tldr · who · why · trace · impact · overview — graph-grounded, no LLM. Same data your agent gets.
MCP server (for agents).mcp.json
{
  "mcpServers": {
    "grafema": {
      "command": "npx",
      "args": ["grafema-mcp", "--project", "."]
    }
  }
}
find_nodesfind_callsfind_callersfind_definitiontrace_dataflowcontrol_flowblast_radiuscluster_summaryeffect_propagation
30+ tools. Drops the prompt cost on L4 architecture questions by ~40% — and improves accuracy by ~10% against vanilla file-reading agents.
tldr
grafema tldr <file>
Semantic summary of a file. What does it do, what does it own, who depends on it.
who
grafema who <symbol>
Who calls this? Who imports it? Direct + transitive, with citations.
wtf
grafema wtf <symbol>
Where does this value come from? Backward dataflow trace to its origin — hops + evidence.
why
grafema why <symbol>
Explain a symbol from the graph — the actual code paths and evidence that justify it.
Language support11 + counting
TypeScriptFirst-classJavaScriptFirst-classPythonGoRustJavaKotlinC#RubyPHPC++
05 //Welcome

Welcome to the party.

Grafema born to fight complexity in big codebase.
And to stop Copilot inventing nonexistent functions.
Just to make software maintenance less painful.

So I need your help — and I want to hear your pain.
If something's broken, file feedback.
If it works and you're excited — share it.
And maybe mention grafema on X, if you like.
★ Star on GitHub→Read the docsFile feedback
Vadim Reshetnikov · 2026
FSL-1.1-Apache-2.0
Built with hex grids and stubbornness