C# Class Analyzer MCP

English | 简体中文

CSharpAnalyserMcp

A read-only Model Context Protocol (MCP) server that lets an AI assistant browse any C# solution through Roslyn.

The server loads a solution with MSBuildWorkspace into a cached Roslyn snapshot and then answers structured queries about it: where each type is declared, its XML documentation, and a method's signature, documentation, source location and body. An agent can therefore pull in the exact slice of source it needs instead of reading whole files into its context window.

• Transport: stdio (StdioServerTransport), protocol traffic on stdout only; all logs go to stderr.
• Solution path is passed on the command line (--workspace <path to .sln>); the solution is loaded before the MCP handshake, so a bad path fails fast with a message on stderr and a non-zero exit code.
• Every tool returns MCP text content and never structuredContent: listing / hierarchy / search tools return one text block per entry (a string list from the client's point of view), while detail tools emit path / desc / namespace / signature / body blocks separated by a line containing ---.
• Distribution: published to NuGet as the .NET tool CSharpAnalyserMcp (command csharp-analyser-mcp) and listed in the official MCP Registry as io.github.undy-mosq/CSharpAnalyserMcp.

Installation

NuGet .NET tool (recommended)

dotnet tool install --global CSharpAnalyserMcp
csharp-analyser-mcp --workspace D:\MyProject\MySolution.sln

# upgrade / remove
dotnet tool update --global CSharpAnalyserMcp
dotnet tool uninstall --global CSharpAnalyserMcp

Install it globally: a --local install only writes a manifest entry, so csharp-analyser-mcp never lands on PATH and MCP clients cannot start it.

On demand with dnx (nothing to install, .NET SDK 10+)

# "--" separates dnx options from the arguments forwarded to the server
dnx CSharpAnalyserMcp --yes -- --workspace D:\MyProject\MySolution.sln

From source

git clone https://github.com/undy-mosq/CSharpAnalyserMcp
dotnet build CSharpAnalyserMcp\CSharpAnalyserMcp.csproj
dotnet run --project CSharpAnalyserMcp -- --workspace D:\MyProject\MySolution.sln

Requirements

Client configuration

The server is started with a single argument, --workspace, pointing at the solution file.

Installed .NET tool

The global tool shim lives in %USERPROFILE%\.dotnet\tools. MCP clients spawn the process themselves and only see the PATH they inherited, so point the configuration at the shim by absolute path (expand %USERPROFILE%, e.g. C:\Users\you\.dotnet\tools\csharp-analyser-mcp.exe):

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "csharp-analyser": {
      "command": "C:\\Users\\you\\.dotnet\\tools\\csharp-analyser-mcp.exe",
      "args": ["--workspace", "D:\\MyProject\\MySolution.sln"]
    }
  }
}

VS Code (.vscode/mcp.json):

{
  "servers": {
    "csharp-analyser": {
      "type": "stdio",
      "command": "C:\\Users\\you\\.dotnet\\tools\\csharp-analyser-mcp.exe",
      "args": ["--workspace", "D:\\MyProject\\MySolution.sln"]
    }
  }
}

The bare command name ("command": "csharp-analyser-mcp") works only when that directory is already on the client's PATH; a client started before the tool was installed keeps the old environment, so restart it after changing PATH.

On demand with dnx (nothing installed)

{
  "servers": {
    "csharp-analyser": {
      "type": "stdio",
      "command": "dnx",
      "args": ["CSharpAnalyserMcp", "--yes", "--", "--workspace", "D:\\MyProject\\MySolution.sln"]
    }
  }
}

Append @<version> to the package id to pin a version. The MCP Server tab of the NuGet package page offers the same JSON for copying. dnx is a .cmd shim; if the client cannot spawn it, use the equivalent dotnet form instead: "command": "dotnet" with "args": ["tool", "exec", "CSharpAnalyserMcp", "--yes", "--", "--workspace", "D:\\MyProject\\MySolution.sln"].

