graphicle-ai/graphicle

Code graph and memory for your coding agents, in one Rust program.

Graphicle maps your repository into a code graph, remembers your project’s docs, decisions and past agent sessions, and gives your coding agent cited excerpts from both: the exact files and lines. It runs on your machine: no API key needed, no account, no telemetry. Works with Claude Code · Cursor · Codex · VS Code · Claude Desktop · any MCP client

Quick start · How it works · Benchmarks · Memory, compared · Docs · Coming from Graphify? · Discussions

Graphicle 0.1.11 against Graphify 0.9.100, labelled as in the picture; every measurement and its method are in docs/benchmarks.md. The code-graph engine is a Rust port of Graphify, credited below. Graphicle is not affiliated with Graphify Labs.

From a bug on the screen to a tested fix

Built during Meta’s Global AI Developer Hackathon (what was built, and when). 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. The picture is one live run on excalidraw issue #12053, built from source, and the fix passes 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.

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.

Start here

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 .graphicle-bak, and graphicle disconnect removes what it added.

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.

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).

Speed and memory of 0.1.11 against Graphify 0.9.100

Graphicle 0.1.11, built from its release source, against Graphify 0.9.100 on one cloud Linux machine (AMD EPYC 9V84), measured runs one at a time, alternating between the programs; the picture at the top and the two charts below show the results (method and every measurement).

• Updates after commits. After each of 30 recent code commits in prometheus, tokio and poetry, Graphicle’s update took a median 4.9, 2.0 and 1.6 s against 32.1, 11.9 and 11.7 s for Graphify: 5.8 to 7.2 times less time, with 4 CPUs per run. After an update, both programs’ graphs had the same number of differences from a fresh build at every step (none on tokio; on prometheus and poetry, mostly differences already present after an update with no change), and a graph left as it was differed from the next fresh build at 25 to 30 of the 30 steps. In a sample of 30 notes tied to code, every change to a noted function was flagged, with no false flag; a wider exploratory check found false flags (precision 0.68 to 0.86) and, on poetry, misses (recall 0.90) (details).
• Speed on 13 codebases. 3 operations each, 3 CPUs and 8 workers per run: Graphicle took 3.4 to 23.9 times less time in 34 of 39 measurements, including every first build (Kubernetes v1.37.1, one run each: 1 min 14 s against 29 min 18 s). Graphify 0.9.100 took less time in the other 5, all updates with nothing to change, where it now stops early: 0.28 to 0.97 times Graphicle’s time (react: 4.1 s against 14.5 s). The graphs differ slightly: node counts within 1.6%, edge counts within 1.1% (every measurement).
• Peak memory. Lower in the same 34 measurements, 0.30 to 0.96 times Graphify’s figure (Kubernetes extract: 3,059 against 3,541 MiB), and higher in the 5 updates where Graphify stops early (every measurement).

Finding the files a fix changes

Offline ranking, 100 SWE-bench Verified issues never used for tuning. Graphicle 0.1.8 put a file the fix changed in its first 5 files for 75 issues, against 61 for BM25 (SWE-bench style), a significant difference (McNemar exact p = 0.013); for the first file (43 vs 35) and the first 10 (81 vs 77) the differences are not significant. This measures ranking, not whether a coding agent fixes more issues; no agent test of this ranking has been run yet (method, task lists and limits).

Speed, memory and agent tests of 0.1.0 and 0.1.1

