# io.github.csa7mdm/dotnetdevmcp (nuget · DotNetDevMCP)

MCP server for .NET: Roslyn code navigation and refactoring, build, and affected-test selection.

- Trust score: 57/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-24

## Components

- nuget · `DotNetDevMCP`: 57/100 (this document), [markdown](https://verifymcp.io/servers/csa7mdm-dotnetdevmcp/dotnetdevmcp.md), [page](https://verifymcp.io/servers/csa7mdm-dotnetdevmcp/dotnetdevmcp)

## Channel facts

- Registry: `nuget`
- Package: `DotNetDevMCP`
- Version: `0.3.3`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-24.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 83/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 3780 tokens (~102/item across 37 items; 37 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: the tool surface changed between 0.2.2 and 0.3.3: 16 tool removals, 0 breaking changes, 0 additions.
- **Tool Coverage**: 88/100
  - 86% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 91% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 37 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the io.github.csa7mdm/dotnetdevmcp MCP server?

io.github.csa7mdm/dotnetdevmcp runs locally as a NuGet package, launched with dnx DotNetDevMCP@0.3.3 --yes. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add csa7mdm-dotnetdevmcp -- dnx DotNetDevMCP@0.3.3 --yes
```

### Cursor

```json
{
  "mcpServers": {
    "csa7mdm-dotnetdevmcp": {
      "command": "dnx",
      "args": [
        "DotNetDevMCP@0.3.3",
        "--yes"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "csa7mdm-dotnetdevmcp": {
      "command": "dnx",
      "args": [
        "DotNetDevMCP@0.3.3",
        "--yes"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add csa7mdm-dotnetdevmcp -- dnx DotNetDevMCP@0.3.3 --yes
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "csa7mdm-dotnetdevmcp": {
      "type": "local",
      "command": [
        "dnx",
        "DotNetDevMCP@0.3.3",
        "--yes"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  csa7mdm-dotnetdevmcp:
    command: "dnx"
    args: ["DotNetDevMCP@0.3.3", "--yes"]
```

### Netclaw

```json
{
  "McpServers": {
    "csa7mdm-dotnetdevmcp": {
      "Transport": "stdio",
      "Command": "dnx",
      "Arguments": [
        "DotNetDevMCP@0.3.3",
        "--yes"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "csa7mdm-dotnetdevmcp": {
      "command": "dnx",
      "args": [
        "DotNetDevMCP@0.3.3",
        "--yes"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-24 (score 57, −14)

- [security regression] Stability: unverified → fail
- [security regression] Malware scan: pass → unverified
- [functional regression] Schema quality: 78 → 102
- [functional regression] Schema quality: 78 → 100
- [functional improvement] Tool coverage: 79% → 86%
- [functional] Package version: 0.2.2 → 0.3.3
- [functional] Package version: 0.2.2 → 0.3.1
- [functional] Package version: 0.2.2 → 0.3.0

### 2026-09-23 (score 71)

First indexed and scored.

## MCP tools (37)

### `dotnet_test_discover` (~78 tokens)

Lists the tests in a test project (dotnet test --list-tests). Builds the project first unless it is already built.

Input parameters:

- `filter` (string|null): VSTest filter, e.g. FullyQualifiedName~OrderService or Category=Unit
- `projectPath` (string, required): Path to the test project (.csproj)

### `configure_resource_limits` (~39 tokens)

Sets the maximum number of orchestrated operations that may run concurrently.

Input parameters:

- `maxConcurrency` (integer, required): Maximum number of concurrent operations (>= 1)

### `dotnet_analyze_project` (~31 tokens)

Input parameters:

- `includeDependencies` (boolean)
- `includeMetrics` (boolean)
- `path` (string, required)

### `dotnet_build_with_properties` (~159 tokens)

Builds a .NET project with custom MSBuild properties. Useful for setting version numbers, configuration values, etc. Returns a compact summary by default; pass verbose=true for raw MSBuild output lines too.

Input parameters:

- `configuration` (string|null): Build configuration (Debug/Release)
- `framework` (string|null): Target framework (e.g., net8.0)
- `projectPath` (string, required): Path to the project file (.csproj) or solution file (.sln)
- `properties` (object, required): MSBuild properties as key-value pairs (e.g., Version=1.0.0, Configuration=Release)
- `verbose` (boolean): Include raw MSBuild output lines in the response. Default false returns a compact summary only.

### `SharpTool_LoadSolution` (~147 tokens)

The the `SharpTool` suite provides you with focused, high quality, and high information density dotnet analysis and editing tools. When using `SharpTool`s, you focus on individual components, and navigate with type hierarchies and call graphs instead of raw code. Because of this, you create more modular, coherent, composable, type-safe, and thus inherently correct code. `SharpTool_LoadSolution` is the entry point for the suite, and should be called once at the beginning of your session to initialize the other tools with data from the solution.

Input parameters:

- `solutionPath` (string, required): The absolute file path to the .sln or .slnx solution file.

### `SharpTool_ManageUsings` (~105 tokens)

Reads or writes using directives in a document.

Input parameters:

- `codeToWrite` (string, required): For 'read', must be 'None'. For 'write', provide all using directives that should exist in the file. This will replace all existing usings.
- `filePath` (string, required): The absolute path to the file to manage usings in
- `operation` (string, required): 'read' or 'write'. For 'read', set codeToWrite to 'None'.

### `dotnet_analyze_quality` (~15 tokens)

Input parameters:

- `path` (string, required)

### `SharpTool_ReadTypesFromRoslynDocument` (~71 tokens)

Returns a comprehensive tree of types (classes, interfaces, structs, etc.) and their members from a specified file. Use this to enter the more powerful 'type' domain from the 'file' domain.

Input parameters:

- `filePath` (string, required): The absolute path to the file to analyze.

### `SharpTool_ManageAttributes` (~103 tokens)

Reads or writes all attributes on a declaration.

Input parameters:

- `codeToWrite` (string, required): For 'read', must be 'None'. For 'write', specify all attributes that should exist on the target declaration. This will replace all existing attributes.
- `operation` (string, required): 'read' or 'write'. For 'read', set codeToWrite to 'None'.
- `targetDeclaration` (string, required): The FQN of the target declaration to manage attributes for

### `dotnet_get_dependencies` (~15 tokens)

Input parameters:

- `projectPath` (string, required)

### `dotnet_detect_circular_dependencies` (~17 tokens)

Input parameters:

- `solutionPath` (string, required)

### `dotnet_build` (~201 tokens)

Builds a .NET project or solution with configurable options. Returns a compact summary by default (counts, all errors, up to the first 20 de-duplicated warnings); pass verbose=true for raw MSBuild output lines too.

Input parameters:

- `configuration` (string|null): Build configuration (Debug/Release)
- `framework` (string|null): Target framework (e.g., net8.0)
- `noRestore` (boolean): Skip restoring packages
- `projectPath` (string, required): Path to the project file (.csproj) or solution file (.sln)
- `runtime` (string|null): Target runtime (e.g., win-x64, linux-x64)
- `verbose` (boolean): Include raw MSBuild output lines in the response. Default false returns a compact summary only.
- `verbosity` (integer): Verbosity level (0=quiet, 1=minimal, 2=normal, 3=detailed, 4=diagnostic)

### `SharpTool_RenameSymbol` (~105 tokens)

Renames a symbol (variable, method, property, type) and updates all references. Changes are formatted.

Input parameters:

- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `fullyQualifiedSymbolName` (string, required): FQN of the symbol to rename.
- `newName` (string, required): The new name for the symbol.

### `get_resource_metrics` (~24 tokens)

Returns current concurrency limits and how many orchestrated operations are running or queued.

### `SharpTool_ReadRawFromRoslynDocument` (~50 tokens)

Reads the content of a file in the solution or referenced directories. Omits indentation to save tokens.

Input parameters:

- `filePath` (string, required): The absolute path to the file to read.

### `SharpTool_FindAndReplace` (~199 tokens)

Every developer's favorite. Use this for all small edits (code tweaks, usings, namespaces, interface implementations, attributes, etc.) instead of rewriting large members or types.

Input parameters:

- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `regexPattern` (string, required): Regex operating in multiline mode, so `^` and `$` match per line. Always use `\s*` at the beginnings of lines for unknown indentation. Make sure to escape your escapes for json.
- `replacementText` (string, required): Replacement text, which can include regex groups ($1, ${name}, etc.)
- `target` (string, required): Target, which can be either a FQN (replaces text within a declaration) or a filepath supporting globbing (`*`) (replaces all instances across files)

### `SharpTool_AddMember` (~206 tokens)

Adds one or more new member definitions (Property, Field, Method, inner Class, etc.) to a specified type. Code is parsed, inserted, and formatted. Definition can include xml documentation and attributes. Writing small components produces cleaner code, so you can use this to break up large components, in addition to adding new functionality.

Input parameters:

- `codeSnippet` (string, required): The C# code to add.
- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `fileNameHint` (string, required): If the target is a partial type, specifies which file to add to. Set to 'auto' to determine automatically.
- `fullyQualifiedTargetName` (string, required): FQN of the parent type or method.
- `lineNumberHint` (integer, required): Suggest a line number to insert the member near. '-1' to determine automatically.

### `SharpTool_GetMembers` (~100 tokens)

Lists the full signatures of members of a specified type, including XML documentation. Essential for rapidly understanding a type's API, but does not give you the implementations. Use this like Intellisense when you're writing code which depends on the target class.

Input parameters:

- `fullyQualifiedTypeName` (string, required): The fully qualified name of the type.
- `includePrivateMembers` (boolean, required): If true, includes private members; otherwise, only public/internal/protected members.

### `SharpTool_MoveMember` (~132 tokens)

Moves a member (property, field, method, nested type, etc.) from one type/namespace to another. The member is removed from the source location and added to the destination.

Input parameters:

- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `fullyQualifiedDestinationTypeOrNamespaceName` (string, required): FQN of the destination type or namespace where the member should be moved.
- `fullyQualifiedMemberName` (string, required): FQN of the member to move.

### `SharpTool_OverwriteRoslynDocument` (~124 tokens)

Overwrites an existing document file with the specified content. You must use SharpTool_ReadRawFromRoslynDocument first.

Input parameters:

- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `content` (string, required): The content to write to the file. For C#, omit indentation to save tokens. Code will be auto-formatted.
- `filePath` (string, required): The absolute path to the file to overwrite.

### `SharpTool_FindReferences` (~60 tokens)

Finds all references to a specified symbol with surrounding context. Indentation is omitted to save space. Critical for understanding symbol usage patterns across the codebase before editing the target.

Input parameters:

- `fullyQualifiedSymbolName` (string, required): The FQN of the symbol.

### `SharpTool_ViewDefinition` (~75 tokens)

Displays the verbatim source code from the declaration of a target symbol (class, method, property, etc.) with indentation omitted to save tokens. Essential to fully understand a specific implementation without opening files.

Input parameters:

- `fullyQualifiedSymbolName` (string, required): The fully qualified name of the symbol (type, method, property, etc.).

### `SharpTool_LoadProject` (~39 tokens)

Use this immediately after LoadSolution. This injects a comprehensive understanding of the project structure into your context.

Input parameters:

- `projectName` (string, required)

### `dotnet_test_run` (~267 tokens)

Runs tests in a project or a whole solution with one dotnet test invocation and returns per-test results, failures with messages and stack traces. Use filter or testNames to narrow.

Input parameters:

- `filter` (string|null): VSTest filter expression, e.g. FullyQualifiedName~OrderService|Category=Unit. For a project that runs under Microsoft.Testing.Platform, this is instead that test framework's own filter options, e.g.…
- `framework` (string|null): Run one target framework only, e.g. net10.0. Default: every framework the projects target.
- `noBuild` (boolean): Skip the build. Only when nothing changed since the last build.
- `path` (string, required): Path to a test project (.csproj) or a solution (.sln)
- `testNames` (array|null): Exact fully qualified test names to run (Namespace.Class.Method). Combined with filter if both given.
- `timeoutSeconds` (integer): Kill the run and fail it past this many seconds. A run must always return, even if a test hangs (e.g. an injected fault causing a deadlock). Default 600.

### `SharpTool_OverwriteMember` (~170 tokens)

Replaces the definition of an existing member or type with new C# code, or deletes it. Code is parsed and formatted. Code can contain multiple new members, update the existing member, and/or replace it with a new one.

Input parameters:

- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `fullyQualifiedMemberName` (string, required): FQN of the member or type to rewrite.
- `newMemberCode` (string, required): The new C# code for the member or type. *If this member has attributes or XML documentation, they MUST be included here.* To Delete the target instead, set this to `// Delete {memberName}`.

### `SharpTool_RequestNewTool` (~103 tokens)

Allows requesting a new tool to be added to the SharpTools MCP server. Logs the request for review.

Input parameters:

- `expectedOutput` (string, required): Expected output and format.
- `expectedParameters` (string, required): Expected input parameters and their descriptions.
- `justification` (string, required): Justification for why this tool would be valuable.
- `toolDescription` (string, required): Detailed description of what the tool should do.
- `toolName` (string, required): Name for the proposed tool.

### `SharpTool_Undo` (~40 tokens)

Reverts the last applied change to the solution. You can undo all consecutive changes you have made. Returns a diff of the change that was undone.

### `dotnet_scan_outdated_packages` (~17 tokens)

Input parameters:

- `projectPath` (string, required)

### `dotnet_clean` (~91 tokens)

Cleans build artifacts from a .NET project or solution.

Input parameters:

- `configuration` (string|null): Build configuration to clean (Debug/Release)
- `projectPath` (string, required): Path to the project file (.csproj) or solution file (.sln)
- `verbose` (boolean): Include the full raw output in the response. Default false omits it on success and returns only a short tail on failure.

### `SharpTool_ListImplementations` (~73 tokens)

Gets the locations and FQNs of all implementations of an interface or abstract method, and lists derived classes for a base class. Crucial for navigating polymorphic code and understanding implementation patterns.

Input parameters:

- `fullyQualifiedSymbolName` (string, required): The fully qualified name of the interface, abstract method, or base class.

### `SharpTool_CreateRoslynDocument` (~118 tokens)

Creates a new document file with the specified content. Returns error if the file already exists.

Input parameters:

- `commitMessage` (string, required): Commit message summary of this change. Ignored when git integration is disabled (the default) - enable with --git-commit-edits to have edits create git commits.
- `content` (string, required): The content to write to the file. For C#, omit indentation to save tokens. Code will be auto-formatted.
- `filePath` (string, required): The absolute path where the file should be created.

### `dotnet_test_affected` (~383 tokens)

Finds the tests that reference the code in the changed files (via Roslyn, through the loaded solution) and runs only those. Default changed files: the git working tree. Requires a loaded solution (SharpTool_LoadSolution or --load-solution).

Input parameters:

- `changedFiles` (array|null): Changed source files. Omit to use git: uncommitted changes, or the diff against gitBase if given.
- `dryRun` (boolean): Only report which tests would run; do not run them.
- `framework` (string|null): Run one target framework only, e.g. net10.0: much faster for multi-targeted test projects. Default: every framework.
- `gitBase` (string|null): Git ref to diff against instead of the working tree, e.g. main or HEAD~3
- `maxDepth` (integer): How many reference hops to follow from a changed symbol (1 = tests that call it directly). Default 8.
- `maxSelectedFraction` (number): Above this share of all test methods, run the whole solution instead of the filtered selection. Measured on Polly: a selection of 4% of tests ran 3.3x faster than the whole suite, but 23% was slower…
- `maxSelectionSeconds` (integer): Seconds allowed for tracing. Past it the change reaches too much code for selection to beat running everything, so the whole solution runs instead. Default 10.
- `noBuild` (boolean): Skip building the affected test projects. Only when nothing changed since the last build.
- `timeoutSeconds` (integer): Kill the run and fail it past this many seconds. A run must always return, even if a test hangs. Default 600.

### `execute_workflow` (~80 tokens)

Runs tools of this server as a dependency graph: steps whose dependencies are done run in parallel, dependents wait. Use for build -> test -> analyze pipelines.

Input parameters:

- `steps` (array, required): Steps. dependsOn lists step names that must finish first; steps with no unmet dependencies run in parallel.
- `workflowName` (string, required): Name of the workflow

### `SharpTool_SearchDefinitions` (~86 tokens)

Dual-engine pattern search across source code AND compiled assemblies for public APIs. Perfect for finding all implementations of a pattern - e.g., finding all async methods with 'ConfigureAwait', or all classes implementing IDisposable. Searches declarations, signatures, and type hierarchies.

Input parameters:

- `regexPattern` (string, required): The regex pattern to match against full declaration text (multiline) and symbol names.

### `SharpTool_AnalyzeComplexity` (~96 tokens)

Deep analysis of code complexity metrics including cyclomatic complexity, cognitive complexity, method stats, coupling, and inheritance depth. Scans methods, classes, or entire projects to identify maintenance risks and guide refactoring decisions.

Input parameters:

- `scope` (string, required): The scope to analyze: 'method', 'class', or 'project'
- `target` (string, required): The fully qualified name of the method/class, or project name to analyze

### `orchestrate_parallel` (~85 tokens)

Runs several tools of this server concurrently (throttled by the resource manager) and returns every result. Use for independent operations, e.g. build two projects while running tests.

Input parameters:

- `maxParallelism` (integer|null): Maximum degree of parallelism (default: processor count)
- `operations` (array, required): Operations to run. Each has the tool name and its arguments object.

### `dotnet_restore` (~76 tokens)

Restores NuGet packages for a .NET project or solution.

Input parameters:

- `projectPath` (string, required): Path to the project file (.csproj) or solution file (.sln)
- `verbose` (boolean): Include the full raw output in the response. Default false omits it on success and returns only a short tail on failure.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/csa7mdm-dotnetdevmcp/dotnetdevmcp#diagnostics

## Score history

- 2026-09-24: 57
- 2026-09-23: 71

## Common questions

### What is the io.github.csa7mdm/dotnetdevmcp MCP server?

io.github.csa7mdm/dotnetdevmcp is an MCP server listed in the public MCP registry as io.github.csa7mdm/dotnetdevmcp. MCP server for .NET: Roslyn code navigation and refactoring, build, and affected-test selection. This page covers its NuGet package (DotNetDevMCP).

### Is the io.github.csa7mdm/dotnetdevmcp MCP server safe to use?

io.github.csa7mdm/dotnetdevmcp scores 57 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 24 September 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.csa7mdm/dotnetdevmcp MCP server expose?

io.github.csa7mdm/dotnetdevmcp exposes 37 tools: dotnet_test_discover, configure_resource_limits, dotnet_analyze_project, dotnet_build_with_properties, SharpTool_LoadSolution, and 32 more. Their descriptions and schemas cost roughly 3,780 tokens of context every time the server is loaded.

### Is the io.github.csa7mdm/dotnetdevmcp MCP server still maintained?

io.github.csa7mdm/dotnetdevmcp is still listed as active in the MCP registry. We last reached this channel on 24 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.csa7mdm/dotnetdevmcp MCP server under?

io.github.csa7mdm/dotnetdevmcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- NuGet package: https://www.nuget.org/packages/DotNetDevMCP
- Socket report: https://socket.dev/nuget/package/DotNetDevMCP
- Repository: https://github.com/csa7mdm/DotNetDevMCP
- Website: https://github.com/csa7mdm/DotNetDevMCP/wiki
- Changelog RSS feed: https://verifymcp.io/servers/csa7mdm-dotnetdevmcp/dotnetdevmcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/csa7mdm-dotnetdevmcp/dotnetdevmcp.json
- HTML version of this page: https://verifymcp.io/servers/csa7mdm-dotnetdevmcp/dotnetdevmcp