Published executable

VS Code (.vscode/mcp.json):

{
  "servers": {
    "csharp-analyser": {
      "type": "stdio",
      "command": "C:\\Tools\\csharp-analyser\\CSharpAnalyserMcp.exe",
      "args": ["--workspace", "D:\\MyProject\\MySolution.sln"]
    }
  }
}

Running the project from source

{
  "servers": {
    "csharp-analyser": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "D:\\MyProject\\CSharpAnalyserMcp\\CSharpAnalyserMcp\\CSharpAnalyserMcp.csproj",
        "--",
        "--workspace",
        "D:\\MyProject\\MySolution.sln"
      ]
    }
  }
}

Press F5 in VS Code to debug the server itself; .vscode/launch.json already passes a --workspace argument — point it at your own solution.

Tools

list_classes_in_folder

{ "folderPath": "src/Services", "kinds": ["class", "interface"] }

Files under bin/obj are skipped. Returns a string list, one text content per type, formatted as {relativePath} L{start}-{end} {namespace}: {signature}; the namespace segment is omitted for the global namespace, and a partial type reports the location of its first declaration plus a trailing ...(partial xN).

list_classes_in_namespace

{ "namespaceName": "MyApp.Services", "includeSubNamespaces": true, "kinds": ["all"] }

get_class_documentation

{ "typeDeclaration": "public static class ItemConfig", "maxXmlChars": 2000 }

On a match the result is a text block: path / desc / namespace (the global namespace prints as global) / signature / body (member signatures, one per line); multiple matches are separated by a line containing ---. A miss prints (no match) followed by candidates : and candidate declaration lines.

get_method

{ "methodDeclaration": "public static void SetEffect(RoleAttributes owner, int stack)", "typeDeclaration": "public class RoleAttributes", "namespaceName": "DuelModel" }

Matching rules:

• Both declaration lines must match the canonical signature or the first source line of the declaration exactly after whitespace is stripped (no substring matching).
• Only members declared by the type itself are searched (ordinary methods; no inherited members, constructors or properties). Explicit interface implementations (IFoo.Bar) are matched too.
• Parameter types parsed from the declaration line are compared case-insensitively and whitespace-insensitively, without namespace prefixes; C# aliases are mapped to their metadata names (int → Int32, string → String, …). The comparison is relaxed step by step: exact → ignoring generic arguments → allowing a prefix of the parameter list.
• When nothing matches, (no match) is printed followed by candidates : and candidate declaration lines (same-named methods of that type first, otherwise every method of that type).

The result is a text block per overload: path / desc (raw XML docs, 2000-char cap) / namespace / class / signature / body (source with the outermost braces and the common indentation removed); overloads are separated by a line containing ---.

find_inheritance

{ "typeDeclaration": "public abstract class BuffEntity", "namespaceName": "Duel" }

The first entry is the queried type itself (no indentation, no prefix); every derived type follows as its own text content, indented by one tab and prefixed with - per hierarchy level. A class root reports the classes / records deriving from it; an interface root reports sub-interfaces plus the classes / structs / records implementing it directly. Generic base types are matched by OriginalDefinition (Base<T> and Base<int> count as the same base). Each type appears once, at its shallowest depth; a miss returns (no match) followed by candidates : and candidate declaration lines.

find_method_overrides

{ "methodDeclaration": "public abstract void Apply(BuffEntity buff)", "typeDeclaration": "public abstract class BuffEntity", "namespaceName": "Duel" }

The first entry is the method itself; implementations / overrides follow as their own text contents, indented by one tab and prefixed with - per hierarchy level. An interface member root reports the implementing methods in every implementing type (including explicit IFoo.Bar implementations); a class method root reports the overrides in derived classes. Only the downward direction is reported — base declarations are not walked upwards. A miss returns (no match) followed by candidates : and candidate declaration lines.

search_regex

