Open Beta · Python · Java · JavaScript

Navigate code, not chaos.

Point Meridian at any GitHub repository. Get back a living, queryable knowledge graph. Ask it anything — answers cite actual nodes and files.

View on GitHub See the difference →
Scroll
The shift

Before Meridian.
After Meridian.

Stop navigating code blind. Every relationship, every call chain, every cluster — visible instantly.

Without Meridian
✕
grep -r "validate" . | grep -v test — 83 results across 29 files. Start reading.
✕
Open 12 files to trace one call chain. Lose context halfway. Start again.
✕
Ask the AI assistant. It hallucinates a file path that doesn't exist.
✕
New engineer onboarding: 2 weeks before they understand the module boundaries.
✕
Refactor causes a silent break. Nobody saw the dependency.
✕
Dead code stays forever. No one knows if it's still used.
With Meridian
✓
Ask "who calls validate?" — get every caller, cited, with file:line. In 2 seconds.
✓
The graph renders the entire call chain visually. One glance replaces 12 open files.
✓
AI answers are grounded in the live graph. Every claim links to a real node.
✓
New engineer: share the graph link. Module boundaries visible immediately.
✓
Refactor safely — every downstream dependency is an edge on the graph.
✓
Orphan nodes flagged automatically. Dead code has nowhere to hide.
What changes

From grep-ing in the dark to seeing every connection

Meridian renders your codebase as a living knowledge graph — functions, classes, modules, and every relationship between them. Point it at any GitHub URL.

0
Languages
recognized
0%
Refs resolved
without LLM
—
Required on
your machine
auth/service.py
Graph output
Public Beta

3 languages, fully supported

Full node extraction, edge resolution, and Leiden community clustering — working today, hardening for production. More languages are in the pipeline.

Python
✓ Fully supported
Java
✓ Fully supported
JavaScript
✓ Fully supported

Coming soon

TypeScriptGoRust C++RubyC#+ more
Architecture

Three passes.
No wasted tokens.

Most tools throw the entire codebase at an LLM. Meridian doesn't. A deterministic parser handles the obvious; a symbol index resolves the easy refs; the agent handles only what's left.

Pass 01
Tree-sitter
Deterministic grammar parsing. Extracts every function, class, module, and explicit edge. No AI involved. Zero cost.
0
Languages recognized
Pass 02
Symbol Reducer
Builds a project-wide symbol index. Routes ambiguous refs to a language-specific resolver. Resolves ~88% without LLM.
0%
Resolved without LLM
Pass 03
Agent Reasoning
Surgical. Uses grep/glob/read to resolve only what the symbol index couldn't. Never reads a whole file. Only fires when needed.
0%
Reaches the agent
Architecture · Differential Engine

Patch the graph.
Don't rebuild it.

Most tools re-parse the entire repository on every push. Meridian re-parses only the files that changed, splices the delta into the stored tree, and re-clusters in place — the same graph, updated in seconds.

Other tools · every push
O(whole repo)
Re-clone, re-parse every file, rebuild the graph from scratch. Minutes — and the cost scales with repo size, not with what you actually changed.
Meridian · every push
O(changed files)
Diff previous_sha..HEAD, re-parse only the delta, mutate the stored tree in place. Seconds — the cost scales with your commit, not the codebase.
git push → auth/service.py auth/tokens.py graph_engine/builder.py api/deps.py + 1,723 unchanged · skipped
1Detect

git pull → diff previous_sha..HEAD. No-op short-circuit if HEAD didn't move.

2Re-parse the delta

Only added / modified / renamed files hit the parser (parse_files) — never the whole tree.

3Mutate in place

Drop stale nodes & edges, splice in the delta. The tree_id is preserved across syncs.

4Resolve only what moved

The agent re-resolves just the delta's ambiguous refs. Carry-over references are left untouched.

5Re-cluster & snapshot

Rebuild the graph, re-run Leiden, append an immutable graph_history version.

Same graph_id, same tree_id — mutated, never replaced. One POST /repos/sync endpoint picks FULL vs PATCH for you; every successful sync appends a versioned snapshot to graph_history.

