Strider 0.10.1

Strider

A read-only MCP server that lets AI coding agents navigate .NET code the way the compiler sees it.

Strider loads your solution into Roslyn and answers questions like "who calls this method?", "what implements this interface?" or "what breaks if I change this signature?" with short, structured JSON. The agent doesn't have to grep for text and read whole files to work it out.

• Semantic, not textual. It resolves overloads, generics, extension methods, partial types and calls through interfaces (DI), and it ignores comments and strings that merely contain the name.
• Cheap on tokens. Answers are lists of symbols and path:line locations, and every list is capped. A response says whether it was cut, so the agent knows when to ask for more.
• Answers it can act on. Every symbol comes back with the exact name every other tool accepts, and every error says what to call instead.
• Sees past your code. Symbols from NuGet packages and the framework can be found and decompiled to C#.
• Stays current. Edited files are picked up within seconds, new files and project edits trigger a reload, rebuilt DLLs are swapped in, and refresh_files applies an agent's changes at once.
• Never writes. All 28 tools are read-only.

Works with any MCP client: Claude Code, VS Code, Cursor, Claude Desktop and others.

What it looks like

The agent asks where SymbolText.Ref is called, capped at three results:

// find_call_sites { "symbol": "SymbolText.Ref", "maxResults": 3 }
{
  "Target": {
    "Symbol": "Strider.Symbols.SymbolText.Ref(ISymbol, SolutionPaths, SourceClassification, CancellationToken)",
    "Kind": "method",
    "At": "src/Symbols/SymbolText.cs:132"
  },
  "CallSites": [
    { "Symbol": "Strider.Symbols.StackFrameResolver.ResolveAsync(Solution, int, StackFrame, CancellationToken)",
      "Kind": "method", "At": "src/Symbols/StackFrameResolver.cs:48" },
    { "Symbol": "Strider.Symbols.SymbolLookup.ResolveAsync(Solution, string, KindFilter, string, int?, CancellationToken, int)",
      "Kind": "method", "At": "src/Symbols/SymbolLookup.cs:46" },
    { "Symbol": "Strider.Tools.Hierarchy.FindImplementationsTool.ExecuteAsync(…)",
      "Kind": "method", "At": "src/Tools/Hierarchy/FindImplementationsTool.cs:40" }
  ],
  "TotalFound": 17, "Truncated": true, "Limit": 3
}

Each Symbol can be passed straight back as the symbol argument of another tool.

Quick start

You need the .NET 10 SDK. Strider uses it to load your solution, so it has to be a full SDK, not just the runtime.

dotnet tool install -g Strider

Claude Code

claude mcp add --scope user strider -- strider

Other clients. Add a stdio server whose command is strider. For example, in VS Code (.vscode/mcp.json):

{
  "servers": {
    "strider": { "type": "stdio", "command": "strider" }
  }
}

Clients that use the mcpServers format (Cursor, Claude Desktop) take { "mcpServers": { "strider": { "command": "strider" } } }.

No per-project setup is needed: the agent loads the solution it works on with load_solution. To have one loaded at start, pass --solution (see Choosing the solution).

Tools

Find and navigate

Read without opening files

Analyze

Project structure and ASP.NET Core

get_project_graph leaves out package references. For those and their resolved versions use the .NET CLI: dotnet package list --format json (SDK 10) or dotnet list package --format json (earlier SDKs).

Workspace

How every tool is called

• symbol names a type or member: bare (CreateAsync), with its type (OrderService.CreateAsync) or fully qualified; a parameter list picks an overload, <T> or `1 a generic type.
• file is any whole part of a path (OrderService.cs, Services/OrderService.cs, src/Orders) or a glob (**/*Tests.cs); line/column count from 1; project is a project name or .csproj path.
• Results give symbols as Symbol + Kind + At ("path:line", or "dll:Assembly" for a library symbol). Lists carry TotalFound; Truncated and Limit appear only when maxResults cut them.
• Errors carry Error (a code such as SymbolNotFound, AmbiguousMatch, NotLoaded), Message and usually Hint; AmbiguousMatch lists Candidates to pick from.

Choosing the solution

Strider loads one solution at a time, and only one that was named. There are two ways to name it:

1. --solution <path> at start: a .sln, .slnx, .slnf (only the projects it lists) or .csproj (that project and its references). A directory is scanned for a solution instead, up to 3 levels deep, so --solution . loads the one in the directory the client starts the server in.
2. load_solution from the agent, at any time. It takes the same paths and replaces what is loaded. This is useful in a git worktree, where the loaded solution may belong to another checkout.

Without --solution nothing is loaded, and tools report NotLoaded until load_solution. When a scanned directory holds several solutions, the shallowest wins, then the first alphabetically.

Other ways to run it

<details> <summary><b>Local tool, per repository</b></summary>

dotnet new tool-manifest   # if the repository has none yet
dotnet tool install Strider

.mcp.json in the repository root (Claude Code starts the server there, so --solution . loads the repository's solution):

{
  "mcpServers": {
    "strider": { "command": "dotnet", "args": ["tool", "run", "strider", "--solution", "."] }
  }
}

</details>

<details> <summary><b>Container</b></summary>

No SDK is needed on the host. The image is built with the SDK's container publishing, so there is no Dockerfile:

dotnet publish src/Strider.csproj -c Release --os linux --arch x64 /t:PublishContainer

That builds strider:latest. Mount the solution at /workspace and keep stdin open (-i), because MCP runs over stdio:

claude mcp add strider -- docker run -i --rm -v "$PWD:/workspace" strider:latest --solution /workspace

$PWD is expanded when you run the command, so register it from the repository root and once per repository (the default local scope). The base image is mcr.microsoft.com/dotnet/sdk:10.0: on a runtime-only image the server starts but cannot load any solution.

To push to a registry, add -p:ContainerRegistry=ghcr.io -p:ContainerRepository=<owner>/strider. </details>

<details> <summary><b>From source</b></summary>

dotnet run --project src/Strider.csproj -- --solution path/to/App.sln

</details>

Troubleshooting

"No .NET SDKs were found" on macOS or Linux. MCP clients often start servers without your shell profile, so DOTNET_ROOT is missing. A Homebrew dotnet wrapper script can cause the same error. Strider then looks for an SDK in the sdk/ folder next to the .NET runtime it runs on. If none is there, set DOTNET_ROOT in the server's registration:

claude mcp add-json --scope user strider \
  '{"type":"stdio","command":"strider","env":{"DOTNET_ROOT":"/usr/local/share/dotnet"}}'

Use /usr/local/share/dotnet for the official installer and /opt/homebrew/Cellar/dotnet/<version>/libexec for Homebrew.

Results come from the wrong checkout. Call get_solution_status to see what is loaded, and load_solution to switch.

A tool returns Loading. A large solution takes a while to open. Call again in a moment.

The first queries after a load are slower. The solution is usable as soon as MSBuild has opened it; the compilations are built in the background, and a query that comes first builds the ones it needs.

Results look stale after dotnet restore. A package restore without a project file edit is invisible to the server. Call reload_solution.

Development

dotnet build Strider.slnx -c Release
dotnet src/bin/Release/net10.0/Strider.dll --solution path/to/App.sln

Logs go to stderr, because stdout carries the JSON-RPC stream.