{ "path": "src/Services", "pattern": "public\\s+\\w+\\s+Get", "fileFilters": ["*.cs"] }

• A directory is searched recursively; bin / obj / .git and symlinked directories are skipped. A file path is searched directly.
• Every match is one text content: {relativePath} L{line}: {line text} (line text trimmed).
• At most 1000 matches; when truncated, a final ... [truncated: showing 1000 of N matches] entry is appended.
• Reads the files on disk, so it is not affected by the Roslyn snapshot / reload_solution.
• A missing path or an invalid regex returns isError with the reason in the text; no matches returns (no match).

reload_solution

No parameters. Discards the cached snapshot and re-opens the solution, so later queries see the current files on disk. Prints solution / resolveBaseDirectory / projects / reloaded : true ({ms} ms).

set_resolve_base_path

{ "basePath": "src" }

Type kinds and kinds

kind is lowercase and mutually exclusive: class, static class, record, struct, record struct, interface, enum, delegate. Only classes can be static, so class and static class are distinct; structs, enums, interfaces and delegates have no static form.

The kinds filter is case-insensitive and accepts multiple values (an omitted kinds behaves like ["class"]):

The same table, the declaration-line protocol (strict matching of typeDeclaration / methodDeclaration plus candidates recovery) and the text output shapes are all sent to the client as server-level instructions during the initialize handshake (see Tools/ServerInstructions.cs), so the model does not have to guess the accepted values or the output format.

Output format

