Graphicle 0.1.0: A Rust Port of Graphify That Adds Code Graph and Memory for Coding Agents
Graphicle is a single Rust program that builds a code graph of a repository and stores project memory — docs, decisions and past agent sessions — then serves cited excerpts from both to coding agents over MCP. It is a Rust port of the Graphify code-graph engine with a memory layer, app and session capture added on top, licensed Apache-2.0 and published by KarLex AI, Inc.
The project was posted to Hacker News as a Show HN, where it reached 32 points and 9 comments. The discussion was thin: three of the nine comments were flagged, and the remaining substantive comments questioned whether memory systems of this kind beat a plain agent harness with ripgrep.
What Graphicle does
Graphicle combines two capabilities that are usually separate tools: a code graph and a memory store. The code graph covers files, functions, classes, calls and imports, parsed with tree-sitter and no model. The memory store covers Markdown, PDF, Office and HTML documents, reviewed decisions and procedures, and past Claude Code and Codex sessions.
Both are searchable together. graphicle context and the MCP tools return excerpts with their sources inside a token budget, without calling a model. Every excerpt names its file and line range.
A worked example from the README, asking graphicle ask "where is tax added to prices?", returns four cited excerpts totalling 598 of 3,000 tokens. The first is shop/pricing.py:1-7, the price_with_tax() function.
Install and setup
The install path is Homebrew or a shell script:
brew install graphicle-ai/tap/graphicle
cd your-repo
graphicle setup
Without Homebrew, the README offers curl -fsSL https://github.com/graphicle-ai/graphicle/releases/latest/download/install.sh | sh. There is no native Windows build yet; the README states the Linux install should work under WSL2 but has not been tested there, and native Windows support is planned.
graphicle setup indexes the repository, builds the code graph, connects the coding agents it finds, turns on session capture, points Claude Code's searches to the code graph first, adds a short section to AGENTS.md, and installs Git hooks that keep the project current. It lists every file it changes and backs each one up first as <file>.graphicle-bak. graphicle disconnect undoes everything setup did.
Other commands documented in the README include graphicle ask for terminal questions, graphicle open for a browser view of the graph, sources and memory, graphicle doctor for health checks, graphicle graph extract . --code-only followed by graphicle graph affected "retry()" to list what depends on a symbol, and graphicle call graph.doc_links to list links between code mentions in docs and the definitions they name.
Benchmarks: speed against Graphify
On Kubernetes with roughly 31,000 files, the Graphicle 0.1.0 engine ran a code-only extract in 3 minutes 18 seconds, against 26 minutes 38 seconds for Graphify 0.9.88. Both built the same graph: 256,329 nodes and 1,400,392 edges. The README describes this as one exploratory run each, on one Linux host with the same 16 CPUs and 8 workers, and notes the 0.1.0 engine was a Linux test build of the release source.
An earlier comparison on Django measured a pre-release build of Graphicle at 7.5 seconds for a code-only extract against 72.8 seconds for Graphify 0.9.77. Those figures are medians of five alternating runs on one shared Linux host with 8 workers, and both tools built the same graph.
Benchmarks: memory against seven memory systems
The README reports a comparison against seven memory systems, registered before any answer was scored and run with one open model acting as every system's reader and judge. A pre-release build of Graphicle "trails none on three development sets" in that comparison. The README links to the full scores along with their method and caveats.
Memory anchored to code symbols
The distinguishing design choice in Graphicle is that reviewed memories are tied to the functions they are about. A memory goes stale when that code changes, while edits elsewhere in the same file usually leave it current. The README links to the exact rule in the crate documentation.
Hacker News commenter dmos62 singled this out as the most important part of the project, arguing that it solves a long-standing problem with memory systems:
The memory invalidation based on tying memories to pieces of code (e.g. functions) is the big thing here, I think, though I see why it wouldn't be front and center. I've always found memory systems icky, because it's difficult to tell whether a memory is still valid. Also, discoverability is always a concern (when is a memory relevant). This being both a code-graph and a memory system (seemingly unrelated things), actually addresses this in a novel way.
Memories that agents propose do not take effect automatically. They wait for approval in the app, which is where graphicle open sends you.
Architecture: one program, one SQLite file
Graphicle ships the code graph, the memory, one MCP server, the web app and the command line in one install, backed by one SQLite file. The README contrasts this with the common alternative of a code-graph tool plus a memory server, which typically means two tools on different runtimes, two MCP servers configured separately in each agent, and separate storage.
The MCP server is started with graphicle mcp and serves the code-graph tools under Graphify's tool names, including query_graph, get_neighbors and shortest_path, alongside the memory tools. Recall can span multiple repositories in a workspace via graphicle context --workspace or a workspace MCP endpoint.
The source is split into three crates: crates/graphicle/ for the program (command line, app, HTTP and MCP server), crates/graphicle-graph/ for the code-graph engine, and crates/graphicle-memory/ for the memory library. Python and TypeScript SDKs are included, along with a team server recipe in deploy/. Each crate builds on its own.
Client support
graphicle setup connects every client it finds over MCP. Per the README, the connection points are:
| 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 |
— |
| Any other MCP client | a short JSON entry | — |
Privacy and local-first behaviour
Graphicle requires no account and sends no telemetry. Sources, memories and the code graph live in one SQLite store at ~/Library/Application Support/Graphicle on macOS and ~/.local/share/graphicle on Linux; graphicle graph extract writes its graph file to .graphicle/ in the project. The app and its HTTP and MCP endpoints listen on 127.0.0.1 by default.
The README lists the cases where Graphicle does reach the network: a model or connector you configure, a full graphicle graph extract (which 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, and graphicle update with a feed you name. A build from source also downloads the parser sources once.
Sync respects .gitignore and skips .env files, keys and credentials. Session capture drops <private>…</private> spans and redacts credentials. Deleting a memory or a captured session also removes what was derived from it, and produces a hash-chained deletion receipt.
What requires a model and what does not
No API key or model is needed for the code graph with --code-only, sync, context, the MCP server, session capture or the app. A model is required to write the answers of graphicle ask, to propose memories from sources, and to read documents and images during a full graphicle graph extract.
Models are configured with graphicle config set model anthropic, openai or ollama. Local models through Ollama or any OpenAI-compatible server are supported. With no model configured, graphicle ask still shows the retrieved evidence rather than a written answer.
Limits and licensing
By default a project can hold up to 100,000 text files and 1 GiB of text, and both limits can be raised. A very large file is analysed in part or kept as searchable text instead of stopping a sync.
Graphicle is Apache-2.0, free to use, change and ship commercially. The code-graph engine is a Rust port of Graphify by Safi Shamsi and the Graphify contributors, kept in step with Graphify's releases and credited in file headers and in the NOTICE file; parity checks name the release it follows. The memory, memory tools, app and session capture are not part of Graphify. Migrating from Graphify is supported: graphicle setup offers to switch a repository, backs up each file and never deletes graphify-out/.
Contributions are accepted under Apache-2.0 with a Developer Certificate of Origin sign-off (git commit -s) and no CLA. A commercial edition for teams is in private preview.
What the Hacker News discussion questioned
The most substantive counterpoint in the thread came from commenter theLiminator, who reported that memory systems underperformed a simpler baseline in their own testing:
Has anyone actually gotten good results out of this? For the evals I've run (albeit, not super scientific), these memory systems did worse than the raw harness given ripgrep.
Commenter pjm331 asked the methodological question behind that claim:
who out there is running evals of giving agents these kinds of tools and how are you doing it?
No one in the thread answered either question. Commenter blackspacx asked how the benchmarks hold up and whether the tool was written with AI assistance; that also went unanswered in the visible comments. The remaining comments, including one from the submitter account KarLexAI, were flagged.
The practical takeaway from the thread is that the project's own memory benchmark — seven systems, one open model as reader and judge, registered before scoring — is the only evaluation evidence presented so far, and that independent replication against a ripgrep-plus-harness baseline has not been demonstrated in public.