DeveloperProjectAssistant.McpServer 0.2.0

Developer Project Assistant MCP Server

This project was scaffolded using the C# MCP server project template (dotnet new mcpserver). See /docs/implementation-plan.md at the repo root for the full design and phase-by-phase implementation plan.

The MCP server is built as a self-contained application and does not require the .NET runtime to be installed on the target machine. However, since it is self-contained, it must be built for each target platform separately. By default, the template is configured to build for:

• win-x64
• win-arm64
• osx-arm64
• linux-x64
• linux-arm64
• linux-musl-x64

If your users require more platforms to be supported, update the list of runtime identifiers in the project's <RuntimeIdentifiers /> element.

See aka.ms/nuget/mcp/guide for the full guide.

Please note that this template is currently in an early preview stage. If you have feedback, please take a brief survey.

Checklist before publishing to NuGet.org

• Test the MCP server locally using the steps below.
• Update the package metadata in the .csproj file, in particular the <PackageId>.
• Update .mcp/server.json to declare your MCP server's inputs.
  • See configuring inputs for more details.
• Pack the project using dotnet pack.

The bin/Release directory will contain the package file (.nupkg), which can be published to NuGet.org.

Developing locally

To test this MCP server from source code (locally) without using a built MCP server package, you can configure your IDE to run the project directly using dotnet run. This server requires a --project-root <path> argument pointing at the .NET solution to inspect.

{
  "servers": {
    "DeveloperProjectAssistant.McpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<PATH TO PROJECT DIRECTORY>",
        "--",
        "--project-root",
        "<PATH TO SOLUTION TO INSPECT>"
      ]
    }
  }
}

Refer to the VS Code or Visual Studio documentation for more information on configuring and using MCP servers:

• Use MCP servers in VS Code (Preview)
• Use MCP servers in Visual Studio (Preview)

Testing the MCP Server

Once configured, ask your AI client to "ping the developer project assistant server" or "get the server info" — it should invoke the ping or get_server_info tool on the DeveloperProjectAssistant.McpServer MCP server and show you the result.

Testing the packaged tool locally

Before publishing, verify the actual packaged tool works (not just dotnet run from source):

dotnet pack -c Release
dotnet tool install --global --add-source ./bin/Release --version <version-in-csproj> DeveloperProjectAssistant.McpServer
developer-project-assistant --project-root <path-to-a-solution>

If <PackageVersion> is a prerelease version (e.g. 0.1.0-beta), --version is required -- dotnet tool install silently reports the package as "not found" otherwise, even when it's sitting right there in the local source, since it doesn't consider prerelease versions by default without an explicit version or --prerelease.

dotnet pack with <RuntimeIdentifiers> set (as this project has) produces one small portable package plus one large self-contained package per RID. The installed command is a thin shim that auto-selects and runs the correct RID-specific package for the current machine -- you don't need to do that selection yourself.

Uninstall when done testing: dotnet tool uninstall --global DeveloperProjectAssistant.McpServer.

Publishing to NuGet.org

Normal publishing happens automatically via .github/workflows/release.yml when a v* tag is pushed. That workflow uses NuGet trusted publishing -- it exchanges a short-lived GitHub OIDC token for a temporary NuGet.org API key at publish time, so no long-lived API key is stored as a secret. This requires a one-time trusted publishing policy configured on nuget.org for this repo (Repository Owner kl00t, Repository developer-project-assistant, Workflow File release.yml) and a NUGET_USER repository secret holding the nuget.org profile username (not the email address).

To publish manually instead (e.g. from a fork, or before trusted publishing is configured):

1. Run dotnet pack -c Release to create the NuGet package
2. Publish to NuGet.org with dotnet nuget push bin/Release/*.nupkg --api-key <your-api-key> --source https://api.nuget.org/v3/index.json

Using the MCP Server from NuGet.org

Once the MCP server package is published to NuGet.org, you can configure it in your preferred IDE. Both VS Code and Visual Studio use the dnx command to download and install the MCP server package from NuGet.org.

• VS Code: Create a <WORKSPACE DIRECTORY>/.vscode/mcp.json file
• Visual Studio: Create a <SOLUTION DIRECTORY>\.mcp.json file

For both VS Code and Visual Studio, the configuration file uses the following server definition:

{
  "servers": {
    "DeveloperProjectAssistant.McpServer": {
      "type": "stdio",
      "command": "dnx",
      "args": [
        "DeveloperProjectAssistant.McpServer",
        "--version",
        "<published package version>",
        "--yes"
      ]
    }
  }
}

More information

.NET MCP servers use the ModelContextProtocol C# SDK. For more information about MCP:

• Official Documentation
• Protocol Specification
• GitHub Organization
• MCP C# SDK