Give your AI a memory of your codebase.

Contextifly compiles your React, NestJS & Flutter code into a deterministic, full-stack knowledge graph, 100% on your machine. Your assistant queries it instead of re-reading 40 files every conversation.

$claude plugin install contextifly@contextifly
Watch it buildHow it works
graph · e-commerce app12 nodes · deterministic
AppCartPageProductCardCheckoutBtnuseCartGET /productsPOST /ordersProductCtlProductSvcOrderCtlOrderSvcOrderCheckoutButton.tsx:23api:POST /ordersorder.controller.ts:27order.service.ts:33order.entity.ts:9

routes, services, entities. Every edge cited to file:line.

Your AI re-discovers your project every conversation.

Every new chat, it pays again: in time, tokens and wrong answers. Contextifly gives it a memory that persists and stays in sync with your code.

Without Contextifly“How does checkout work?”
  • Searches 40+ files from scratch
  • Re-reads 15-20 of them
  • Guesses the dependencies it can't see
  • Re-analyzes the same screenshots
~45s~60,000 tokensguesses
With Contextiflytrace_flow /cart → /orders
  • Asks the graph one question
  • Gets the traced flow + exact file paths
  • Reads only 2-3 files for detail
  • Cites file:line, no guessing
~2sa few hundred tokensverified

Live comparison

Same repo. Two engines. Watch them build.

Point both at the same e-commerce app. Both start from the AST, then split. The other tool clusters your code into topic communities + concepts. Contextifly keeps compiling: it links the front-end call → API route → service → entity into one full-stack trace, with the file:line to prove it.

Other graph tool

e.g. Graphify-style · Tree-sitter + LLM

AppCartPageProductCardCheckoutBtnuseCartfetch /productsfetch /orders@Get /productsProductCtlProductSvc@Post /ordersOrderCtlOrderSvcOrder~?~?~?FRONTENDBACKEND
time
0.0s
tokens
0
topic communitiesno route identity
status: idle, press run
✓ done · full-stack linked

Contextifly compiler

you

TypeScript & AST parsers · on your machine

AppCartPageProductCardCheckoutBtnuseCartGET /productsPOST /ordersProductCtlProductSvcOrderCtlOrderSvcOrderCheckoutButton.tsx:23api:POST /ordersorder.controller.ts:27order.service.ts:33order.entity.ts:9
time
0.0s
tokens
0
✓ routes → services → entities✓ file:line provenance
status: idle, press run
ComponentStateEndpointServiceEntityfull-stack trace~? uncertain edge

Same repo, different graph. Contextifly linked the whole stack (front-end call → API route → service → entity) into one exact, file:line-cited trace. The LLM route produced topic communities + concepts, but never built the route identities that join front to back, so the cross-layer links stay guesses (~?).

0%

fewer vision tokens per screenshot

measured
0%

less code-exploration per question

estimated
0ms

no-op incremental re-index

verified byte-identical
0

MCP tools the moment you install

+ 3 bundled skills

A compiler for software architecture.

Not a chatbot guessing at structure. Real parsers compile your code into a versioned graph, and the AI only queries it. Every edge carries provenance and a confidence.

1

Providers

Compile one slice (a framework, a spec, a config) into IR nodes & edges.

ts-morph · NestJS decorators · Dart scanner

2

Versioned IR

The stable node/edge schema everything else is written against.

one contract, cited provenance

3

Normalizer

Assigns framework-agnostic semantic roles on top of syntax.

entry-point · business-logic · data-model

4

Algorithms

Impact, traces, diffs, scoring, maps. Pure graph computation.

provider-agnostic, deterministic

5

AI

Explains, summarizes, plans. Always the last step, never the source of truth.

queries the graph, never guesses

Providers never know each other. A frontend fetch('/orders') and a NestJS @Post() both emit api:POST /orders and merge into one node.

trace_flow

One tap, traced front to back.

A frontend fetch('/orders') and a NestJS @Post() handler resolve to the same endpoint node, so a whole checkout journey becomes one path with file:line at every hop.

≈ 200-500 tokens · not 40 files read
1
CheckoutButton
components/CheckoutButton.tsx:23
user taps “Place order”
2
POST /orders
fetch('/orders', { method: 'POST' })
frontend call
3
OrderControllermerged node
@Post() order.controller.ts:27
same endpoint node, merged
4
OrderService
injected · order.service.ts:33
business logic
5
Order
order.entity.ts:9
data model

Think in features, not files.

The moment the plugin is installed, your assistant can trace flows, measure blast radius, and simulate refactors. Every answer backed by the graph.

trace_flow

Full-stack traces

A checkout button → POST /orders → OrderController → OrderService → entity, in one path. Frontend fetch and backend handler merge into the same node.

get_impact

Blast-radius analysis

“What breaks if I change ProductCard?” Affected components, routes, contexts and APIs, with a Low / Med / High regression score.

what_if

Digital-twin simulation

Simulate remove / split / lazy-load before you touch a line of code. See what breaks and what stays safe, then decide.

get_project_map

Instant project map

Every route with its component tree and API calls, plus a Mermaid navigation diagram. A 40-file crawl becomes one query.

analyze_project

Architecture score

0-100 health: circular imports, dead code, unused routes, oversized components, and copy-pasted-then-renamed duplicates caught by JSX-shape fingerprint.

get_feature

Feature-level answers

“Explain Authentication”: its routes, components, state, APIs and entry points in one answer. Think in features, not files.

…plus analyze_screenshot, explain_visually, graph_diff, graph_timeline, match_screenshot and more.

A compiler you can trust, not a model you hope is right.

Other graph tools are clever, but they map calls and let a model infer the semantics. Contextifly is a deterministic compiler that links your whole stack and cites every edge.

How to read this: ✓ the tool does this well · ✗ a limitation on that row, not an overall verdict. Each tool wins different rows.

Capability
Contextifly
Other graph tools
How the code graph is built
Compiler (TS / AST parsers)
Tree-sitter AST + LLM extraction
Inputs it reads
Source code only: TS/React/Nest/Flutter
Code + docs, PDFs, images, diagrams
What the graph models
App wiring: routes, DI, entities
Topic communities + concepts
Endpoints & routing
Every route a node, fetch ↔ @Post() merge
Endpoints barely modeled, no route identity
Determinism
Byte-identical every run
Probabilistic, inferred edges vary
Your source code
Never leaves your machine
Semantic step sends content to a model
Evidence
Every edge structural, cites file:line
Some edges are model-inferred (guessed)
Re-index after an edit
~17ms incremental
Re-runs LLM extraction on changed files
Cost per query
A few hundred tokens
Thousands of tokens

The screenshot engine does use a model (optionally your own key). The code graph never does.

Install it. Then just ask.

No account, no API key. The 14 tools and 3 skills are available the moment a new session starts.

1Install the plugin
$claude plugin marketplace add Sam123336/Contextifly
$claude plugin install contextifly@contextifly
2Index your project

In a new session, say:

“index this project with contextifly”

Runs 100% locally · incremental after the first pass.

3Ask anything
›show me the project map
›what breaks if I change ProductCard?
›trace the flow from /cart to /orders
›analyze this screenshot with contextifly: ./home.png

Bonus: open .pixelcontextifly/graph.html in any browser for the interactive map.

Give your AI a memory today.

Open source, MIT. Works with Claude Code, Cursor & any MCP client.

View on GitHub