Your codebase, rendered live

This is Meridian's own graph. Hover a node to trace its real connections · drag to pull it free · gold = god nodes · dim = orphans

API Gateway Hybrid Parser Orchestrator Graph Engine QnA Agent Ingestion God node
—
Nodes
—
Edges
—
Communities
Agent Relief

Your AI agent, finally at full strength

Without the graph, coding agents waste their entire context reading random files. Meridian generates a skill file baked from the graph — your agent knows everything before it reads a single line of code.

Agent without Meridian skill
Context exhausted
Reading auth/service.py (340 lines)…
Reading auth/tokens.py (218 lines)…
Reading api/deps.py (127 lines)…
Reading db/entities/users.py (89 lines)…
Context window12%
Agent with Meridian skill file
Graph loaded · Ready
meridian-graph.md
.claude/commands/meridian-graph.md
Skill file loaded · 142 nodes · 6 communities · 289 edges
Context window8% used
The validate_token function in auth/tokens.py:42 is called by 3 nodes: AuthService._verify, api/deps.py::get_current_user_id, and orchestrator/qna_chat.py:88. All are in community 2 (auth cluster). Safe to refactor — no cross-community callers.
Answer grounded in the graph · 0 files read · 8% context used
Benchmarks

The difference, measured

Same repo, same question — with and without Meridian's graph. Each figure is derived from Meridian's three-pass architecture and representative mixed-language repositories.

0
Fewer references sent to an LLM
vs a naive whole-repo parse
0
Less agent context burned
to answer a structural question
0
From question to cited answer
on the live graph
Trace a call chain — "who calls validate_token?"~60× faster
Without
~2 min · 29 files
With
~2 s · cited
References handed to an LLM while building the map~98% fewer
Without
100% → LLM
With
~2% → agent
Agent context consumed to answer a structural question~12× less
Without
~97% · exhausted
With
~8% used
Files an agent must read before it can answer12+ → 0
Without
12+ files
With
0 files
Re-sync after a commitincremental, not full
Without
full rebuild
With
Δ files · ~sec
Onboard a new engineer to the module boundariesdays → minutes
Without
~2 weeks
With
share a link

Derived from Meridian's design — ~88% of ambiguous references resolve deterministically (tree-sitter + symbol index), ~10% via unique cross-file match, only ~2% reach the agent. Illustrative of the architecture on representative repos, not an independently audited benchmark.

QnA Playground

Ask your codebase anything

Multi-turn WebSocket chat, grounded in the live graph. Every answer cites specific nodes and files — not hallucinated references.

Streaming responses — answers appear word by word
Node citations — every claim links to a real file:line
Community awareness — understands cluster relationships
Multi-turn memory — history stays in context across the session
M
Meridian Playground
Graph-grounded QnA
0%
Refs resolved without any LLM call
0
Programming languages recognized by tree-sitter
0
Parsing pipeline stages, no wasted tokens
—
Local install required — just a GitHub URL
Skill Export

Bring the graph to your AI tool

One click generates a context file baked from the live graph. Drop it into your IDE — your AI assistant immediately understands your entire codebase structure.

Claude Code
.claude/commands/{repo}.md
Slash command with full graph context. Works with Claude Sonnet and Opus in any project.
Cursor
.cursor/rules/{repo}-context.mdc
MDC rule file with frontmatter. Cursor picks it up automatically on project open.
GitHub Copilot
.github/copilot-instructions.md
Always-on instructions. Copilot reads this on every chat turn in your IDE automatically.
Windsurf
.windsurfrules
Global rules file. Windsurf injects this into every Cascade session automatically.

Your codebase
is waiting.

No hosted service to sign up for — Meridian is self-hosted and bring-your-own-key. Run it with Docker, drop in your own Anthropic API key, and point it at any GitHub repo.

# Self-hosted. Bring your own key.
cp .env.example .env # add your ANTHROPIC_API_KEY
docker compose up --build -d
→ Meridian running at http://localhost:8000
Get started on GitHub See supported languages