How to Build an MCP Server in TypeScript & Python: Production Guide (2026)

mkdir my-mcp-server-ts
cd my-mcp-server-ts
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx
npx tsc --init

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

// Initialize server metadata
const server = new Server(
  {
    name: "company-architecture-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      resources: {},
      tools: {},
    },
  }
);

// 1. Define a Resource (Read-only service directory)
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: "architecture://services/directory",
        name: "Microservices Directory",
        mimeType: "application/json",
        description: "List of active production microservices and their owners",
      },
    ],
  };
});

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  if (request.params.uri === "architecture://services/directory") {
    const services = [
      { name: "Auth-Service", port: 8080, owner: "Security Team" },
      { name: "Payment-Worker", port: 9020, owner: "Billing Team" },
    ];
    return {
      contents: [
        {
          uri: request.params.uri,
          mimeType: "application/json",
          text: JSON.stringify(services, null, 2),
        },
      ],
    };
  }
  throw new Error("Resource not found");
});

// 2. Define a Tool (Executable architecture search)
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "query_service_history",
        description: "Retrieve past architectural trade-offs and decisions for a given microservice",
        inputSchema: {
          type: "object",
          properties: {
            serviceName: {
              type: "string",
              description: "The name of the service (e.g., Auth-Service, Payment-Worker)",
            },
          },
          required: ["serviceName"],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "query_service_history") {
    const serviceName = String(request.params.arguments?.serviceName);

    // Mock response simulating an organizational memory lookup
    const history = {
      service: serviceName,
      lastDecision: "Migrated from REST to gRPC in May 2026",
      owner: "Alex Torres",
      linkedPR: "github.com/company/repo/pull/412",
    };

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(history, null, 2),
        },
      ],
    };
  }
  throw new Error("Tool not found");
});

// 3. Connect via Standard Input/Output (stdio)
async function run() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Architecture MCP Server running on stdio");
}

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

mkdir my-mcp-server-py
cd my-mcp-server-py
python -m venv .venv
source .venv/bin/activate  # Or on Windows: .venv\Scripts\activate
pip install mcp

from mcp.server.fastmcp import FastMCP

# Initialize FastMCP Server
mcp = FastMCP("Enterprise-Memory-Server")

# 1. Define a Resource
@mcp.resource("config://production/limits")
def get_limits() -> str:
    """Returns production rate limits and timeout thresholds."""
    return """
    {
      "global_rate_limit_rps": 5000,
      "database_timeout_ms": 250,
      "max_payload_size_mb": 10
    }
    """

# 2. Define a Tool
@mcp.tool()
def search_code_decisions(service: str, query: str) -> str:
    """
    Search historical architectural decisions for a service.
    
    Args:
        service: Microservice identifier
        query: Specific technical question or topic
    """
    # In production, query Memora's Knowledge Graph here
    return f"Service '{service}' records indicate '{query}' was resolved in ADR-48 with AES-256 encryption."

# 3. Define a Prompt Template
@mcp.prompt()
def review_architecture(service: str) -> str:
    """Pre-loads service context into the conversation."""
    return f"Please review the following proposed architectural change for {service}, taking into account all historical ADRs."

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

{
  "mcpServers": {
    "my-python-server": {
      "command": "python",
      "args": ["C:/path/to/my-mcp-server-py/server.py"]
    }
  }
}