• Speed. The first panel of the four-panel chart above: on 13 codebases, 3 operations each, Graphicle’s 0.1.1 memory engine (a pre-release build) took 3.0 to 22.7 times less time than Graphify 0.9.91 in all 39 measurements, on the same machine with 3 CPUs and 8 workers each (the programs measured one after the other; median of 3 runs, 1 for Kubernetes and VS Code). The graphs differ slightly: node counts within 4.7%, edge counts within 2.0% (every measurement, with both graphs’ sizes). docs/benchmarks.md also has the earlier runs in which both programs built the same graph: the 0.1.0 engine against Graphify 0.9.88 on Kubernetes (Kubernetes run), and a pre-release build on Django, which ran a code-only extract in 7.5 s against 72.8 s for Graphify 0.9.77 (medians of five alternating runs, one shared Linux host, 8 workers; the 8 October record).
• Updates. After each of 30 commits on prometheus, tokio and poetry, Graphicle 0.1.0’s graph update took 6 to 8 times less time than Graphify 0.9.91’s (one Linux node, 4 CPUs per run), and both matched a fresh build apart from three kinds of keying difference that both programs share. In a 30-note sample, the 15 notes whose function changed were flagged and no other; a wider exploratory check found some false flags (details and limits).
• Peak memory. A pre-release build with 0.1.1’s changes to how the engine holds its data, later than the one timed above, used less peak memory than Graphify 0.9.91 in all 39 measurements (13 repositories; extract and two kinds of update), for example 2,092 against 2,767 MiB on the Kubernetes extract and 1,426 against 2,800 MiB on the next.js extract. A build of the merged 0.1.1 source stayed below in the 5 measurements rechecked; the second panel of the four-panel chart shows its Kubernetes extract, 2,148 against 2,767 MiB (the higher peak of 2 runs). One Linux 8×H100 node, GPUs not used; 8 workers; Graphicle’s peak RSS against Graphify’s peak PSS (every measurement).
• Finding code (Claude Code 2.1.287 on a Linux node, Opus 5.5, effort medium). Graphicle ties grep. On 100 SWE-bench Verified tasks, plain Claude Code, Graphicle 0.1.0’s default setup and Graphify 0.9.91 found every file the fix changed in 95, 95 and 94 of them; Graphicle used 16% and Graphify 29% more tokens than plain Claude Code, and the agent never called Graphicle’s tools. On 93 tasks from our own code, which the model has not seen, all three tied again, and a prototype card from Graphicle 0.1.0’s index (not shipped) used about 20% fewer tokens than Graphify.
• Answering questions (the same setup). On Graphify’s showcase corpus (30 questions), the 0.1.1 agent defaults (a pre-release build) found 99.2% of the facts, against 94.7% for plain Claude Code (a tie) and 87.8% for Graphify 0.9.91: more facts than Graphify, with fewer tokens. On 60 questions about our own project all three tied, and Graphify used about 48k more tokens per question than Graphicle (pre-release 0.1.1 plus a prototype context hook) (every agent test).
• Agent memory. In a comparison with seven memory systems, registered before any answer was scored and run with one open model as every system’s reader and judge, a pre-release build of Graphicle trails none on three development sets. Every score, with its method and caveats.

FAQ

Privacy and local first

• One data folder. Your sources, memories and the code graph that setup builds live in one SQLite store: ~/Library/Application Support/Graphicle on macOS, ~/.local/share/graphicle on Linux, %LOCALAPPDATA%\Graphicle on Windows. graphicle graph extract writes its graph file to .graphicle/ in the project.
• Loopback by default. The app and its HTTP and MCP endpoints listen on 127.0.0.1.
• No telemetry, no account. Graphicle connects to the network only in these cases: a model or a connector you configure, a full graphicle graph extract (it sends documents and images to the LLM whose API key it finds), the GitHub CLI for graphicle graph add, clone and the graph server’s pull-request tools, graphicle update with a feed you name, and a daily check for a new release. That check is on by default: a command you run in a terminal asks GitHub for the latest release, with no code or data, to tell you about a new one (GRAPHICLE_NO_UPDATE_NOTIFIER=1 turns it off). A build from source also downloads the parser sources once. Details
• Careful sync. sync respects .gitignore and skips .env files, keys and credentials. Session capture drops … spans and redacts credentials.
• Forgetting with a receipt. Deleting a memory or a captured session also removes what was derived from it, and you get a hash-chained deletion receipt.

More answers: FAQ · Troubleshooting · or run graphicle doctor.

Documentation

Quick start · Agents · Muse Code · MCP · Packs · Fix · Flow · Review · Wiki · Install · Configuration · Team server · Moving from Graphify · Benchmarks · FAQ · Changelog · Built at Meta’s hackathon

The code: crates/graphicle/ (the program: command line, app, HTTP and MCP server), crates/graphicle-graph/ (the code-graph engine), crates/graphicle-memory/ (the memory library), SDKs for Python and TypeScript, a team server recipe in deploy/, the benchmark kits in bench/, and the hosted demo in demo/. Each crate builds on its own (building from source).

Contributing

Contributions are welcome under the Apache License 2.0, with a Developer Certificate of Origin sign-off (git commit -s) and no CLA. See CONTRIBUTING.md. To report a security problem, follow SECURITY.md rather than opening a public issue.

License and credits

Graphicle is licensed under the Apache License 2.0. Copyright 2026 KarLex AI, Inc.

Code signing policy: release builds are not yet signed with a trusted certificate. The Windows programs are signed through SignPath with a test certificate, which Windows does not trust, or left unsigned when that signing fails; each release’s notes say which. Signing with the SignPath Foundation’s certificate is planned. The policy also lists every case in which Graphicle contacts the network.

The code-graph engine is a Rust port of Graphify by Safi Shamsi and the Graphify contributors, licensed under Apache-2.0, with portions that remain available under the MIT License. Thank you. NOTICE, NOTICE.md and the licenses/ folders hold the attributions and the licences of every adapted project and third-party component.

If Graphicle is useful to you, star the repository so other developers find it. Try it · Report a bug · Contribute · Discord Built by KarLex AI, Inc.