Graphmind
Local-first code knowledge graph with 25 MCP tools that give your AI assistant ranked symbols and persistent memory instead of raw grep dumps.
GraphMind is worth it if you run Claude Code, Cursor, or another MCP client over a large or multi-project codebase and you are tired of watching tokens vanish into grep output. The Free tier is genuinely usable — MIT-licensed, unlimited projects, 25 MCP tools, SQLite memory, local minilm embeddings, no account — so you can validate the 5,700x token-reduction claim on your own repo before paying anything. The catch is that Embeddings (€9/mo), Pro (€19/mo), and Team (€19/mo/seat) are all marked 'Coming soon', so remote Voyage AI embeddings and team sharing are not purchasable today. Against Sourcegraph Cody, GraphMind is narrower but returns ranked symbols with callers, callees, and blast
Verified 3d ago · liveness 74/100 · cite: rightaichoice.com/tools/graphmind
- Developers running Claude Code, Cursor, or another MCP-compatible assistant
- Teams maintaining large or multi-project codebases where grep returns too much noise
- Engineers reviewing PRs who need symbolic impact context
- Open-source-minded developers who want local-first, MIT-licensed tooling
- Non-developers who do not write code
- Developers whose AI assistant does not speak MCP
- Teams that need a paid team plan today — Team is labeled Coming soon
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip GraphMind if your AI assistant does not support MCP, since all 25 tools are delivered through an MCP server and there is no other way to query the graph.
Team is priced at €19/mo per seat with a 3-seat minimum, so the cheapest real Team commitment is €57/mo — there is no single-seat team option.
GraphMind's Free tier is unusually complete — MIT license, unlimited projects, all 25 MCP tools, local embeddings, no account — which undercuts most code-intelligence tools that paywall search from the start. Embeddings (€9/mo) and Pro (€19/mo) sit well below Sourcegraph Cody's enterprise-oriented pricing, but both are marked 'Coming soon', so today there is effectively one purchasable price point: €0. Team at €19/mo/seat with a 3-seat minimum (€57/mo floor) is aimed at engineering teams
In short
Graphmind — Local-first code knowledge graph with 25 MCP tools that give your AI assistant ranked symbols and persistent memory instead of raw grep dumps. Best for Developers running Claude Code, Cursor, or another MCP-compatible assistant, Teams maintaining large or multi-project codebases where grep returns too much noise, Engineers reviewing PRs who need symbolic impact context. Free to start; paid plans from €9/mo.
What's new in Graphmind
Checked 3 days agoAcross the latest 3 updates: 2 feature updates and 1 launch.
Desktop app for Mac and Windows configures MCP, hooks, and skill automatically on first launch
The desktop build removes terminal setup entirely: install the app, point it at a project folder, and the MCP server, Claude Code hooks, and skill configure themselves. The CLI path remains brew install aouicher/graphmind/graphmind.
Claude Code hooks rewrite grep/find/rg into graph-aware searches at PreToolUse
graphmind install hook-claude installs PreToolUse, SessionStart, UserPromptSubmit, and PostToolUse hooks that intercept grep/find/rg, pre-fetch graph context per prompt, and deduplicate identical searches within 5 minutes to zero tokens.
Cross-project dependency edges and CLAUDE.md sync ship in the index pipeline
gm_cross_links detects cross-project dependency edges automatically at index time, while graphmind sync keeps CLAUDE.md files current with symbol count, languages, and top files so Claude Code always has accurate project context.
What people actually say about Graphmind — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
5 mentions across 3 sources (Hacker News, Product Hunt, GitHub) · researched Jul 3, 2026.
Average across the 3 sources that answered — each source counts once, not each post.
- +Local-first: no code sent to external servers.
- +Massive token reduction—up to 5,700x fewer than raw search.
- +Persistent memory (SQLite) for cross-session AI recall.
- +Hybrid search: full-text, semantic, and graph ranking.
- +Dead code detection via zero-caller symbol analysis.
- −Very little community feedback to validate claims.
- −Multi-repo support questioned and not clearly answered.
- −Integration setup not documented for most AI assistants.
- −Desktop app only for Mac and Windows—no Linux GUI.
- −Free tier local embeddings only; remote embeddings cost.
- • Remote embedding API costs via Voyage AI not included in free tier.
Viability Score
How well maintained and how widely used is Graphmind? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Knowledge graph of codebase built with tree-sitter parsers and stored in DuckDB
- 25 MCP tools exposed to any MCP-compatible AI assistant
- Persistent memory store (SQLite) for architectural decisions and conventions
- Hybrid search combining full-text, semantic, and graph ranking (RRF across 3 sources)
- gm_fn symbol detail with full source, callers, and callees in one call
- gm_fn_impact transitive caller chain for blast-radius analysis before refactors
- gm_dead_code detection of zero-caller symbols across all projects
- gm_similar structural similarity detection for duplicated code
- gm_diff_impact git diff impact analysis for PR review
- gm_cross_links cross-project dependency edge detection at index time
- gm_cycles circular dependency cycle detection
- Local embeddings (minilm) for offline semantic search on the Free plan
- Remote embeddings via Voyage AI on paid plans (marked Coming soon)
- Desktop app for Mac and Windows with automatic MCP, hook, and skill configuration
- CLI installable via Homebrew with unlimited project indexing on the Free plan
About Graphmind
GraphMind turns your codebase into a knowledge graph that your AI coding assistant can query, navigate, and remember. It parses every file with tree-sitter, builds a symbol graph in DuckDB, and detects cross-project dependencies at index time. Instead of dumping millions of tokens of grep output into context, it returns ranked symbols with structural context — callers, callees, transitive impact chains. On the vendor's own 31K-symbol benchmark, queries like "payment processing" dropped from roughly 1,468,000 grep tokens to 257 GraphMind tokens (a 5,700x reduction), and GraphMind claims ~10M tokens saved across a typical 5-10 search session. It is available two ways: a desktop app for Mac and Windows with automatic MCP/hook/skill configuration, or a CLI installed via Homebrew (brew install aouicher/graphmind/graphmind) with graphmind setup for global config and graphmind init per project. The Free tier is MIT-licensed, runs entirely locally with minilm embeddings, allows unlimited projects, and requires no account. Paid tiers — Embeddings at €9/mo, Pro at €19/mo, and Team at €19/mo/seat — add remote semantic search, Voyage AI embeddings, a remote API and remote MCP server, shared team graphs, shared architectural memories, and gm_team_who_knows. All three paid tiers are labeled 'Coming soon' on the pricing page. It works with any MCP client, including Claude Desktop, Claude Code, Cursor, Windsurf, Cline, Zed, and Continue, and supports 30+ languages through tree-sitter parsers. This is built for developers and teams whose AI assistants currently burn context on raw code search.
Behind the Verdict
The core insight behind GraphMind is that raw code search is a terrible interface for a language model. Grep hands the model lines of text; GraphMind hands it symbols with structure — what a function is, who calls it, what it calls, how deep the blast radius goes. That is why the benchmark numbers hold up conceptually: on a 31K-symbol codebase, "payment processing" pulled ~1,468,000 grep tokens versus 257 GraphMind tokens, and "compliance check" went from ~1,007,000 to ~274. Results come back in under 300 tokens because the graph already knows the relationships, and RRF ranking over three sources (full-text, semantic, graph) means a search for "money transfer" can surface payment_service even without a name match. The second pillar is memory. gm_memory_add and gm_memory_read keep architectural decisions, conventions, and context notes in a local SQLite store, and after graphmind setup the Claude Code skill and hooks inject that context automatically before a session. You stop re-explaining "all DB writes go through Repository" every morning. Third is operational surface that most code-search tools simply do not have: gm_fn_impact gives the full transitive caller chain before a refactor, gm_dead_code finds zero-caller symbols across all projects, gm_similar catches structural duplication, gm_cycles flags circular dependencies, and gm_cross_links maps how separate projects depend on each other. The hooks layer is the underrated part — graphmind install hook-claude rewrites grep/find/rg calls into graph-aware searches at PreToolUse, pre-fetches context per prompt, and deduplicates identical searches within five minutes to zero tokens. Where GraphMind falls short: everything paid is still labeled 'Coming soon' on the pricing page, so remote semantic search via Voyage AI embeddings, the remote API, the remote MCP server, and the entire Team feature set (shared graph, shared memories, gm_team_who_knows, auto-sync, 3-seat minimum) are not purchasable right now. The free path means local minilm embeddings and local indexing, which is real work on a very large monorepo. And the whole product is gated behind MCP — if your assistant does not speak MCP, GraphMind's 25 tools are unreachable. As a free, open-source, local-first companion to Claude Code or Cursor on a big codebase, it is one of the more persuasive token-saving plays available; as a paid team platform, it is not finished shipping.
Researching Graphmind? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Graphmind actually fits — and what changes day-one when you adopt it.
Installs via Homebrew with brew install aouicher/graphmind/graphmind, runs graphmind setup to configure MCP, hooks, and the Claude Code skill, then graphmind index . to build the symbol graph, and finally asks Claude 'run gm_status to check GraphMind is connected.'
Outcome: Grep and find calls are rewritten into graph-aware searches, identical searches within 5 minutes are deduplicated to zero tokens, and ranked symbols come back in under 300 tokens instead of millions of tokens of raw lines.
Runs gm_diff_impact on the PR's git diff and gm_fn_impact on the touched payment symbols to pull the full transitive caller chain before approving.
Outcome: The blast radius is visible before merge, so callers in unrelated services surface early rather than in production, and gm_similar flags duplicated logic the refactor would have preserved.
Stores decisions with graphmind memory add "all DB writes go through Repository" --type convention and graphmind memory add "PaymentService is the billing entry point" --type decision, then asks the assistant why a service exists.
Outcome: The hooks and Claude Code skill inject stored context before each session, so gm_memory_read recalls the conventions automatically and the assistant stops proposing DB writes that bypass the repository layer.
Use Cases
- Ask your AI assistant for dead code, dependencies, or blast radius and get answers grounded in your actual architecture rather than guessed from grepped snippets
- Understand any symbol instantly with full source, callers, and callees in a single gm_fn call instead of browsing files
- Review a PR by running gm_diff_impact on the diff to see which symbols are affected and who calls them
- Catch circular dependency cycles with gm_cycles before they cause build failures or runtime surprises
- Find copy-pasted code with gm_similar and pay down duplication before it becomes debt
- Reduce AI context consumption by returning ranked symbols — the vendor benchmarks up to 5,700x fewer tokens than grep
- Persist architectural decisions with gm_memory_add so your assistant recalls conventions at the start of every session
- Map how separate services depend on each other with gm_cross_links detected automatically at index time
Models Under the Hood
as of 2026-09-30
Limitations
- The Embeddings (€9/mo), Pro (€19/mo), and Team (€19/mo/seat) tiers are all labeled 'Coming soon' on the pricing page, so remote semantic search, Voyage AI embeddings, the remote API, the remote MCP server, shared team graphs, shared architectural memories, gm_team_who_knows, and auto-sync are not available yet.
- The Free plan relies on local minilm embeddings for semantic search and runs the graph locally, so very large indexes are bounded by your machine's memory.
- GraphMind's 25 tools are exposed via MCP, so they only work with MCP-compatible clients — Claude Desktop, Claude Code, Cursor, Windsurf, Cline, Zed, Continue, and other MCP clients.
- Team requires a minimum of 3 seats when it ships.
- The vendor supports 30+ languages via tree-sitter parsers and ships a Mac/Windows desktop app plus a Homebrew CLI; Linux desktop is not listed among the app builds.
as of 2026-10-05
Verification history
We have re-verified Graphmind 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
Showing the 6 most recent of 9 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Graphmind tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free
€0/mo
Ideal for
Solo developers and open-source contributors who want graph-aware AI search locally with no account, no server, and unlimited projects.
What this tier adds
Free entry point: local graph, all 25 MCP tools, SQLite memory store, local minilm embeddings, MIT license.
Embeddings
€9/mo
Ideal for
Developers who have outgrown local minilm embeddings and want stronger cross-session semantic recall on the same machine.
What this tier adds
Adds remote semantic search and Voyage AI embeddings on top of everything in Free, plus email support. Marked Coming soon.
Pro
€19/mo
Ideal for
Developers who want GraphMind's tools from any machine without installing or indexing locally, including laptop-only or thin-client setups.
What this tier adds
Adds remote API and remote MCP server so no local installation is needed, on top of everything in Embeddings. Marked Coming soon.
Team
€19/mo/seat
Ideal for
Engineering teams of 3 or more that want a shared graph and shared architectural memory so the whole team sees the same decisions.
What this tier adds
Adds shared team graph, shared memories, gm_team_who_knows, auto-sync after indexing, and priority support; minimum 3 seats at €19/mo/seat. Marked Coming soon.
Where the pricing makes sense
The company stage and team size where Graphmind's pricing actually pencils out — and where peers do it cheaper.
GraphMind's Free tier is unusually complete — MIT license, unlimited projects, all 25 MCP tools, local embeddings, no account — which undercuts most code-intelligence tools that paywall search from the start. Embeddings (€9/mo) and Pro (€19/mo) sit well below Sourcegraph Cody's enterprise-oriented pricing, but both are marked 'Coming soon', so today there is effectively one purchasable price point: €0. Team at €19/mo/seat with a 3-seat minimum (€57/mo floor) is aimed at engineering teams
Setup time & first value
How long it actually takes to get something useful out of Graphmind — broken out by persona, not the marketing-page minute.
Desktop app: install the Mac or Windows build, point it at a project folder, and the app configures MCP, hooks, and the skill automatically on first launch — you are asking questions in minutes. CLI: brew install aouicher/graphmind/graphmind, then graphmind setup once globally and graphmind init per project; first value comes after the initial index completes, which scales with repo size. The
Switching to or from Graphmind
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From raw grep/rg in your AI assistant: run graphmind setup so Claude Code hooks rewrite grep/find/rg into graph-aware searches automatically.
- →From Sourcegraph Cody-style file search: index with graphmind index . and switch queries to gm_search for RRF-ranked symbols with callers and callees attached.
- →From manual CLAUDE.md upkeep: run graphmind sync to keep symbol counts, languages, and top files current in your CLAUDE.md files.
- ↗To plain grep or IDE search: stop the GraphMind MCP server and remove the hook-claude and git hooks installed by graphmind install.
- ↗To a remote-only code intelligence service: export your graph with gm_export to Mermaid or DOT for documentation before dropping local indexing.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Graphmind”, and we withheld 6: 6 could not be judged, because “Graphmind” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Graphmind.
Official links
Tools that pair well with Graphmind
Common stack mates teams adopt alongside Graphmind, with the specific reason each pairing earns its keep.
Bito
Bito Governor is an AI model router and code context engine that grounds coding agents in your codebase to cut agent spend 40-70%
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.
Moderne
Moderne is a deterministic code-change layer that sequences repositories into a Lossless Semantic Tree so transformations land identically everywhere.
Featured Head-to-Head Comparisons
Graphmind vs Spider Cloud
If you need an AI assistant that deeply understands your codebase's architecture, Graphmind is the clear choice with its free, local-first knowledge graph. If you need to feed your AI agent real-time web data, Spider Cloud offers a cost-effective scraping API with powerful new browser AI commands. Choose based on whether your bottleneck is code understanding or external data ingestion.
Graphmind vs Voyage Ai
If you need high-accuracy retrieval on domain-specific data like finance or legal docs, Voyage AI's specialized embeddings and 32K context are unmatched. If you're a developer wanting architecture-aware code assistance with persistent memory, Graphmind's local-first knowledge graph and MCP tools slash token usage drastically. Choose based on your data type: text documents or codebases.
Graphmind vs Temporal Ai
If you're a developer using AI coding assistants and need grounded, architecture-aware code context with token savings, choose Graphmind: it's free, local-first, and integrates directly with your AI tools. If you're building reliable AI agents or multi-step workflows that require automatic retries, state persistence, and human-in-the-loop, choose Temporal: it's battle-tested by OpenAI and Replit, with new usage-based billing starting June 2026. They solve completely different problems—don't pick one over the other unless your need is code intelligence vs. durable execution.
Alternatives to Graphmind
View all
Bito
Bito Governor is an AI model router and code context engine that grounds coding agents in your codebase to cut agent spend 40-70%
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.
Frequently Asked Questions
Best-of guides
Used Graphmind? Help shape our editorial sentiment research.