# Option 1: Scaffold automatically
npx @modelcontextprotocol/create-server my-mcp-server
cd my-mcp-server && npm install

# Option 2: Manual
mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod@3
npm install -D @types/node typescript

{
  "type": "module",
  "bin": { "my-mcp-server": "./build/index.js" },
  "scripts": { "build": "tsc && chmod 755 build/index.js" }
}

uv init my-mcp-server
cd my-mcp-server
uv venv && source .venv/bin/activate
uv add "mcp[cli]" httpx

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "my-server",
  version: "1.0.0",
});

// Register tools here

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server running on stdio");
}

main().catch((error) => {
  console.error("Fatal error:", error);
  process.exit(1);
});

# server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

# Register tools here

if __name__ == "__main__":
    mcp.run(transport="stdio")

// Basic tool
server.registerTool("greet", {
  description: "Greet someone by name",
  inputSchema: {
    name: z.string().describe("Person's name"),
  },
}, async ({ name }) => ({
  content: [{ type: "text", text: `Hello, ${name}!` }],
}));

// Tool with structured output
server.registerTool("add", {
  description: "Add two numbers",
  inputSchema: { a: z.number(), b: z.number() },
  outputSchema: z.object({ result: z.number() }),
}, async ({ a, b }) => ({
  content: [{ type: "text", text: JSON.stringify({ result: a + b }) }],
  structuredContent: { result: a + b },
}));

// Tool with annotations
server.registerTool("search", {
  description: "Search the database",
  inputSchema: { query: z.string() },
  annotations: {
    readOnlyHint: true,
    destructiveHint: false,
    idempotentHint: true,
  },
}, async ({ query }) => ({
  content: [{ type: "text", text: `Results for: ${query}` }],
}));

# Basic tool
@mcp.tool()
async def greet(name: str) -> str:
    '''Greet someone by name.

    Args:
        name: Person's name
    '''
    return f"Hello, {name}!"

# Tool with structured output
from pydantic import BaseModel, Field

class AddResult(BaseModel):
    result: float = Field(description="Sum of the two numbers")

@mcp.tool()
async def add(a: float, b: float) -> AddResult:
    '''Add two numbers.

    Args:
        a: First number
        b: Second number
    '''
    return AddResult(result=a + b)

// Static resource
server.registerResource(
  "config", "config://app",
  { mimeType: "text/plain" },
  async (uri) => ({
    contents: [{ uri: uri.href, text: "key=value
env=production" }],
  })
);

// Prompt template
server.registerPrompt("review-code", {
  title: "Code Review",
  argsSchema: z.object({
    code: z.string(),
    language: z.string().optional(),
  }),
}, ({ code, language }) => ({
  messages: [{
    role: "user",
    content: { type: "text", text: `Review this ${language || ""} code:

${code}` },
  }],
}));

@mcp.resource("config://app")
def get_config() -> str:
    '''Application configuration.'''
    return "key=value
env=production"

@mcp.prompt()
def review_code(code: str, language: str = "python") -> str:
    '''Review code for quality issues.'''
    return f"Review this {language} code:

{code}"