GraphMind Code Graph
Turn local codebases into queryable knowledge graphs that AI assistants can navigate and remember.
- Source repo
- aouicher/graphmind
- Stars
- ★ 218
- Last updated
- 1mo ago
- License
- MIT
- Primary language
- Rust
- FA score
- 55/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformClaude Code · Claude.aiOpenAI API (Partial support)
- Cost
- Free tier plus a paid hosted plan
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- A maintainer of a large repository checks
graphmind fn-impactorgraphmind diff-impactbefore changing a widely used function. - Not a fit if
- Windows users who require a desktop app and will not use a CLI
- Teams looking only for a hosted web service
- Projects written in languages outside the documented set of 30
- Website
- getgraphmind.com ↗ set on GitHub
- Maintenance
- Commits in the last 6 monthslast commit 2026-10-15latest release v0.3.7 (2026-10-15)
- Source review
- 55/100 · Major gaps
What does this agent do, and when should you use it?
GraphMind is a local-first code intelligence system whose Rust core uses tree-sitter to build function- and file-level knowledge graphs stored in SQLite and JSONL. It is delivered as a CLI, a macOS desktop application, and a stdio MCP server for Claude Code, Claude Desktop, Cursor, Windsurf, Cline, Zed, Continue, VS Code, and other MCP clients. Retrieval combines FTS5, optional semantic embeddings, and one-hop graph expansion, with Reciprocal Rank Fusion producing compact ranked symbol results. Beyond source structure, it maintains persistent records of decisions, patterns, conventions, bugs, and context, and it can link multiple registered repositories. The default configuration opens no ports, sends no telemetry, and makes no network calls; embeddings can run through local ONNX or optional OpenAI and Voyage AI services. Core functionality is MIT-licensed, while team graph and shared-memory synchronization are identified as Pro/Team features.
A user registers and indexes a repository with graphmind init. The Rust core parses supported files with tree-sitter, extracts symbols, call sites, and dependency edges, then writes the structural graph and FTS5 index to ~/.graphmind/graphs/<slug>/graph.db with an incremental build cache. When an embedding provider is configured, graphmind build also creates vectors in embeddings.db; graphmind search fuses full-text matches, cosine-similarity results, and neighboring graph nodes with RRF. CLI commands and MCP tools can inspect symbols and full functions, read files, map dependencies, traverse callers, estimate the impact of Git changes, detect cycles and dead code, and export Mermaid, DOT, JSON, or Obsidian output. Its memory layer records decisions, patterns, conventions, bugs, and contextual facts in project or global JSONL files, with automatic recall through Claude Code hooks or MCP instructions. Cross-project commands search all registered repositories, infer shared-symbol relationships, and report dependencies between projects.
- A maintainer of a large repository checks
graphmind fn-impactorgraphmind diff-impactbefore changing a widely used function. - A team using Claude Code or Cursor wants assistants to query symbols, call relationships, and architecture without repeatedly reading the whole repository.
- Engineers responsible for an API, frontend, and shared libraries search symbols across registered projects and trace inter-project dependencies.
- A developer onboarding to an unfamiliar codebase inspects connected files, hierarchical outlines, dependency cycles, and symbols with no incoming edges.
- Individuals or teams preserve architecture decisions, coding conventions, known bugs, and business context across separate AI sessions.
- An architect exports a repository or cross-project graph to Mermaid, Graphviz DOT, JSON, or an Obsidian vault.
Key setup facts
Pulled from the install and usage notes below. The project README has the current values.
- Install / run
curl -fsSL https://raw.githubusercontent.com/aouicher/graphmind/main/scripts/install.sh | bashbrew install aouicher/graphmind/graphmindbrew install --cask aouicher/graphmind/graphmind
- Config files
~/.local/bin/graphmind~/.graphmind/config.json- Install notes cover
- macOS · Linux
How do you install or deploy this agent?
On macOS, download GraphMind-macos-arm64.dmg or GraphMind-macos-x64.dmg from GitHub Releases. The desktop application installs the CLI and provides guided setup for MCP, hooks, the skill, and embeddings.
On macOS or Linux, use the installation script:
curl -fsSL https://raw.githubusercontent.com/aouicher/graphmind/main/scripts/install.sh | bashAlternatively, install the CLI with Homebrew:
brew install aouicher/graphmind/graphmindThe macOS desktop application is also available through Homebrew:
brew install --cask aouicher/graphmind/graphmindLinux x64 users can download the CLI directly:
curl -fsSL https://github.com/aouicher/graphmind/releases/latest/download/graphmind-cli-linux-x64 -o ~/.local/bin/graphmind
chmod +x ~/.local/bin/graphmindBuilding from source requires Rust and Cargo:
git clone https://github.com/aouicher/graphmind
cd graphmind
cargo build --release -p graphmind-cli
cp target/release/graphmind ~/.local/bin/Embeddings are disabled by default, so no API credential is required for the initial setup. OpenAI or Voyage AI keys must be added to ~/.graphmind/config.json only if those embedding modes are selected.
How do you use this agent?
Run the global setup once, then initialize each repository:
graphmind setup
cd ~/projects/myapp
graphmind initsetup configures the shell path, Claude Code hooks and skill, and MCP settings for Claude Desktop, Claude Code, OpenCode, and Cursor. init registers the current directory, installs Git hooks, builds the graph, and writes supported project-level MCP configuration. Both commands are documented as idempotent.
After indexing, query the project from the terminal:
graphmind search "authentication flow"
graphmind fn validate_token --include-content
graphmind deps src/services/auth.ts
graphmind diff-impact
graphmind dead-code --kind function
graphmind cycles
graphmind export -f mermaidPersistent project knowledge can be managed explicitly:
graphmind memory add "Authentication tokens are validated by AuthService"
graphmind memory search "authentication"
graphmind memory listTo enable embeddings without an API key, select the local provider:
{
"embedding": {
"mode": "local",
"model": "nomic-embed-text-v1.5"
}
}Then generate the index:
graphmind embed --runMCP clients launch the stdio server with:
graphmind mcpWhat are this agent's strengths and limitations?
- Structural graph traversal, FTS5, semantic vectors, and graph expansion are combined in one retrieval pipeline, with result provenance shown as FTS, semantic, or graph-derived.
- The default deployment is local, port-free, and telemetry-free; graphs, embeddings, and memories remain inspectable SQLite or JSONL files.
- Its operations extend beyond search to caller traversal, change-impact analysis, cycle detection, dead-code discovery, event listeners, and cross-project relationships.
- It works as a standalone CLI and as a stdio MCP server for several editors and assistants, with additional automatic context hooks for Claude Code.
- The parser covers 30 documented languages and supports incremental rebuilding, post-commit refreshes, and pre-push impact checks.
- Packaged desktop assets are documented only for macOS; Linux and Windows users are directed to the CLI.
- Semantic search is disabled on new installations and requires either a local ONNX model or OpenAI/Voyage AI credentials and their associated service dependencies.
- The Claude Code hooks can rewrite grep, find, and rg activity, so teams must evaluate their effect on existing search workflows and five-minute cache behavior.
- Team graph synchronization and shared-memory MCP tools are restricted to the named Pro/Team tiers.
- The repository reports major token savings, but provides no independent validation, retrieval-accuracy evaluation, or quality comparison with other code-graph products.
How does this agent compare with similar options?
Compared with passing raw grep -r output to a model, GraphMind first indexes symbols and dependencies, then returns compact results ranked through full-text search, semantic retrieval, and graph expansion. Its own benchmark on an approximately 100,000-line codebase reports fewer than 300 output tokens for GraphMind versus more than 1.5 million for raw grep output; this figure is reported by the project itself.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| GraphMind Code Graph This agent | 55 · Major gaps | Desktop appFreemium | ★ 218 | 1mo ago | Rust | Claude Code · Claude.ai |
| Gortex Code Intelligence | 73 · Some gaps | CLIFree | ★ 2.1k | today | Go | Codex · Claude Code · OpenAI API · Claude API |
| Ori Mnemos | 56 · Major gaps | CLIFree | ★ 337 | 1mo ago | TypeScript | Claude Code · OpenAI API · Claude API |
| mex Project Memory | 84 · Good | CLIFree | ★ 1.8k | 2d ago | TypeScript | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
The code and documentation describe a mainly local stdio MCP service using SQLite and JSONL, with network calls for optional OpenAI/Voyage embeddings and embeddings disabled by default; least privilege and data flows receive some coverage (2 each). setup/init can edit configuration, PATH, hooks, MCP entries, and indexes. The docs describe backups, preservation of user-edited content, and handling for some parse failures, but do not provide a general per-action confirmation flow (user confirmation 1) or concrete protections for stored memories and API keys (sensitive data 1). Dependency security receives only Cargo workspace and CI evidence; the sample shows no audit or vulnerability mitigation process (1). External effects and their scope are described in useful detail (2), and backups, idempotence, and uninstall commands offer partial recovery (2). The repository provides a security contact and copyright information, but publisher identity is unverified and maintenance attribution remains limited (source attribution 2).
The README says there are 25 MCP tools, while the architecture and CLAUDE.md say 27; the sample does not reconcile the counts and listed tools, lowering self-consistency (1). CI configuration shows multi-platform builds and several test suites, but availability safeguards for external model services, distribution channels, and parser dependencies are not established in the sample (dependency availability 1). The code turns parse errors into messages containing file context, and the README describes preserving files and reporting some configuration parse failures, which adequately supports ordinary failure reporting (2).
The README covers CLI, desktop, multiple editors and MCP clients, worktrees, and embedding modes, giving useful audience and scenario guidance (2). It documents boundaries such as unregistered directories, husky/core.hooksPath, external sessions, and local versus remote embeddings (2). The skill broadly requires GraphMind-first exploration and makes memory saving automatic, with limited trigger calibration or user control described (1). Installation spans macOS, Linux, and Windows paths, although desktop assets are listed only for macOS (2).
The README is organized around installation, setup, search, memory, and commands, with many examples; the sample is incomplete, so information architecture receives 2. Installation guidance is detailed, including configuration locations, platform differences, and manual setup (3). Command and MCP naming is generally understandable, but tool counts and some naming details differ between README and CLAUDE.md (1). Examples are plentiful and manual setup/scenario sections answer some common questions, though no complete FAQ is shown (2). Several platform and hook limitations are disclosed (2). The MIT license text matches Cargo metadata (3). Cargo.toml specifies a version and CI describes release steps, but the sample does not include a complete changelog (2). The security policy gives a reporting email and response targets, but publisher identity is unverified and no clear maintenance team or ongoing responsibility is established (1).
CLI, MCP, and memory queries expose structured symbol, dependency, impact, and search results, though the sample does not fully show output formats (2). Graph navigation, semantic search, cross-project links, and persistent memory offer clear potential value over raw text search; token savings and accuracy claims remain primarily project assertions (2). Users must install the CLI, register projects, and build graphs; some embedding modes require external APIs, and the sample does not independently quantify costs and benefits (1).
Architecture, installation, configuration, side effects, and benchmark claims are traceable to the README and some source/CI files, but the token benchmark and several capabilities lack concrete measurement evidence in the sample (2). A few claims can be corroborated across README, CLI source, Cargo metadata, or CI, but most product claims are concentrated in the README and the packet is limited (1). The README distinguishes some defaults and behaviors, but does not clearly mark the inferential boundary between benchmark/efficiency claims and implementation evidence (1).
- The README's MCP tool count differs from the architecture and CLAUDE.md; the review packet is also not the complete repository.
- Install and setup can modify user-level configuration, hooks, and project indexes; review the affected paths before running them.
- Embeddings can use external services and configured API keys; the sample does not detail key-storage protections.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
Fixed - Update checks call curl directly, not through rtk. rtk 1.0 renamed rtk proxy, which graphmind used for its update checks; once rtk drops the old name, those checks would have failed. They never needed rtk. The CLI and the MCP server now share one daily check, so a failed check isn't retried by every MCP server start, and graphmind update reads the release tag from GitHub's JSON. by @aouicher . Thanks @KennethWKZ for spotting the rename. Upgrading Nothing to do.View on GitHub ↗ -
Release notes excerpt
Fixed - A removed worktree no longer lingers. After git worktree remove, the next graphmind list or graphmind build --all (and the desktop app's project list and "build all") forgets the worktree and deletes its graph, so build --all no longer fails on its missing folder. Before, it stayed until another worktree of the repo was registered or graphmind clean --stale ran. Projects registered by hand are not affected. Upgrading Nothing to do. Worktrees removed before this version are forgotten by the first graphmind list or graphmind build --all.View on GitHub ↗ -
Release notes excerpt
Fixed - graphmind update downloads to a file of its own. The new binary is written next to the installed one, under a unique name created for this update, instead of a fixed name in the temp folder: two updates at once no longer corrupt each other, and on a shared machine no other user can put a file in its place. A downloaded binary that crashes now says why. - graphmind build --all says when a project fails. It still builds every project, then exits non-zero and names the projects whose build failed, so a script or hook can tell. …View on GitHub ↗
FAQ
Can it run in an offline environment?
Does it upload source code?
~/.graphmind/, and MCP communicates over stdio. Network use is introduced only when OpenAI or Voyage AI embeddings are explicitly configured, or when optional Pro/Team synchronization is enabled.Is Claude Code required?
/gm skill are specifically designed for Claude Code.Are memory writes controlled?
gm_memory_add requires explicit confirmation. Entries persist until they are deliberately deleted.Is the free functionality sufficient for an individual developer?
Is GraphMind Code Graph open source?
Is GraphMind Code Graph safe to use?
Is GraphMind Code Graph still maintained?
Who makes GraphMind Code Graph?
What is GraphMind Code Graph's official website?
Thanks — we use this to improve the page.