What are the four phases of MCP server development covered in this guide?

The four phases are: (1) Research and Planning—studying the MCP spec and target service API to design tools; (2) Implementation—building the project structure, shared infrastructure, and individual tools with validated schemas; (3) Review and Test—checking code quality, type coverage, and testing with the MCP Inspector; and (4) Evaluations—creating 10 independent, read-only test questions to verify the server works for realistic tasks.

Should I use TypeScript or Python for building an MCP server?

TypeScript is recommended as the primary language due to strong SDK support, good fit for AI code generation, and static typing. Python is recommended as a fallback where needed, with both languages having language-specific implementation guides and tools available.

What tools and resources does this guide provide for testing an MCP server?

The guide includes the MCP Inspector tool (`npx @modelcontextprotocol/inspector`) for interactive testing, language-specific build verification commands (`npm run build` for TypeScript, `python -m py_compile` for Python), and reference documentation covering naming conventions, transport selection, and evaluation creation.

What should evaluation questions for an MCP server test?

Evaluation questions should be independent, read-only, complex (requiring multiple tool calls), realistic, verifiable by exact string comparison, and stable over time. They test whether an LLM can effectively use the server by inspecting available tools, exploring content, generating questions, and verifying answers manually.

Skill

Develop LLM-Integrated Service Servers

Name: MCP Server Development Guide
Availability: OnlineOnly
Author: Antigravity

Four-phase guide for building high-quality MCP servers: research/design, TypeScript/Python implementation, testing, and evaluations.

Get skill

Works with github

Antigravity

Own this? Claim it

Spark score

out of 100

Updated last month

Version 13.1.0

Models

universal

Add to Favorites

Why it matters

Build robust MCP servers that empower Large Language Models to interact with external services, enabling them to perform real-world tasks through well-defined tools and protocols.

Outcomes

What it gets done

Design and implement MCP server infrastructure using TypeScript or Python.

Define clear tool schemas, descriptions, and actionable error messages for LLM interaction.

Develop comprehensive evaluations to test LLM's ability to utilize the MCP server.

Ensure code quality, testability, and adherence to MCP best practices.

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-mcp-builder | bash

Overview

MCP Server Development Guide

A four-phase guide for building high-quality MCP servers - research and tool design, TypeScript/Python implementation with schema validation and behavior annotations, testing with MCP Inspector, and creating verifiable evaluation questions to measure real-world LLM task performance. Use when building a new MCP server or improving an existing one's tool design, implementation quality, or evaluation coverage.

What it does

Guides the creation of MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools, measuring server quality by how well it enables LLMs to accomplish real-world tasks, across four phases: research and planning, implementation, review/testing, and evaluation creation.

When to use - and when NOT to

Use this skill when building a new MCP server or improving an existing one's tool design, quality, or test coverage.

Inputs and outputs

Phase 1, Research and Planning: covers modern MCP design tradeoffs (balancing comprehensive API coverage against specialized workflow tools, defaulting to comprehensive coverage when uncertain), tool naming conventions (consistent action-oriented prefixes like github_create_issue), context management (concise descriptions, filtering/pagination), and actionable error messages. It directs studying the MCP spec via its sitemap (modelcontextprotocol.io/sitemap.xml, fetching pages with a .md suffix) and recommends TypeScript as the primary language (strong SDK support, good AI-code-generation fit, static typing) with streamable HTTP transport for remote servers (stateless JSON, simpler to scale) or stdio for local servers, falling back to Python where needed. Planning also means reviewing the target service's own API docs to prioritize which endpoints to implement first.

Phase 2, Implementation: sets up the project structure per language-specific guides, builds shared infrastructure (authenticated API client, error handling helpers, JSON/Markdown response formatting, pagination support), then implements each tool with a validated input schema (Zod for TypeScript, Pydantic for Python, with constraints and field-level examples), an outputSchema and structuredContent for structured responses, a concise tool description, async I/O with actionable error handling, and behavior annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint).

Phase 3, Review and Test: checks for DRY code, consistent error handling, full type coverage, and clear tool descriptions, then verifies compilation/syntax (npm run build for TypeScript, python -m py_compile for Python) and tests interactively with the MCP Inspector (npx @modelcontextprotocol/inspector).

Phase 4, Evaluations: creates 10 evaluation questions to test whether an LLM can effectively use the server for realistic, complex tasks - inspecting available tools, exploring content via read-only operations, generating questions, and verifying each answer manually. Each question must be independent, read-only, complex (requiring multiple tool calls), realistic, verifiable by exact string comparison, and stable over time, packaged into an XML <evaluation> file with <qa_pair> question/answer entries.

Integrations

Built on the official MCP specification and SDKs (TypeScript SDK, Python SDK), with a documentation library of reference guides (mcp_best_practices.md, node_mcp_server.md, python_mcp_server.md, evaluation.md) covering naming conventions, transport selection, framework-specific implementation patterns, and evaluation creation, plus the MCP Inspector tool for interactive testing.

Who it's for

Developers building MCP servers who want a structured path from API research through tool implementation to rigorous evaluation - covering both TypeScript and Python stacks - rather than assembling MCP server conventions from scratch.

FAQ

Common questions

Discussion