Graphicle MCP server

From a bug on the screen to a tested fix

With a key for the Meta Model API, graphicle see lets Muse Spark reproduce a bug in a web app with computer use, graphicle pixel finds the code that draws what the model points at, and graphicle fix patches it with a model such as Muse Wonder and runs your tests; when a round fails, the next one reads the failing lines and the files they name. In one live run on excalidraw issue #12053, built from source, the fix passed excalidraw's own regression test (see it, find it, fix it, check it).

Agent memory, compared

In a pre-release comparison with seven memory systems, Graphicle matched the accuracy of Hindsight 0.10.2 and beat that of Mem0 OSS 2.2.1 (the open-source library, not Mem0's hosted platform) on LoCoMo-10, and while ingesting made about 12 model calls per conversation, against about 160 for Hindsight and 332 for Mem0 (estimates per conversation; each system's total is exact). Labels: development sets; one open model (Qwen3.8-27B) as every system's reader, judge and model; a pre-release build of Graphicle.

System	LoCoMo-10 accuracy, points [95% CI]	Model calls per conversation, ingesting (estimate)	Prompt tokens per conversation, ingesting (estimate)
Graphicle (pre-release build)	87.7 [85.1, 90.2]	12	43K
Hindsight 0.10.2, observations on	87.3 [85.6, 89.1]	160	1.14M
Mem0 OSS 2.2.1	81.9 [79.6, 84.4]	332	3.18M
MemMachine 0.4.0	79.6 [77.3, 82.0]	23	140K
Honcho 3.2.2	79.2 [76.2, 82.2]	221	1.25M
Cognee 1.6.3	69.5 [67.3, 71.2]	206	291K
Graphiti (graphiti-core 0.30.2)	46.5 [44.0, 48.9]	1,363	4.52M
Mastra Observational Memory 1.36.0	38.6 [33.6, 43.1]	22, and 1 per question	356K

On the two other development sets, LME-84 and BEAM-100K, Graphicle trailed none of the systems it was compared with. Every score, with its method and caveats.

Earlier pre-release evaluations also ran three published protocols on GPT models. Under Mem0's own LoCoMo protocol (its prompts, GPT-5 as reader and judge), it scored 93.5%, against 91.6% in Mem0's published result files (paired difference +1.95 points [+0.55, +3.55]). On LongMemEval-S under the same protocol it scored 92.6%, against Mem0's 93.4%. Against Hindsight's published contexts, it tied with a GPT-5.4 reader (LoCoMo 90.4 vs 90.6, LongMemEval-S 94.6 vs 93.4) and with a GPT-4.1-mini reader on LoCoMo (86.4 vs 87.5), and trailed with GPT-4.1-mini on LongMemEval-S (85.8 vs 89.2). Every GPT run, with its labels.

Quick start

brew install graphicle-ai/tap/graphicle
cd your-repo
graphicle setup

No Homebrew? curl -fsSL https://github.com/graphicle-ai/graphicle/releases/latest/download/install.sh | sh · Release archives · Other ways to install Windows: a preview build for x86-64, not yet code-signed (Windows (preview)).

graphicle setup indexes the repository, builds its code graph and connects the coding agents it finds. It also turns on session capture, adds a two-line section to AGENTS.md (unless Claude Code is the only agent) and installs Git hooks that keep the project current. It lists every file it changes and backs each one up first; graphicle disconnect undoes it all.

Then ask your agent to "use graphicle to find where failed requests are retried", or ask from the terminal:

$ graphicle ask "where is tax added to prices?"
Evidence for "where is tax added to prices?"
4 excerpts · 606 of 3,000 tokens

[1] shop/pricing.py:1-7  price_with_tax()
    """Prices and tax."""
    TAX_RATE = 0.2


    def price_with_tax(price):
        """A price with the sales tax added."""
        return round(price * (1 + TAX_RATE), 2)

Real output, cut after the first excerpt. With no model configured, ask shows the evidence; graphicle config set model anthropic (or openai, ollama) adds written answers.

