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 build How it works

graph · e-commerce app12 nodes · deterministic

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

communities + concepts

time

0.0s

tokens

topic communitiesno route identity

status: idle, press run

✓ done · full-stack linked

Contextifly compiler

you

TypeScript & AST parsers · on your machine

wiring · deterministic

time

0.0s

tokens

✓ 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 (~?).

fewer vision tokens per screenshot

measured

less code-exploration per question

estimated

0ms

no-op incremental re-index

verified byte-identical

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.

Providers

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

ts-morph · NestJS decorators · Dart scanner

Versioned IR

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

one contract, cited provenance

Normalizer

Assigns framework-agnostic semantic roles on top of syntax.

entry-point · business-logic · data-model

Algorithms

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

provider-agnostic, deterministic

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

CheckoutButton

components/CheckoutButton.tsx:23

user taps “Place order”

POST /orders

fetch('/orders', { method: 'POST' })

frontend call

OrderControllermerged node

@Post() order.controller.ts:27

same endpoint node, merged

OrderService

injected · order.service.ts:33

business logic

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