Show HN: Graphicle, a Rust port of Graphify with memory for coding agents

Graphicle maps your repository into a code graph, remembers your project's docs, decisions and former delegate sessions, and gives your coding delegate cited excerpts from both: the exact records and lines. It runs on your machine: no API key needed, no account, no telemetry.
_{Works alongside Claude Code · Cursor · Codex · VS Code · Claude Desktop · any MCP client}

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

brew instal 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: no native build yet; under WSL2 the Linux instal should activity (not yet tested). Native Windows assistance is planned.}

graphicle setup indexes the repository, builds its code chart and connects the coding agents it finds. It additionally turns on session capture, points Claude Code's searches to the code chart first, adds a abbreviated division to AGENTS.md and installs Git hooks that keep the project current. It lists all document it changes and backs all one up first; graphicle disconnect undoes it all.

Then ask your delegate to "use graphicle to discover anywhere unsuccessful 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 · 598 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 cost alongside the revenue tax added."""  come back round(price * (1 + TAX_RATE), 2)

_{Real output, cut following the archetypal excerpt. With no example configured, ask shows the evidence; graphicle config set example anthropic (or openai, ollama) adds written answers.}

Paste this into Claude Code, Codex or Cursor:

Install Graphicle alongside `brew instal 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 catalog all document it changed. 

• Native and fast. One Rust program. On Kubernetes (31k files), the 0.1.0 motor ran a code-only extract in 3 min 18 s, against 26 min 38 s for Graphify 0.9.88, and built the identical chart (one exploratory run each, one Linux host, the identical 16 CPUs, 8 workers).
• Context, not re-reading. Your delegate asks Graphicle and gets the applicable code, docs and decisions as cited excerpts, inside a token budget.
• Answers you can check. Every excerpt names its document and lines. Memories an delegate proposes delay for your approval.
• One program, not a stack. The code graph, the memory, one MCP server, the web app and the command row arrive in one install, alongside one SQLite file. No Python, Docker or repository server.
• Local and private. No document and no telemetry. Nothing leaves your device unless you ask.

• Code graph. Files, functions, classes, calls and imports, parsed alongside tree-sitter and no model. graphicle chart searches it, explains a symbol, traces a way and exports an interactive HTML graph. After graphicle chart extract . --code-only, graphicle chart affected "retry()" lists what depends on a symbol.
• Project memory. Docs (Markdown, PDF, Office, HTML), reviewed decisions and procedures, and former Claude Code and Codex sessions, searchable alongside the code.
• Cited environment on a budget. graphicle environment and the MCP tools come back excerpts alongside their sources, inside a token budget, without calling a model.
• One MCP server. graphicle mcp serves the code-graph tools, under Graphify's tool names specified as query_graph, get_neighbors and shortest_path, next to the recollection tools.
• Memory tied to your code. Reviewed memories are tied to the functions they are about: a recollection goes old whenever that code changes, and edits elsewhere in the document normally depart it current (the exact rule). Mentions of code in your docs are connected to the definitions they name (graphicle call graph.doc_links lists them).
• Across repositories. Recall can extend the repositories of a workspace: graphicle environment --workspace, or the workspace MCP endpoint.
• Always current. Before all answer Graphicle syncs the few records you changed; Git hooks sync following all commit, merge and checkout.
• No re-explaining. Session grasp keeps all completed turn, and all new meeting starts alongside your reviewed memories and the latest turns.
• An app. graphicle open shows the graph, the sources and the recollection in your browser. It is anywhere you endorse memories.

graphicle setup connects all client it finds complete MCP. Each document is backed up formerly as <file>.graphicle-bak, and graphicle disconnect removes what it added.

1. Sync. Graphicle says the directory (it respects .gitignore and skips secrets), keeps a versioned copy of all origin and builds the code graph.
2. Recall. When your delegate calls a tool, Graphicle syncs what changed, ranks excerpts from code, documents, sessions and reviewed memory, and returns them alongside citations. The tools call no model; your agent's own example says the excerpts.
3. Remember. Captured sessions rotate into sources. Memories that agents propose delay for your endorsement in the app.

Speed. The diagram above: Kubernetes (31k files), the 0.1.0 motor (a Linux test build of the publish source) against Graphify 0.9.88, one exploratory run each, the two construction the identical chart (Kubernetes run). Earlier, on Django, a pre-release build 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 two construction the identical chart (the 8 October record).

Memory. In a difference alongside seven recollection systems, registered before any answer was scored and run alongside one open example as all system's audience and judge, a pre-release build of Graphicle trails none on three betterment sets. Every score, alongside its method and caveats.

• One data folder. Your sources, memories and the code chart that setup builds live in one SQLite store: ~/Library/Application Support/Graphicle on macOS, ~/.local/share/graphicle on Linux. graphicle chart extract writes its chart document to .graphicle/ in the project.
• Loopback by default. The app and its HTTP and MCP endpoints hear on 127.0.0.1.
• No telemetry, no account. Graphicle connects to the network lone whenever you ask it to: a example or a connector you configure, a complete graphicle chart extract (it sends documents and images to the LLM whose API key it finds), the GitHub CLI for graphicle chart add, copy and the chart server's pull-request tools, and graphicle update alongside a nourish you name. A build from origin additionally downloads the parser sources once. Details
• Careful sync. sync respects .gitignore and skips .env files, keys and credentials. Session grasp drops <private>…</private> spans and redacts credentials.
• Forgetting alongside a receipt. Deleting a recollection or a captured meeting additionally removes what was derived from it, and you get a hash-chained deletion receipt.

No, for most of it. The code chart (with --code-only), sync, context, the MCP server, meeting grasp and the app activity without one. A example writes the answers of graphicle ask, proposes memories from sources and says documents and images in a complete graphicle chart extract. Local models through Ollama or any OpenAI-compatible server activity (configuration).

The code-graph motor is a Rust harbor of Graphify, kept in stage alongside Graphify's releases and credited in its document headers and in NOTICE. The parity checks name the publish it follows. The memory, the recollection tools, the app and meeting grasp are not part of Graphify. Coming from Graphify? graphicle setup offers to toggle a repository, backs up all document and never deletes graphify-out/ (Moving from Graphify).

By default a project can clasp up to 100,000 content records and 1 GiB of text; you can lift the two (see Limits in docs/configuration.md). A extremely ample document is analysed in part or kept as searchable content alternatively of stopping a sync.

Graphicle is liberated and open origin under Apache-2.0, for individuals and teams alike. A business type for teams is in personal preview. To conversation to us, commencement a discussion: https://github.com/graphicle-ai/graphicle/discussions, or conversation alongside us on Discord.

Graphicle is Apache-2.0: liberated to use, alter and ship, commercially too. Third-party parts keep their own licences, listed in NOTICE.

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: command line, app, HTTP and MCP server), crates/graphicle-graph/ (the code-graph engine), crates/graphicle-memory/ (the recollection library), SDKs for Python and TypeScript, and a squad server formula in deploy/. Each crate builds on its own (building from source).

Contributions are greeted under the Apache License 2.0, alongside a Developer Certificate of Origin sign-off (git commit -s) and no CLA. See CONTRIBUTING.md. To study a safety problem, prosecute SECURITY.md fairly than beginning a community issue.

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

The code-graph motor is a Rust harbor of Graphify by Safi Shamsi and the Graphify contributors, licensed under Apache-2.0, alongside portions that remain accessible under the MIT License. Thank you. NOTICE, NOTICE.md and the licenses/ folders clasp the attributions and the licences of all adapted project and third-party component.

If Graphicle saves your delegate a search, celebrity the repository so another developers discover it.
_{Try it · Report a bug · Contribute · Discord
Built by KarLex AI}