Every tool returns MCP text content and never structuredContent. Listing / hierarchy / search tools return one text content per entry, so the client receives a list of strings instead of a single newline-joined block. Paths are shown relative to the resolve base directory (default: the solution's directory), using / as separator.

Listing (list_classes_in_folder / list_classes_in_namespace)

Each type is one text content (the tool returns a string list):

{relativePath} L{start}-{end} {namespace}: {signature}

The namespace segment is omitted for the global namespace (only the : remains); a partial type shows the location of its first declaration plus a trailing ...(partial xN); a miss returns a single (no match) item.

script/config/ItemConfig.cs L14-163: public static class ItemConfig
src/Services/UserService.cs L12-88 MyApp.Services: public class UserService : BaseService

Type detail (get_class_documentation)

One block per same-named type, blocks separated by a line containing ---:

path : {relativePath} L{start}-{end}
desc :
{raw XML documentation, truncated to maxXmlChars; the whole section is omitted when there is none}
namespace : {namespace; the global namespace prints as global}
signature : {modifiers + kind + name + type/primary-constructor parameters + constraints + base list}
body :
{member signatures, one per line: enum members / fields / properties / methods / events / nested types; omitted when there are none}

Method detail (get_method)

One block per overload, blocks separated by a line containing ---:

path : {relativePath} L{start}-{end}
desc :
{raw XML documentation, 2000-char cap}
namespace : {namespace}
class : {type name}
signature : {modifiers + return type + name + parameters (including this / ref / out / in / params)}
body :
{method source: block bodies lose their outermost braces and common indentation, expression bodies lose "=>"}

No match prints (no match) followed by candidates : and candidate declaration lines (brief-line format, ready to copy into the declaration parameter):

(no match)
candidates :
script/config/ItemConfig.cs L16-39: public static string TextName(this ItemInfo.ItemType itemType)
script/config/ItemConfig.cs L40-120: public static void RegisterItem(ItemModel model)

Hierarchy (find_inheritance / find_method_overrides)

The first entry is the queried type / method itself (no indentation, no -); derived types / implementations follow as their own text contents, indented by one tab and prefixed with - per hierarchy level:

script/config/BuffEntity.cs L12-40 Duel: public abstract class BuffEntity
    -script/config/DamageBuff.cs L8-25 Duel: public class DamageBuff : BuffEntity
        -script/config/BurnBuff.cs L6-18 Duel: public class BurnBuff : DamageBuff
    -script/config/HealBuff.cs L9-20 Duel: public class HealBuff : BuffEntity

No match returns a single (no match) item; candidates, when any, follow as candidates : and the candidate declaration lines.

Regex search (search_regex)

Every match is one text content:

src/Services/UserService.cs L42: public User GetById(int id)

No match returns a single (no match) item; above 1000 matches a final truncation entry is appended.

Workspace (reload_solution / set_resolve_base_path)

solution : {absolute path of the solution file}
resolveBaseDirectory : {resolve base directory}
projects : {project count}
reloaded : true ({ms} ms)

Output limits

Long payloads are truncated to keep tool results small; the appended marker reads ... [truncated: showing {n} of {m} chars]. All thresholds live in Services/TextTruncator.cs.

Passing 0 to maxXmlChars / maxBodyChars disables truncation for that call.

Typical workflow

1. Start the server once with --workspace pointing at your solution (an MCP client does this for you).
2. Discover types: list_classes_in_namespace { "namespaceName": "MyApp.Services" } or list_classes_in_folder { "folderPath": "src/Services", "kinds": ["all"] }; to find a specific string, use search_regex { "path": "src", "pattern": "..." }.
3. Read a type's contract by copying its declaration line from the listing: get_class_documentation { "typeDeclaration": "public class UserService : BaseService" }.
4. Read the exact implementation: get_method { "methodDeclaration": "public User GetById(int id)", "typeDeclaration": "public class UserService : BaseService" }.
5. Walk the hierarchy: find_inheritance { "typeDeclaration": "public abstract class UserServiceBase" } or find_method_overrides { "methodDeclaration": "public abstract User GetById(int id)", "typeDeclaration": "public abstract class UserServiceBase" }.
6. After the source files change, call reload_solution before the next query — otherwise queries keep answering from the stale snapshot.

Troubleshooting

• The server exits immediately with Solution file not found (or another MSBuild error) on stderr → the --workspace path is wrong; it must point at the solution file, not at a folder.
• The command "dnx" was not found in the client's MCP log → dnx ships with the .NET SDK 10 and newer. Install .NET SDK 10, or use an installed tool or the published executable instead.
• dotnet tool install reports that the package is not a .NET tool → the version you asked for was packed before PackAsTool was enabled; install the current version instead (dotnet tool list --global shows what is installed).
• spawn csharp-analyser-mcp ENOENT or MCP error -32000: Connection closed in the client log → the client could not resolve the command it was told to run. Use the absolute path to %USERPROFILE%\.dotnet\tools\csharp-analyser-mcp.exe (a --local install has no shim there at all) and restart the client.
• Cannot find package CSharpAnalyserMcp with version x.y.z right after a release → NuGet's index can lag behind the release. Retry later, or install from the downloaded .nupkg: dotnet tool install -g --add-source <folder> CSharpAnalyserMcp --version x.y.z.

Behavior notes and limitations

• Snapshot semantics. The solution is read once from disk; file edits become visible only after reload_solution. Unsaved editor buffers are never visible.
• Regex search reads the disk. search_regex reads files directly, bypassing the Roslyn snapshot; it searches *.cs by default, skips bin/obj/.git while recursing, and returns at most 1000 matches.
• Source-only view. Syntax trees under bin/obj are skipped, so types without source declarations are not reported.
• Declared members only. get_method does not walk base types, interfaces or the other parts of a partial type.
• Exact names. Type and method names must match exactly; namespaces are compared as full display strings. Use namespaceName (or a qualified className) to disambiguate.
• Cost. Every query asks each project for its compilation, so response time grows with solution size.
• Diagnostics. Workspace load problems are written to stderr as [WorkspaceFailed] {Kind}: {Message}; nothing but JSON-RPC ever reaches stdout.
• One solution per process. The workspace path is fixed at startup; start another instance to analyse another solution.

License

MIT — see LICENSE.

---

Building, publishing and the release process: docs/DEVELOPMENT.zh-CN.md (中文).