MCP Server Development Guide
A practical guide to building clear, testable MCP servers that let LLMs work with external APIs.
The documentation covers authentication, input validation, tool annotations, approvals, sensitive data, and error handling, and recommends scoped permissions and approval for remote or destructive operations. It does not provide a concrete server implementation, universally enforced confirmation, complete data-flow disclosure, rollback guidance, or dependency-risk verification, so points are deducted.
The workflow is coherent and includes implementation, testing, pagination, and error-feedback guidance. However, the evidence consists of examples and recommendations rather than a target implementation, committed test suite, or reproducible build evidence; examples also rely on potentially version-sensitive APIs, so points are deducted.
The audience is clear: developers building MCP servers, with coverage for Python, TypeScript, C#/.NET, stdio, and HTTP scenarios. Non-fit boundaries, precise trigger conditions, Chinese-language support, and mainland-China reachability are not established, and some core documentation and services depend on overseas endpoints, so points are deducted.
The material has layered overviews, phased workflow guidance, language-specific references, best practices, evaluation guidance, and many examples. The supplied metadata identifies an MIT license and Microsoft provenance, but the skill lacks an explicit versioning policy, changelog, maintenance owner, update path, and centralized disclosure of assumptions, so points are deducted.
The guide can directly support planning, tool design, authentication, error handling, and evaluation creation, and its examples are potentially useful. Static review provides no execution validation; the evaluation requirements may be disproportionately complex and explicitly permit questions unsolvable by the server, so direct usability and cost-benefit remain uncertain and points are deducted.
Specific commands, code patterns, checklists, and test structures provide some auditability. There is no committed CI, test result, third-party execution record, or independent corroboration in the supplied skill evidence; conclusions therefore rely mainly on documentation claims, so points are deducted.
- This is a low-confidence static review; no examples, builds, or tests were executed.
- Before deploying a remote MCP server, add explicit evidence for least privilege, mandatory approval, sensitive-data flows, credential handling, rollback, and dependency pinning.
- The evaluation guidance requires complex, many-call questions and permits questions beyond server capability, which may increase cost and reduce verifiability; define capability boundaries first.
- Overseas documentation sites, package registries, and Azure services referenced by the guide may affect usability from mainland-China networks.
What does this skill do, and when should you use it?
This software-development skill guides the creation of MCP servers in Python, Node/TypeScript, and C#/.NET. It covers the full path from protocol, SDK, and API research through implementation, testing, and evaluation. Its recommendations address tool naming, schemas, pagination, actionable errors, and tool annotations. It also helps developers decide whether to reuse Microsoft MCP infrastructure or build a custom server for an internal API or third-party SaaS.
It directs developers to review MCP specifications, language SDKs, and service API documentation; choose stdio or Streamable HTTP; plan endpoint coverage and workflow tools; implement shared authentication, error handling, response formatting, and pagination; define tool schemas with Zod, Pydantic, or the corresponding .NET patterns; add read-only, destructive, idempotent, and open-world annotations; run TypeScript builds, Python syntax checks, and MCP Inspector tests; and create 10 read-only, complex, verifiable XML evaluation questions.
- A developer integrating a third-party SaaS needs an MCP interface that lets an LLM call the service API.
- An engineering team exposing an internal API needs guidance on authentication, pagination, and actionable tool errors.
- An Azure developer must choose between Azure MCP, Foundry MCP, and a custom server.
- An engineer building an MCP integration in TypeScript, Python, or C#/.NET needs an implementation and testing workflow.
What are this skill's strengths and limitations?
- Supports TypeScript, Python, and C#/.NET implementation paths.
- Covers tool design, shared infrastructure, testing, and evaluation rather than only code generation.
- Clearly identifies when to prefer Azure, Foundry, Fabric, Playwright, or GitHub MCP servers.
- Provides concrete quality requirements for schemas, pagination, errors, and tool annotations.
- It relies on external MCP, SDK, and service API documentation, so offline use is limited.
- The referenced guide files are not included in the supplied SKILL.md, leaving some implementation details to be loaded separately.
- It does not include one complete, directly runnable end-to-end server example.
- No test results are provided for every language, client, or target API.
How do you install this skill?
Run npx skills add microsoft/skills in your project and select mcp-builder in the installation wizard. The README says skills are installed in the selected agent's directory, such as .github/skills/ for GitHub Copilot. The repository is licensed under MIT.
How do you use this skill?
In a coding agent with the skill installed, provide a request such as: “Design and implement an MCP server for my third-party API in TypeScript, including authentication, pagination, structured output, error handling, and evaluation tests.” The guide organizes the work into research, implementation, review/testing, and evaluation; service-specific API, permission, and deployment details must be supplied separately.
How does this skill compare with similar options?
Compared with Microsoft’s existing Azure MCP, Foundry MCP, Fabric MCP, Playwright MCP, and GitHub MCP servers, this guide is better suited to custom internal APIs and third-party SaaS integrations. When an existing Microsoft server already covers the target capability, the guide recommends reusing it.