Graphicle
Code graph and project memory for coding agents in one local Rust program, returning cited, exact file-and-line evidence.
- Source repo
- Graphicle-AI/graphicle
- Stars
- ★ 432
- Last updated
- 1d ago
- License
- Apache-2.0
- Primary language
- Rust
- FA score
- 92/100 · Excellent
At a glance
- How it runs
- Works with
- Universal · cross-platformCodex · Claude Code
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- A developer in a large unfamiliar repo who wants Claude Code to locate, with line-number citations, where failed requests are retried
- Not a fit if
- Teams needing a hosted shared server (the commercial team edition is private preview)
- Users who want agent memories saved without manual approval
- Environments requiring signed Windows builds (currently preview, unsigned)
- Source review
- 92/100 · Excellent
What does this agent do, and when should you use it?
Graphicle maps your repository into a code graph (tree-sitter parsing of files, functions, classes, calls and imports, with no model) and stores your project docs, reviewed decisions, and past Claude Code / Codex sessions as searchable memory. It exposes code-graph and memory tools through a single MCP server to Claude Code, Codex, Cursor, VS Code and other clients, returning excerpts cited to exact files and lines within a token budget you set. The whole product is one Rust binary with one local SQLite file — no Python, Docker, database server, account, or telemetry. Memories are anchored to code symbols, so they go stale when that code changes; agent-proposed memories wait for your approval in the app. Built by KarLex AI under Apache-2.0, its graph engine is a Rust port of Graphify.
After graphicle setup, it indexes the repository (respecting .gitignore, skipping .env files and secrets), builds the code graph, connects every coding agent it finds over MCP, enables session capture, appends two lines to AGENTS.md, and installs Git hooks (post-commit / post-merge / post-checkout) that keep data current; graphicle disconnect undoes it all. graphicle ask/context return excerpts cited to files and lines; graphicle graph extract . --code-only plus graphicle graph affected "retry()" analyzes a symbol's blast radius; graphicle pack fills a token budget up to 2,000,000 tokens with architecture, focus code, call paths, tests and a manifest; graphicle mcp serves query_graph, get_neighbors, shortest_path and, with --pull-requests, list_prs, get_pr_impact and triage_prs via the GitHub CLI. Other tools include graphicle review (branch-change review that keeps only comments whose citations hold), graphicle fix (patch an issue on a new branch and run your tests), graphicle see/pixel (locate code from the screen), and graphicle open (browser app).
- A developer in a large unfamiliar repo who wants Claude Code to locate, with line-number citations, where failed requests are retried
- A long-term maintainer who wants docs, decisions and past sessions reusable across sessions and kept fully local
- A maintainer assessing change impact with graph graph affected before refactoring a symbol
- A team wanting automated branch reviews that only keep comments whose citations hold, posted to PRs via a GitHub Action
- An agent user packing complete relevant code (call paths, tests) for long-context models to understand architecture or plan
- A developer reproducing a web bug from a screenshot, finding the code that draws it, and auto-patching with tests
How do you install or deploy this agent?
On macOS / Linux via Homebrew:
brew install graphicle-ai/tap/graphicleWithout Homebrew:
curl -fsSL https://github.com/graphicle-ai/graphicle/releases/latest/download/install.sh | shWindows has an x86-64 preview build (not yet code-signed). No API key, account, or model is needed for the code graph, context, the MCP server, session capture, or the app.
How do you use this agent?
Run the one-time setup in your repository:
cd your-repo
graphicle setupIt indexes the repo, connects detected agents and installs Git hooks. Then ask from the terminal:
graphicle ask "where is tax added to prices?"or tell your agent "use graphicle to find where failed requests are retried". Optional: graphicle config set model anthropic (or openai, ollama) for written answers; graphicle open to browse the graph and approve memories; graphicle disconnect to undo setup; graphicle doctor to check everything works.
What are this agent's strengths and limitations?
- One Rust program and one SQLite file — no Python, Docker, or database server; setup is clean and fully reversible with graphicle disconnect
- Retrieval returns file-and-line citations without calling a model; local-first with no telemetry, so code stays on your machine by default
- Memories are anchored to code symbols: they go stale when the referenced function changes, and unrelated edits usually leave them current
- Self-reported benchmarks: 1.34 s median context call on kubernetes (0.1.8 vs 2.99 s), peak memory down from 3.5 GB to 0.6 GB; matches or beats seven memory systems on LoCoMo-10
- Agent-proposed memories require manual approval, so long-term memory value depends on your review effort
- The Windows build is an unsigned preview, which strict compliance environments may reject
- The retrieval benchmark (Top 5: 75 vs BM25's 61 on SWE-bench) has not been validated end-to-end with an agent fixing issues, and the authors do not claim token savings
- The commercial team edition is in private preview; sharing across a team requires running your own team server
How does this agent compare with similar options?
Per its self-reported data: on 13 codebases, the 0.1.1 pre-release memory engine was 3.0–22.7× faster than Graphify 0.9.91 (Python) with lower peak memory (0.29–0.97×), with slightly different graphs (node counts within 4.7%, edge counts within 2.0%). Against the combination of a code-graph tool plus a separate memory server, Graphicle claims one install, one MCP server, one SQLite store, and unified citation and review. In a pre-registered comparison with seven memory systems (Hindsight, Mem0 OSS, MemMachine, Honcho, Cognee, Graphiti, Mastra), it scored 87.7 on LoCoMo-10 — none trailed (Hindsight 87.3 is a tie) — using ~12 model calls per ingesting conversation versus ~160 (Hindsight) and ~332 (Mem0). All figures are the project's own; methods and caveats are in docs/benchmarks.md.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Graphicle This agent | 92 · Excellent | CLIFree + model costs | ★ 432 | 1d ago | Rust | Codex · Claude Code |
| GraphMind Code Graph | 64 · Some gaps | Desktop appFreemium | ★ 216 | 14d ago | Rust | Claude Code · Claude.ai |
| mex Project Memory | 71 · Some gaps | CLIFree | ★ 1.8k | 2d ago | TypeScript | Codex · Claude Code |
| Graphify – Turn Any Codebase into a Queryable Knowledge Graph | 64 · Some gaps | CLIFree | ★ 138k | 2d ago | Python | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence shows strong least privilege and transparent writes: setup lists every file changed and backs each up as .graphicle-bak first; disconnect/uninstall fully reverses it; agent memories are drafts awaiting human approval; session capture strips credentials and <private> text before storing. Network behavior is exhaustively enumerated (only a daily, disableable GitHub update check). Deduction: the 'skips secrets' claim and capture sanitization are documentation assertions with no static evidence of completeness, so sensitive_data_handling gets 2.
Docs are highly self-consistent: quickstart, configuration, troubleshooting and FAQ cross-reference cleanly with matching versions (0.1.9), paths and settings; doctor plus explicit failure messages are thorough. Deduction: dependency availability rests on described brew/archives/source paths whose actual availability was not verified statically, so 2.
Audiences (Claude Code, Codex, Cursor, VS Code, any MCP client) and scenarios (individual, team server, Windows preview) are clearly covered; boundaries are explicit (100k files / 1 GiB limits, Windows preview exclusions, untested long-session memory); trigger precision is specified via detailed code_first/query_focus/identifier_arm rules; environment fit is concrete (glibc floor, arches, unsigned-binary SmartScreen guidance). Near full marks.
Information architecture is excellent: README entry table, quickstart, install, FAQ and troubleshooting each with clear scope and anchors. Deductions: CHANGELOG content is not present in the evidence (only referenced); maintenance responsiveness (issues/Discord/SECURITY.md) is asserted, not shown; tool naming reuses Graphify names with a compat rationale but dual naming adds cognitive cost — each scored 2.
Output usability is strong: every excerpt cites file and lines; token budgets, a spend log, and per-call/per-day cost caps are well designed. Deduction: marginal value is partly self-undercut — the README admits a tie with grep on finding code and does not claim token savings; the retrieval gains (Top5 75 vs 61) come from the authors' own harness, unverifiable statically, so 2.
Nearly every figure is labeled with method, date, machine, CI and limits; ties are separated from significant differences, and fact/inference separation is exemplary with anchors into benchmarks.md. Deduction: cross-source corroboration depends on the authors' own comparisons and paraphrases of published result files, with no independent third-party replication, so 2.
- Static review only, no execution: 'skips secrets', credential scrubbing in session capture, and install-script behavior are documentation claims, not independently verified.
- curl|sh installation and unsigned Windows preview binaries carry supply-chain and tampering risk; prefer Homebrew or download the archive and verify SHA-256 first.
- setup defaults to connecting every discovered client, enabling session capture and Git hooks — a broad default; narrow it with --clients/--no-capture/--no-hooks and review the .graphicle-bak backups.
- --allow-learning is enabled by default for memory proposals; disable it explicitly if agents should not draft memories.
- All benchmarks are author-run with no third-party replication; do not rely on them alone for adoption decisions.
- Publisher identity is unverified/unknown, and the core code lies outside the reviewed evidence set.