Build an MCP Server From Scratch

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: "weather", version: "1.0.0" });
 
server.registerTool(
  "get_alerts",
  {
    description: "Get weather alerts for a US state",
    // inputSchema is a MAP of Zod schemas, not a wrapped object
    inputSchema: {
      state: z.string().length(2).describe("Two-letter state code (e.g. CA, NY)"),
    },
  },
  async ({ state }) => {
    // ...do real work here (call an API, read a file)...
    return { content: [{ type: "text", text: `Active alerts for ${state}` }] };
  },
);
 
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  // stderr, NEVER stdout — stdout is the JSON-RPC channel
  console.error("Weather MCP Server running on stdio");
}
 
main().catch((e) => {
  console.error(e);
  process.exit(1);
});

import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
// Direct (fixed-URI) resource
server.registerResource(
  "config",
  "config://app",
  { title: "Application Config", description: "App configuration", mimeType: "text/plain" },
  async (uri) => ({
    contents: [{ uri: uri.href, text: "App configuration here" }],
  }),
);
 
// Dynamic resource via a URI template
server.registerResource(
  "user-profile",
  new ResourceTemplate("users://{userId}/profile", { list: undefined }),
  { title: "User Profile", mimeType: "application/json" },
  async (uri, { userId }) => ({
    contents: [{ uri: uri.href, text: JSON.stringify(await getUser(userId)) }],
  }),
);
 
// Prompt with an argument schema (surfaces as a slash command in hosts)
server.registerPrompt(
  "review-code",
  { title: "Code Review", description: "Review code for best practices", argsSchema: { code: z.string() } },
  ({ code }) => ({
    messages: [
      { role: "user", content: { type: "text", text: `Please review this code:\n\n${code}` } },
    ],
  }),
);

import sys
from mcp.server.fastmcp import FastMCP
 
mcp = FastMCP("weather")
 
@mcp.tool()
async def get_alerts(state: str) -> str:
    """Get weather alerts for a US state.
 
    Args:
        state: Two-letter US state code (e.g. CA, NY)
    """
    # ...do real work...
    return f"Active alerts for {state}"
 
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"
 
@mcp.prompt()
def greet_user(name: str, style: str = "friendly") -> str:
    """Generate a greeting prompt"""
    return f"Please write a {style} greeting for {name}."
 
def main():
    # log to stderr — never print() to stdout on a stdio server
    print("Weather MCP Server running on stdio", file=sys.stderr)
    mcp.run(transport="stdio")   # switch to "streamable-http" for remote
 
if __name__ == "__main__":
    main()

{
  "mcpServers": {
    "weather": {
      "command": "node",
      "args": ["build/index.js"],
      "env": { "API_KEY": "$MY_API_TOKEN" },
      "cwd": "./server-dir",
      "timeout": 30000,
      "trust": false
    }
  }
}