Microsoft.TemplateEngine.MCP

An MCP server that lets AI agents work with dotnet new templates — search, inspect, preview, and create projects through natural conversation instead of memorizing CLI flags.

Instead of this:

dotnet new list --language C#
dotnet new webapi --help
dotnet new webapi --auth Individual --use-controllers --name MyApi --output ./MyApi

Your AI agent just says: "I need a web API with authentication and controllers" — and the MCP server figures out the rest.

Tools

Tool	What it does
`template_search`	Search locally and on NuGet.org — one call, ranked results
`template_list`	List what's installed, filter by language/type/classification
`template_inspect`	Parameters, constraints, post-actions — all in one shot
`template_instantiate`	Create a project. Not installed? Auto-resolves from NuGet. Elicits missing params interactively
`template_dry_run`	Preview files without touching disk
`template_install`	Install a package (idempotent — skips if already there)
`template_uninstall`	Remove a template package
`templates_installed`	Inventory of everything installed
`template_from_intent`	"web API with auth" → webapi + `auth=Individual` — no LLM needed
`template_create_from_existing`	Analyze a .csproj → generate a reusable template matching repo conventions
`template_compose`	Execute a sequence of templates (project + items) in one workflow
`template_suggest_parameters`	Suggest parameter values with rationale based on cross-parameter relationships
`template_validate`	Validate a local template directory for authoring issues before publishing
`solution_analyze`	Analyze a solution/workspace — project structure, frameworks, CPM status

📖 Full tool reference →

Quick Start

Zero-install with `dnx` (.NET 10+)

dnx -y DotnetTemplateMCP --version 1.1.0

Global tool

dotnet tool install --global DotnetTemplateMCP --version 1.1.0

VS Code / GitHub Copilot

Add to mcp.json:

{
  "servers": {
    "dotnet-templates": {
      "type": "stdio",
      "command": "dnx",
      "args": ["-y", "DotnetTemplateMCP", "--version", "1.1.0"]
    }
  }
}

📖 Claude Desktop, Cursor, and more →

Transport Modes

Stdio (default)

Standard I/O transport for local CLI and tool usage:

template-engine-mcp                     # stdio is the default
template-engine-mcp --transport stdio   # explicit

HTTP (remote / cloud / team-shared)

Streamable HTTP transport for remote, multi-tenant, or CI/CD deployment:

template-engine-mcp --transport http
# or via environment variable:
MCP_TEMPLATE_TRANSPORT=http template-engine-mcp

The HTTP server exposes:

/mcp — MCP streamable HTTP endpoint
/health — Health check endpoint

Configure the listen URL:

MCP_TEMPLATE_HTTP_URL=http://0.0.0.0:8080 template-engine-mcp --transport http

Connect your MCP client:

{
  "servers": {
    "dotnet-templates": {
      "type": "http",
      "url": "http://localhost:5005/mcp"
    }
  }
}

Interactive Elicitation

When a template has required parameters that weren't provided, the server asks the user interactively via MCP elicitation — instead of failing. Template parameter types are mapped to form fields:

Template Parameter	Elicitation Field
`string`	Text input
`bool` / `boolean`	Checkbox
`int` / `number`	Number input
Choice parameter	Single-select dropdown

Disable with MCP_TEMPLATE_ELICITATION=false.

How it works

You: "I need a web API with authentication, controllers, and Docker support"

→ template_from_intent extracts keywords: web api, authentication, controllers, docker
→ Matches: webapi (confidence: 0.85)
→ Resolves: auth=Individual, UseControllers=true, EnableDocker=true
→ template_instantiate creates the project

The server also does smart defaults (AOT → latest framework, auth → HTTPS stays on), parameter validation before writing files, constraint checking (OS, SDK, workload), interactive elicitation of missing required parameters, and auto-resolves templates from NuGet if they're not installed.

CPM & Latest Package Versions

When creating a project inside a solution that uses Central Package Management, the server automatically:

Detects Directory.Packages.props by walking up the directory tree
Strips Version attributes from generated .csproj PackageReferences
Adds missing <PackageVersion> entries to Directory.Packages.props
Resolves latest stable NuGet versions — no more stale hardcoded versions from templates

Before (what dotnet new generates):
  <PackageReference Include="Serilog" Version="3.1.0" />    ← stale, breaks CPM

After (what template_instantiate produces):
  .csproj:                    <PackageReference Include="Serilog" />
  Directory.Packages.props:   <PackageVersion Include="Serilog" Version="4.2.0" />

Works for standalone projects too — versions are updated directly in the .csproj.

Multi-Template Composition

Chain multiple templates in one call with template_compose:

[
  {"templateName": "webapi", "name": "MyApi", "parametersJson": "{\"auth\": \"Individual\"}"},
  {"templateName": "gitignore", "target": "."}
]

📖 Architecture & smart behaviors →

Tool Profiles (Lite vs Full)

By default, all 13 tools are available. If your agent works better with fewer tools, set the MCP_TEMPLATE_TOOL_PROFILE environment variable:

Profile	Tools	When to use
`full` (default)	All 13 tools	Full control — advanced workflows, composition, custom templates
`lite`	5 core tools	Simpler agents that just need to find and create projects

Lite profile tools: template_from_intent, template_instantiate, template_inspect, template_search, template_dry_run

{
  "servers": {
    "dotnet-template-mcp": {
      "command": "dotnet-template-mcp",
      "env": {
        "MCP_TEMPLATE_TOOL_PROFILE": "lite"
      }
    }
  }
}

Non-lite tools will return a helpful message explaining they're disabled and how to enable them.

Documentation

Doc	What's in it
Configuration	VS Code, Claude Desktop, Cursor setup + troubleshooting
Tool Reference	Every tool's parameters, types, and examples
Architecture	Template cache, smart behaviors, telemetry, project structure
MCP vs Skills	Why MCP over Copilot Skills — benefits and downsides
Plain LLM vs MCP	Side-by-side: what a plain LLM does vs. the MCP tool (4 scenarios)
Skills Equivalent	What it'd take to cover this with Skills instead

Building & Testing

dotnet build
dotnet test    # 185+ tests — unit, integration, and E2E

CI runs on push/PR via GitHub Actions (Ubuntu + Windows).

Contributing

Contributions are welcome! Please open an issue to discuss proposed changes before submitting a PR.

# Setup
dotnet restore
dotnet build

# Run tests
dotnet test

# Pack locally
dotnet pack src/Microsoft.TemplateEngine.MCP -o nupkg/

Changelog

See CHANGELOG.md for release history.

License

MIT

dotnet-template-mcp