Paste this into Claude Code, Codex or Cursor:

Install Graphicle with `brew install graphicle-ai/tap/graphicle` (or, without Homebrew,
`curl -fsSL https://github.com/graphicle-ai/graphicle/releases/latest/download/install.sh | sh`),
then run `graphicle setup --yes` in this repository and list every file it changed.

Start here

You want to	Run
Give your coding agent the code graph and your project's memory	graphicle setup in the repository
Ask a question from the terminal	graphicle ask "how are failed requests retried?"
Browse the graph, the sources and the memory	graphicle open
See what a change to a symbol touches	graphicle graph extract . --code-only, then graphicle graph affected "retry()"
Check that everything works	graphicle doctor
Undo everything setup did	graphicle disconnect
Move from Graphify, or run a server for a team	Moving from Graphify · Team server

Why Graphicle

• Native and fast. One Rust program. On 13 codebases, Graphicle 0.1.11 took 3.4 to 23.9 times less time than Graphify 0.9.100 in 34 of 39 measurements (code-only extract, priming update and update with no change, on one machine with 3 CPUs and 8 workers each); in the other 5, updates with nothing to change, Graphify 0.9.100 now stops early and took less time. The graphs differ slightly: node counts within 1.6%, edge counts within 1.1% (speed table). Graphicle used less peak memory in the same 34 measurements, from 0.30 to 0.96 times Graphify's figure (memory table). After each of 30 recent code commits in three repositories, Graphicle 0.1.11's median update took 5.8 to 7.2 times less time than Graphify 0.9.100's, with 4 CPUs per run (updates after commits).
• Cited context, within a budget you set. Your agent asks Graphicle and gets the relevant code, docs and decisions as cited excerpts, within a token budget you set. In our tests it tied grep on finding code, and we do not claim it saves tokens (what we measured).
• Answers you can check. Every excerpt names its file and lines. Memories an agent proposes wait for your approval.
• One program, not a stack. The code graph, the memory, one MCP server, the web app and the command line come in one install, with one SQLite file. No Python, Docker or database server.
• Local and private. No account and no telemetry. Your code and data leave your machine only when you ask. The only automatic request is a daily check for a new release, which GRAPHICLE_NO_UPDATE_NOTIFIER=1 turns off.

What it does

• Code graph. Files, functions, classes, calls and imports, parsed with tree-sitter and no model. graphicle graph searches it, explains a symbol, traces a path and exports an interactive HTML graph. After graphicle graph extract . --code-only, graphicle graph affected "retry()" lists what depends on a symbol.
• Project memory. Docs (Markdown, PDF, Office, HTML), reviewed decisions and procedures, and past Claude Code and Codex sessions, searchable alongside the code.
• Cited context on a budget. graphicle context and the MCP tools return excerpts with their sources, within a token budget, without calling a model.
• Packs for long-context models. graphicle pack fills a token budget, up to 2,000,000 tokens, with the code a question needs: architecture, focus code with line numbers, call paths, tests and a manifest. graphicle ask --pack and graphicle plan send one to a model such as Muse Spark (packs). In the cache layout the repository part of a pack is the same for every question about a commit, so a provider's prompt cache can bill follow-up questions at its cached price. graphicle fix makes a change for an issue on a new branch and runs your tests on it (fix).
• One MCP server. graphicle mcp serves the code-graph tools, under Graphify's tool names such as query_graph, get_neighbors and shortest_path, next to the memory tools. With --pull-requests it also serves the pull-request tools list_prs, get_pr_impact and triage_prs, which use the GitHub CLI (MCP).
• Memory tied to your code. Reviewed memories are tied to the functions they are about: a memory goes stale when that code changes, and edits elsewhere in the file usually leave it current (the exact rule). Mentions of code in your docs are linked to the definitions they name (graphicle call graph.doc_links lists them).
• Reviews of a change. graphicle review reviews what a branch adds with the code around it, the callers, callees and tests of what it changes, and keeps only comments on changed lines whose citations hold. A GitHub Action posts the review on pull requests (review).
• A project wiki a model keeps. graphicle wiki build writes one cited article per area of the code and an index, wiki update rewrites only what changed, and wiki check lists stale doc mentions, stale memories and broken citations, then proposes corrections for your approval; every model call is opt-in and capped (wiki).
• From the screen to the code. graphicle see lets a model reproduce a bug in a web app with computer use on the Meta Model API, graphicle pixel finds the code that draws what it points at, and graphicle fix patches it and runs your tests (see it, find it, fix it, check it).
• Across repositories. Recall can span the repositories of a workspace: graphicle context --workspace, or the workspace MCP endpoint.
• Always current. Before each answer Graphicle syncs the few files you changed; Git hooks sync after each commit, merge and checkout.
• Sessions carry over. Session capture keeps each finished turn, and once you have reviewed memories, each new session starts with them and the latest turns.
• An app. graphicle open shows the graph, the sources and the memory in your browser. It is where you approve memories.

