Your coding agent asks Graphicle instead of grepping. It gets the functions, callers and past decisions it needs, cited to the exact file and line, from a code graph that stays current after every commit.
Works with Claude Code · Codex · Cursor · VS Code · Claude Desktop · any MCP client. Local: no API key, no account, no telemetry.
Graphicle 0.1.17 against Graphify 0.9.108 on one machine (4 vCPUs, Intel x86), one run each, one program at a time. After ten updates, Graphicle's graph matched a fresh build of the same commit. Method and every measurement. The code-graph engine is a Rust port of Graphify, credited below; Graphicle is not affiliated with Graphify Labs.
brew install graphicle-ai/tap/graphicle
cd your-repo
graphicle setupNo Homebrew? curl -fsSL https://github.com/graphicle-ai/graphicle/releases/latest/download/install.sh | sh · Windows: a preview build (install)
graphicle setup builds the code graph, connects the coding agents it finds and keeps the graph current with Git hooks. 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. No model needed: ask shows the evidence, and graphicle config set model anthropic (or openai, ollama) adds written answers.
- Fast on real repositories. On Kubernetes, Graphicle 0.1.17 built the code graph in 3 min 20 s against 33 min 11 s for Graphify 0.9.108, updated it after a commit in 4 min 30 s against 27 min 54 s, and in 21 s against 8 min 48 s when nothing had changed (labels under the chart above).
- Memory tied to your code. Docs, decisions and past Claude Code and Codex sessions sit next to the graph. A memory is tied to the functions it is about and goes stale when that code changes.
- Answers you can check. Every excerpt names its file and lines, within a token budget you set. Memories an agent proposes wait for your approval.
- One program, not a stack. Code graph, memory, one MCP server, an app and the command line in one install, with one SQLite file. No Python, Docker or database server.
- The code graph. Files, functions, classes, calls and imports, parsed with tree-sitter and no model, under Graphify's tool names (
query_graph,get_neighbors,shortest_path, ...).graphicle graph affected "retry()"lists what a change touches. - Project memory. Markdown, PDF, Office and HTML docs, reviewed decisions and captured agent sessions, searched together with the code.
- Cited context on a budget.
graphicle contextand the MCP tools return excerpts with their sources, without calling a model. - Always current. Graphicle syncs the files you changed before each answer, and Git hooks update the graph after each commit, merge and checkout.
- An app.
graphicle openshows the graph, the sources and the memory in your browser, and is where you approve memories.
More: packs for long-context models · reviews of a branch · a project wiki · from a bug on the screen to a tested fix · several repositories in one connection
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 |
| Cursor | ~/.cursor/mcp.json |
|
| VS Code | .vscode/mcp.json in the repository |
|
| Claude Desktop | claude_desktop_config.json |
|
| Muse Code | ~/.config/muse/settings.json (Muse Code) |
preview: graphicle connect muse --hooks |
| Any other MCP client | a short JSON entry (MCP) |
In a pre-release comparison with seven memory systems (development sets; one open model, Qwen3.8-27B, as every system's reader, judge and model; a pre-release build of Graphicle), Graphicle matched Hindsight 0.10.2 and beat Mem0 OSS 2.2.1 (the open-source library, not Mem0's hosted platform) on LoCoMo-10, with far fewer model calls while ingesting.
| System | LoCoMo-10 accuracy [95% CI] | Model calls per conversation, ingesting |
|---|---|---|
| Graphicle (pre-release build) | 87.7 [85.1, 90.2] | 12 |
| Hindsight 0.10.2 | 87.3 [85.6, 89.1] | 160 |
| Mem0 OSS 2.2.1 | 81.9 [79.6, 84.4] | 332 |
All eight systems, the other two development sets and every caveat.
The code-graph engine is a Rust port of Graphify that follows its releases (currently Graphify 0.9.103) and keeps its MCP tool names. graphicle setup offers to switch a repository, backs up each file it changes and never deletes graphify-out/. Moving from Graphify.
What leaves my machine?
Nothing by default, apart from a daily check for a new release (GRAPHICLE_NO_UPDATE_NOTIFIER=1 turns it off). Graphicle reaches the network only for a model or connector you configure, a full graphicle graph extract (documents and images go to the LLM whose API key it finds), and the GitHub CLI for the commands that use it. Your sources, memories and graph live in one SQLite store in your user data folder; the app and its endpoints listen on 127.0.0.1. Sync respects .gitignore and skips .env files, keys and credentials. Details
Do I need an API key or a model?
No, for most of it. The code graph (with --code-only), sync, context, the MCP server, session capture and the app work without one. A model writes the answers of graphicle ask and proposes memories; local models through Ollama or any OpenAI-compatible server work (configuration).
Will it handle my large repository?
Kubernetes (25,899 code files) builds in minutes on 4 vCPUs (chart above). By default a project can hold up to 100,000 text files and 1 GiB of text; you can raise both (limits).
Is there a version for teams?
Graphicle is free and open source under Apache-2.0, for individuals and teams alike. A commercial edition for teams is in private preview. To talk to us, start a discussion or chat on Discord.
More answers: FAQ · Troubleshooting · or run graphicle doctor.
Quick start · Agents · MCP · Install · Configuration · Team server · Moving from Graphify · Benchmarks · FAQ · Changelog
The code: crates/graphicle/ (the program), crates/graphicle-graph/ (the code-graph engine), crates/graphicle-memory/ (the memory library), SDKs for Python and TypeScript.
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.
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.