SkillFoxx

gograph MCP

Local static analysis for Go with an MCP server: call graphs, change impact, symbol search and review before and after edits

  • 231 ★ on the repository
  • Last commit
  • MIT
MCP server

Minimal access

Why this level

  • The server reads repository sources locally, does not run code or send data outward and writes the graph and session log to disk
All reasons and checks

ozgurcd/gographAuthor:ozgurcd

Install

Manual install

brew install --cask ozgurcd/tap/gograph

Alternative: `go install github.com/ozgurcd/gograph/cmd/gograph@latest`.

Access and checks

How we review

Minimal accessThe tool runs nothing and makes no network calls.

  • The server reads repository sources locally, does not run code or send data outward and writes the graph and session log to disk

This is third-party code. Review the repository files before installing.

What it does

gograph parses a Go repository locally and gives an agent deterministic knowledge of structure: who calls whom, what an edit touches, where a symbol is declared and which tests reach it. Indexing parses source without running application code or touching its services, and the output is exact and bounded by pages. Commands group by task. Navigation: `query`, `callers`, `callees`, `path`, `source`. Context in one call: `context`, `explain`, `focus`. Change analysis: `plan` before an edit, `review` after it, `risk`, `impact`, `changes`. Architecture: `boundaries`, `coupling`, `complexity`, `orphans`. Infrastructure: routes, SQL, environment variables, errors. Security: `flow` looks for possible paths of untrusted data to SQL, processes, the file system and outbound HTTP. A `summary` briefing with hotspots is included. For MCP the server runs locally over stdio, with a plugin for Claude Code and an MCPB build from the registry.

Who it is for. Go developers who edit large repositories together with an agent and want it to plan an edit from the call graph rather than from string search.

Good fit when

  • Before a refactor the agent builds a `plan`: who calls the function, which tests cover it and what may break
  • After an edit `review` shows touched calls and places the tests do not cover
  • You need to find HTTP routes and SQL accesses in an unfamiliar service in one pass
  • A check of untrusted data paths to SQL or outbound HTTP runs before review

Not a fit when

  • The project is not in Go: analysis relies on Go tooling and types
  • You need to run tests or code: gograph by design never runs binaries or tests
  • You only need a quick string search: `grep` is enough and a graph takes longer

Example request

Build the repository call graph, make a plan for editing the payment handling function and show which tests reach it and what the change touches

MCP

Transport
stdio
Authentication
not required

Limitations

Analysis is static: it does not run target code or tests and does not assess execution coverage. Exact results need `build --precise`, and with too low a memory limit the build slows or fails, and the limit is never lowered silently. A simplified AST graph does not prove the absence of calls. The index has to be rebuilt after upgrading the version. Results are split into pages and continuation goes by cursor. The license is MIT and the MCP registry version is 1.7.18. Installation goes through Homebrew or `go install`, and registry registration is a separate path that does not install the Homebrew cask.

How to disable. Remove the gograph block from the client config, the Claude Code plugin and the CLI: `brew uninstall --cask gograph` or delete the binary from `go install`. The graph directory in the repository can be deleted by hand.

FAQ

How do I install gograph?

With `brew install --cask ozgurcd/tap/gograph` or `go install github.com/ozgurcd/gograph/cmd/gograph@latest`. Clients that support MCPB can use the local stdio server in the official registry as `io.github.ozgurcd/gograph`.

Where do I start with an unfamiliar repository?

With `gograph summary`: it gives hotspots, the least stable package, the most complex function and the counts of orphans and god objects. `hotspot --top 5` and `flow --no-tests` fit next.

Does gograph run project code?

No, indexing parses sources and does not call application services. It never runs binaries or tests and does not scan `.env`, key or certificate files.

What does the review command do?

After an edit it shows touched calls, tests and impact from the graph, including deleted declarations from `changes --git HEAD`. It does not evaluate callers and tests of deleted code and names that as a limit.

What is a session audit?

Telemetry records whether the agent ran `plan` before edits and `review` after them and grades it from A to F with recommendations. Commands: `session create`, `end`, `audit`, `cleanup`.

Discussion

No questions or reviews yet.

MCP servers

A gopls-based MCP server: the agent finds Go definitions, interface implementations, references and calls with compiler precision

MCP serverMinimal access60

Local code structure graph: builds a repository map with tree-sitter and serves the assistant only the context a change actually touches over MCP

MCP serverExtended access32.7K

An MCP server that builds a code knowledge graph: semantic search, call graph, HTTP route tracing and change impact analysis.

MCP serverExtended access95

An MCP server that builds a code graph of functions, classes, calls and routes and answers the agent's structural queries locally

MCP serverExtended access48.6K

Local code graph for agents: an MCP server returns entry points, symbol links and change impact in one call

MCP serverExtended access77.5K

README in short

The text opens with notes on symbols and selectors and describes graph accuracy: struct queries, routes, constants and index freshness. Then come installation, a quick start, a table of commands by category, federated workspaces and an audit of agent behavior.

README badge

Report a problem