Works with your agents

graphicle setup connects every client it finds over MCP. Each file is backed up once as <file>.graphicle-bak, and graphicle disconnect removes what it added.

Client	Where setup connects it	Session capture
Claude Code	.mcp.json in the repository	hooks in .claude/settings.local.json
Codex	~/.codex/config.toml	hooks in ~/.codex/hooks.json (Codex asks you to trust them)
Cursor	~/.cursor/mcp.json
VS Code	.vscode/mcp.json in the repository
Claude Desktop	claude_desktop_config.json in Claude's settings folder
Muse Code	~/.config/muse/settings.json (Muse Code)	hooks in the plugin, a preview: graphicle connect muse --hooks
Any other MCP client	a short JSON entry (MCP)

How it works

1. Sync. Graphicle reads the folder (it respects .gitignore and skips secrets), keeps a versioned copy of each source and builds the code graph.
2. Recall. When your agent calls a tool, Graphicle syncs what changed, ranks excerpts from code, documents, sessions and reviewed memory, and returns them with citations. The tools call no model; your agent's own model reads the excerpts.
3. Remember. Captured sessions become sources. Memories that agents propose wait for your approval in the app.

Graphicle, or a code-graph tool plus a memory server

The left column is a code-graph tool, such as Graphify's open-source engine, plus a separate memory server. It is not a comparison with Graphify Cloud, a hosted service that includes memory.

	A code-graph tool + a memory server	Graphicle
Install	Two tools, often on different runtimes, and often a database server	One install
Connect your agents	Configure each tool in each agent	graphicle setup connects the agents it finds; graphicle disconnect undoes it
MCP servers in your agent	Two, configured separately	One, with the graph and the memory tools
Storage	Graph files plus the memory server's database	One SQLite file in one data folder
Code structure: calls, imports, impact	The graph tool	graphicle graph
Docs, decisions, past sessions	The memory server	Built in
Citations and review	Varies	A file and its lines on every excerpt; agent memories wait for approval

Benchmarks

Every figure is labelled, and docs/benchmarks.md has the full tables, methods and limits. In the agent tests, a difference counts only when its 95% interval excludes 0; otherwise it is a tie. Long sessions and memory built up across coding sessions are not tested yet.

• Time per question (0.1.8, the chart above). On kubernetes at ca8a2a9e4 (a shallow clone, 30,315 files), over the 22 questions of issue #8, the median graphicle context call took 1.34 s with 0.1.8 against 2.99 s with 0.1.7 on 16 cores of our Linux server, 1.38 s against 3.89 s on 4 cores, and 1.90 s against 4.55 s on 4 cores with the file cache dropped before each call; 8 lookups took 0.96 s against 2.52 s on 16 cores. Each call was a new process, as the prompt hook runs it. On the same store, both releases gave the same packet for every question, and the peak memory of a call fell from 3.5 GB to 0.6 GB (method and rounds).

Update with nothing to change (0.1.13)

graphicle-graph update stops early when nothing changed since a full update that changed nothing, and keeps the graph as it is (how it decides).