DevBitsLab.Mcp.SourceGraph.Tool 0.7.0

DevBitsLab.Mcp.SourceGraph

A live code source graph Model Context Protocol server for .NET solutions. It indexes your C# code with Roslyn into a SQLite + FTS5 database, exposes structured graph queries to MCP-aware clients (Claude Code, Cursor, Continue, Claude Desktop, …) over stdio, and keeps the index fresh as files change on disk.

The goal is to let coding agents replace dozens of ad-hoc Grep + Read calls with a single structured tool call:

"Where is OrderService.PublishAsync defined?" "Who calls it transitively, and what would change if I rename it?" "Find every controller action attributed [HttpPost] whose route contains /v2/." "Which tests cover this method, and who authored it last?"

Contents

• Features
• Requirements
• Installation
• Wiring it into an MCP client
• MCP tools
• Resource templates
• Scopes (multi-solution monorepos)
• Command-line interface
• How the index stays live
• Observability
• Building from source
• License

Features

• Roslyn-backed C# indexing. Symbols, references, call/uses-type/overrides/ implements/instantiates/throws edges, XML doc summaries, accessibility, and modifiers — all queryable in one round-trip.
• FTS5 name search. Trigram fragment matching for cases where you only remember "…Greet…Async".
• Optional code-aware semantic search. ONNX embeddings (default model: jinaai/jina-embeddings-v2-base-code) stored in sqlite-vec for natural-language queries like "find the rate-limiting code". Disable with --no-embeddings to skip the model download entirely.
• Attribute search. Find every symbol carrying a given attribute, optionally filtered by serialised argument substring.
• Roslyn diagnostics indexing. Query analyzer warnings/errors captured at index time, by severity, code, or symbol.
• Source-generator awareness. Symbols emitted by incremental generators (regex, MVVM Toolkit, ASP.NET routing, JSON source-gen, …) are tracked and filterable.
• Test discovery & git history. Tests edges from xUnit/NUnit/MSTest tests to the production members they exercise; cached per-symbol git-blame summary (last commit, author, time).
• Multi-solution monorepo scopes. One database per scope, isolation flag for vendored/generated code, fan-out queries with scope = "*".
• Live updates. File watcher + .git/HEAD watcher (worktree-aware), 200 ms debounce, batched re-index. Symbol ids stay stable across edits so existing references remain valid.
• Stable plugin SDK. DevBitsLab.Mcp.SourceGraph.Sdk exposes IMcpToolPlugin for adding bespoke tools that share the same scope router.

Requirements

• .NET 10 SDK (see global.json).
• A .sln or .slnx solution file for the codebase you want to index.
• An MCP-aware client (Claude Code, Cursor, Continue, Claude Desktop, …).

Installation

Install the published .NET tool globally:

dotnet tool install -g DevBitsLab.Mcp.SourceGraph.Tool

Make sure ~/.dotnet/tools is on your PATH. The installed command is sourcegraph-mcp. You can also pin a version per repository — see Pin a version per repo below.

Wiring it into an MCP client

Claude Code (project-scoped, committed to the repo)

Drop a .mcp.json at the repository root:

{
  "mcpServers": {
    "sourcegraph": {
      "command": "sourcegraph-mcp",
      "args": ["serve", "--solution", "${workspaceFolder}/MySolution.slnx"]
    }
  }
}

Open the directory in Claude Code and approve the server when prompted. Claude Code expands ${workspaceFolder} automatically; if your client doesn't, the server falls back to the WORKSPACE_FOLDER, CLAUDE_PROJECT_DIR, or MCP_WORKSPACE_FOLDER environment variable. Any other ${VAR} token is expanded against the process environment, so paths like ${HOME}/repos/my.slnx work too.

Pin a version per repo

dotnet new tool-manifest
dotnet tool install DevBitsLab.Mcp.SourceGraph.Tool
git add .config/dotnet-tools.json

Collaborators run dotnet tool restore once. Your .mcp.json then invokes dotnet sourcegraph-mcp serve … — no global install required.

Cursor / Claude Desktop / Continue

Use the same command + args shape inside each client's configuration file (for example ~/.cursor/mcp.json, claude_desktop_config.json, or Continue's MCP block).

Multi-scope monorepo

Run serve without --solution from the repo root and let it discover .sourcegraph.json:

{
  "mcpServers": {
    "sourcegraph": {
      "command": "sourcegraph-mcp",
      "args": ["serve", "--root", "${workspaceFolder}"]
    }
  }
}

See Scopes below for the configuration format.

MCP tools

