# Mcp Csharp Publish

> >

- **Type:** Skill
- **Install:** `agentstack add skill-dotnet-skills-mcp-csharp-publish`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [dotnet](https://agentstack.voostack.com/s/dotnet)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [dotnet](https://github.com/dotnet)
- **Source:** https://github.com/dotnet/skills/tree/main/plugins/dotnet-ai/skills/mcp-csharp-publish

## Install

```sh
agentstack add skill-dotnet-skills-mcp-csharp-publish
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# C# MCP Server Publishing

Publish and deploy MCP servers to their target platforms. stdio servers are distributed as NuGet tool packages. HTTP servers are containerized and deployed to Azure or other container hosts. Both can optionally be listed in the official MCP Registry.

## When to Use

- Packaging a stdio MCP server for NuGet distribution
- Creating a Docker container for an HTTP MCP server
- Deploying to Azure Container Apps or App Service
- Publishing to the official MCP Registry for discoverability
- Setting up `server.json` metadata for the MCP Registry

## Stop Signals

- **Server not tested yet?** → Use `mcp-csharp-test` first
- **Server not working locally?** → Use `mcp-csharp-debug`
- **No server project yet?** → Use `mcp-csharp-create`
- **Publishing a non-MCP NuGet package?** → Use `nuget-trusted-publishing` instead

## Inputs

| Input | Required | Description |
|-------|----------|-------------|
| Transport type | Yes | `stdio` → NuGet path, `http` → Docker/Azure path |
| Target destination | Yes | NuGet.org, Docker registry, Azure Container Apps, Azure App Service, MCP Registry |
| Project path | Yes | Path to the `.csproj` file |
| Package ID / server name | Required for publishing | NuGet `PackageId` or MCP Registry name |

## Workflow

### Step 1: Choose the publishing path

| Transport | Primary Destination | Users Run With |
|-----------|-------------------|----------------|
| **stdio** | NuGet.org | `dnx YourPackage@version` |
| **HTTP** | Docker → Azure | Container URL |

Both paths can optionally publish to the MCP Registry for discoverability.

### Step 2a: NuGet publishing (stdio servers)

1. **Configure `.csproj`** with package properties:
```xml

  true
  mymcpserver
  YourUsername.MyMcpServer
  1.0.0
  Your Name
  MCP server for interacting with MyService
  MIT
  mcp;modelcontextprotocol;ai;llm
  README.md

  

```

2. **Build and pack:**
```bash
dotnet build -c Release
dotnet pack -c Release
```

3. **Test locally before publishing:**
```bash
dotnet tool install --global --add-source bin/Release/ YourUsername.MyMcpServer
mymcpserver --help          # verify it runs
dotnet tool uninstall --global YourUsername.MyMcpServer
```

4. **Push to NuGet.org:**
```bash
dotnet nuget push bin/Release/*.nupkg \
  --api-key YOUR_NUGET_API_KEY \
  --source https://api.nuget.org/v3/index.json
```

5. **Verify** — users configure in `mcp.json`:
```json
{
  "servers": {
    "MyMcpServer": {
      "type": "stdio",
      "command": "dnx",
      "args": ["YourUsername.MyMcpServer@1.0.0", "--yes"]
    }
  }
}
```

**For detailed NuGet packaging and trusted publishing setup**, see [references/nuget-packaging.md](references/nuget-packaging.md).

### Step 2b: Docker containerization (HTTP servers)

1. **Create Dockerfile:**
```dockerfile
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY *.csproj ./
RUN dotnet restore
COPY . ./
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:10.0
WORKDIR /app
COPY --from=build /app .

# Non-root user for security
RUN adduser --disabled-password --gecos '' appuser
USER appuser

ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1
ENTRYPOINT ["dotnet", "MyMcpServer.dll"]
```

2. **Build and test locally:**
```bash
docker build -t mymcpserver:latest .
docker run -d -p 3001:8080 -e API_KEY=test-key --name mymcpserver mymcpserver:latest
curl http://localhost:3001/health
```

3. **Push to container registry:**
```bash
# Docker Hub
docker tag mymcpserver:latest /:1.0.0
docker push /:1.0.0

# Azure Container Registry
az acr login --name yourregistry
docker tag mymcpserver:latest .azurecr.io/:1.0.0
docker push .azurecr.io/:1.0.0
```

### Step 3: Deploy to Azure (HTTP servers)

**Azure Container Apps** (recommended — serverless with auto-scaling):
```bash
az containerapp create \
  --name mymcpserver \
  --resource-group mygroup \
  --environment myenvironment \
  --image .azurecr.io/:1.0.0 \
  --target-port 8080 \
  --ingress external \
  --min-replicas 0 \
  --max-replicas 10 \
  --secrets api-key=my-actual-api-key \
  --env-vars API_KEY=secretref:api-key
```

**Azure App Service** (traditional web hosting):
```bash
az webapp create \
  --name mymcpserver \
  --resource-group mygroup \
  --plan myplan \
  --deployment-container-image-name .azurecr.io/:1.0.0
```

**For detailed Azure deployment**, see [references/docker-azure.md](references/docker-azure.md).

### Step 4: Publish to MCP Registry (optional)

List your server in the official MCP Registry for discoverability.

1. **Install `mcp-publisher`:**
```bash
# macOS/Linux
brew install mcp-publisher

# Or download from https://github.com/modelcontextprotocol/registry/releases
```

2. **Create `.mcp/server.json`** (or run `mcp-publisher init` to generate interactively):
```json
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "io.github.username/servername",
  "description": "Your server description",
  "version": "1.0.0",
  "packages": [{
    "registryType": "nuget",
    "registryBaseUrl": "https://api.nuget.org",
    "identifier": "YourUsername.MyMcpServer",
    "version": "1.0.0",
    "transport": { "type": "stdio" }
  }],
  "repository": {
    "url": "https://github.com/username/repo",
    "source": "github"
  }
}
```

> **Version consistency (critical):** The root `version`, `packages[].version`, and `` in `.csproj` **must all match**. A mismatch causes registry validation failures or users downloading the wrong version.

3. **Authenticate and publish:**
```bash
mcp-publisher login github      # name must be io.github./... for GitHub auth
mcp-publisher publish
```

4. **Verify:**
```bash
curl "https://registry.modelcontextprotocol.io/v0.1/servers?search=io.github./"
```

**For Registry details** (namespace conventions, environment variables, CI/CD automation), see [references/mcp-registry.md](references/mcp-registry.md).

### Step 5: Security checklist

- [ ] No hardcoded secrets — use environment variables or Key Vault
- [ ] HTTPS enabled for HTTP transport in production
- [ ] Health check endpoint implemented
- [ ] Input validation on all tool parameters
- [ ] Rate limiting considered for HTTP servers

## Validation

- [ ] **NuGet:** Package installs and runs via `dnx PackageId@version`
- [ ] **Docker:** Container starts and health check passes
- [ ] **Azure:** Server is reachable and tools respond
- [ ] **MCP Registry:** Server appears at `registry.modelcontextprotocol.io`
- [ ] MCP client can connect and call tools on the deployed server

## Common Pitfalls

| Pitfall | Solution |
|---------|----------|
| NuGet package doesn't run as a tool | Missing `true` in `.csproj` |
| Version mismatch between `.csproj` and `server.json` | Keep ``, `server.json` root `version`, and `packages[].version` in sync |
| Docker container exits immediately | Check entrypoint DLL name matches project output. Run `docker logs mymcpserver` for errors |
| Azure Container App returns 502 | Target port mismatch. Ensure `--target-port` matches `ASPNETCORE_URLS` port in the container |
| MCP Registry rejects publish | Name must follow namespace convention: `io.github./` for GitHub auth |
| API keys leaked in Docker image | Use multi-stage builds. Never `COPY` `.env` files. Pass secrets via `--env-vars` at runtime |

## Related Skills

- `mcp-csharp-create` — Create a new MCP server project
- `mcp-csharp-debug` — Running and interactive debugging
- `mcp-csharp-test` — Automated tests and evaluations

## Reference Files

- [references/nuget-packaging.md](references/nuget-packaging.md) — Complete NuGet `.csproj` configuration, `server.json` for MCP, NuGet.org push, testing with `dnx`, version management. **Load when:** publishing a stdio server to NuGet.
- [references/docker-azure.md](references/docker-azure.md) — Production Dockerfile patterns, ACR setup, Azure Container Apps full configuration, App Service with Key Vault, secrets management. **Load when:** deploying an HTTP server to Docker or Azure.
- [references/mcp-registry.md](references/mcp-registry.md) — `mcp-publisher` CLI installation, `server.json` schema, namespace conventions (GitHub vs DNS auth), CI/CD automation. **Load when:** publishing to the official MCP Registry.

## More Info

- [NuGet publishing](https://learn.microsoft.com/nuget/nuget-org/publish-a-package) — NuGet.org publishing guide
- [Azure Container Apps](https://learn.microsoft.com/azure/container-apps/) — Serverless container hosting
- [MCP Registry](https://registry.modelcontextprotocol.io) — Official MCP server registry

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [dotnet](https://github.com/dotnet)
- **Source:** [dotnet/skills](https://github.com/dotnet/skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-dotnet-skills-mcp-csharp-publish
- Seller: https://agentstack.voostack.com/s/dotnet
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.