Every tool accepts an optional scope parameter (a scope id, a comma-separated list, or "*" for fan-out). Detailed parameter docs are emitted by the server to the client at handshake time.

Discovery & navigation

Search

Diagnostics, generation, tests, history

Operations

Example tool calls

// Where is OrderService.PublishAsync defined?
{ "tool": "find_definition", "args": { "symbol": "OrderService.PublishAsync" } }

// Who would I break if I changed it?
{ "tool": "impact_of_change",
  "args": { "symbol": "OrderService.PublishAsync", "maxDepth": 4 } }

// Every POST controller action whose route contains "/v2/"
{ "tool": "find_by_attribute",
  "args": { "name": "HttpPost", "argValue": "/v2/" } }

// "Find the retry/back-off code"
{ "tool": "semantic_search",
  "args": { "query": "exponential backoff retry policy", "k": 10 } }

// Compiler/analyzer warnings on a specific symbol
{ "tool": "find_diagnostics",
  "args": { "severity": "warning", "symbol": "Legacy.Helpers.OldShim" } }

// What tests cover this before I refactor it?
{ "tool": "list_tests_for", "args": { "symbol": "OrderService.PublishAsync" } }

// Who last touched it, and when?
{ "tool": "who_authored", "args": { "symbol": "OrderService.PublishAsync" } }

// Fan a query out across every non-isolated scope in a monorepo
{ "tool": "find_references",
  "args": { "symbol": "ILogger.LogError", "scope": "*" } }

Resource templates

Hosts that surface MCP resources can dereference these URIs:

Scopes (multi-solution monorepos)

A .sourcegraph.json at the repo root opts a project into multi-scope mode:

{
  "scopes": [
    { "name": "frontend", "solutions": ["src/frontend.slnx"] },
    { "name": "backend",  "solutions": ["src/backend.slnx"], "exclude": ["**/Generated/**"] }
  ],
  "default_scope": "backend"
}

• Each scope owns its own SQLite database at .sourcegraph/scopes/<id>.db.
• A _meta.db registry tracks per-scope status (ok | degraded | indexing) and last-indexed timestamp.
• isolated: true excludes a scope from scope = "*" fan-out — useful for vendored or generated code that shouldn't pollute references on production symbols.
• Without a .sourcegraph.json and without --solution, a synthesised default scope keeps single-solution users working unchanged.
• The legacy single-database layout (.sourcegraph/graph.db) is migrated to scopes/default.db automatically on first start.
• Live indexing currently resolves a Roslyn workspace per scope only for solutions-based scopes. Scopes declared via projects or paths are accepted by the config loader but are not indexed by the live server yet — prefer solutions for now.

Every tool accepts an optional scope parameter — pass an id, a comma-separated list, or "*" to fan out.

Command-line interface

sourcegraph-mcp <subcommand> [options]

Common flags:

Examples:

sourcegraph-mcp index ./MySln.sln
sourcegraph-mcp serve --solution ./MySln.sln
sourcegraph-mcp serve --root ./repo --no-embeddings
sourcegraph-mcp init-scopes
sourcegraph-mcp scopes add backend --solution ./backend.slnx
sourcegraph-mcp stats --db ./.sourcegraph/scopes/default.db

How the index stays live

• Recursive *.cs file watcher that ignores obj/, bin/, .git/, and .sourcegraph/.
• .git/HEAD watcher — also handles git worktrees by parsing gitdir: from the .git file — so branch switches trigger a re-blame.
• 200 ms debounce window with batched re-indexing.
• Each canonical symbol keeps a stable id across edits, so references from other files remain valid even after rapid local changes.

Observability

• Every tool call appends to <solution>/.sourcegraph/usage.jsonl (or the per-scope equivalent), so you can audit how agents are using the graph.
• The usage_stats tool returns in-process counts and latencies on demand — use it at the end of a turn to confirm the agent reached for the graph instead of falling back to Grep + Read.

Building from source

git clone https://github.com/Jak3b0/DevBitsLab.Mcp.SourceGraph.git
cd DevBitsLab.Mcp.SourceGraph
dotnet build
dotnet test

To point a project's .mcp.json at your local checkout instead of the published tool, swap command / args for:

{
  "command": "dotnet",
  "args": [
    "run", "--project",
    "${workspaceFolder}/path/to/DevBitsLab.Mcp.SourceGraph/src/DevBitsLab.Mcp.SourceGraph.Server",
    "--no-build", "--no-launch-profile", "--verbosity", "quiet",
    "--", "serve", "--solution", "${workspaceFolder}/MySolution.slnx"
  ]
}

Re-run dotnet build after each change so the next launch picks it up.

License

Released under the MIT License.