How to Build an MCP Server in Under 10 Minutes

Introduction: Why Build Your Own MCP Server?

The Model Context Protocol (MCP) has fundamentally changed how AI agents interact with external tools and data sources. Instead of relying on rigid, platform-specific integrations, MCP provides a universal standard that lets any AI agent — whether powered by Claude, GPT, Gemini, or open-source models — connect to your tools seamlessly.

Building your own MCP server might sound intimidating, but the reality is surprisingly approachable. In this tutorial, we will walk through the entire process of creating a functional MCP server from scratch in under ten minutes. By the end, you will have a working server that you can publish to MCPlug and share with the entire AI agent ecosystem.

Prerequisites

Before we begin, make sure you have the following installed on your system:

• Node.js 18 or later — MCP servers run on modern JavaScript runtimes.
• npm or yarn — For managing dependencies.
• A text editor or IDE — VS Code, Cursor, or any editor you prefer.
• Basic TypeScript knowledge — We will write our server in TypeScript for type safety.

Step 1: Initialize Your Project

Open your terminal and create a new directory for your MCP server. We will build a simple weather lookup tool as our example.

mkdir mcp-weather-server
cd mcp-weather-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

Next, create a tsconfig.json file:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"]
}

Step 2: Define Your MCP Server

Create a src/index.ts file. This is where all the magic happens. An MCP server exposes tools that AI agents can discover and invoke at runtime.

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-server",
  version: "1.0.0",
});

server.tool(
  "get-weather",
  "Get the current weather for a given city",
  {
    city: z.string().describe("The city name to look up"),
    units: z.enum(["celsius", "fahrenheit"]).optional()
      .describe("Temperature units, defaults to celsius"),
  },
  async ({ city, units }) => {
    const unitSystem = units || "celsius";
    // In production, call a real weather API here
    const weatherData = await fetchWeather(city, unitSystem);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(weatherData, null, 2),
        },
      ],
    };
  }
);

async function fetchWeather(city: string, units: string) {
  // Replace this with a real API call
  return {
    city,
    temperature: units === "celsius" ? 22 : 72,
    units,
    condition: "Partly cloudy",
    humidity: 65,
    windSpeed: "12 km/h",
  };
}

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

main().catch(console.error);

Understanding the Code

Let us break down the key parts of this server:

• McpServer — The core class from the MCP SDK that manages tool registration, protocol handshakes, and message routing.
• server.tool() — Registers a new tool with a name, description, input schema (using Zod for validation), and a handler function.
• StdioServerTransport — Uses standard input/output for communication, which is the most common transport for local MCP servers.
• Zod schemas — Define the expected input parameters with full type safety and validation.

Step 3: Add Multiple Tools

A great MCP server usually exposes more than one tool. Let us add a forecast tool to complement our weather lookup:

server.tool(
  "get-forecast",
  "Get a 5-day weather forecast for a city",
  {
    city: z.string().describe("The city name"),
    days: z.number().min(1).max(7).optional()
      .describe("Number of days, 1-7, defaults to 5"),
  },
  async ({ city, days }) => {
    const numDays = days || 5;
    const forecast = Array.from({ length: numDays }, (_, i) => ({
      day: i + 1,
      high: Math.round(18 + Math.random() * 10),
      low: Math.round(8 + Math.random() * 8),
      condition: ["Sunny", "Cloudy", "Rainy", "Partly cloudy"][
        Math.floor(Math.random() * 4)
      ],
    }));
    return {
      content: [{ type: "text", text: JSON.stringify({ city, forecast }, null, 2) }],
    };
  }
);

Step 4: Test Your Server Locally

Before publishing, test your server to make sure it works correctly. Add a script to your package.json:

{
  "scripts": {
    "start": "tsx src/index.ts",
    "build": "tsc"
  }
}

You can test the server with any MCP-compatible client. If you use Claude Desktop, add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "weather": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-weather-server/src/index.ts"]
    }
  }
}

Restart Claude Desktop, and you should see the weather tools available in your conversation. Ask Claude to check the weather in Tokyo, and watch as it invokes your MCP server in real time.

Step 5: Add Error Handling and Logging

Production-quality MCP servers need robust error handling. Here is a pattern that works well:

server.tool(
  "get-weather",
  "Get the current weather for a given city",
  { city: z.string(), units: z.enum(["celsius", "fahrenheit"]).optional() },
  async ({ city, units }) => {
    try {
      const data = await fetchWeather(city, units || "celsius");
      return {
        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error fetching weather for ${city}: ${error instanceof Error ? error.message : "Unknown error"}`,
          },
        ],
        isError: true,
      };
    }
  }
);

The isError: true flag tells the AI agent that the tool call failed, so it can retry or inform the user appropriately.

Step 6: Publish to MCPlug

Once your MCP server is tested and working, the next step is to share it with the world. MCPlug's publishing platform makes this straightforward. Package your server as an npm package or a standalone binary, write a clear description of what your tools do, and submit it through the MCPlug publisher portal.

Thousands of AI agent users browse the MCPlug marketplace daily looking for tools exactly like yours. Whether you want to offer your server for free or set a price, MCPlug handles distribution, discovery, and payments for you.

Advanced Tips

Using Resources and Prompts

MCP servers can expose more than just tools. The protocol also supports resources (data that agents can read) and prompts (reusable prompt templates). These features let you build richer integrations that go beyond simple function calls.

Adding Authentication

If your MCP server accesses private APIs or user-specific data, you will want to implement authentication. The MCP SDK supports passing configuration through environment variables, which is the recommended approach for API keys and tokens.

Performance Optimization

For servers that make external API calls, consider implementing caching to reduce latency and API costs. A simple in-memory cache with a TTL of a few minutes can dramatically improve the user experience.

Conclusion

Building an MCP server is one of the highest-leverage activities you can do as a developer in the AI ecosystem. In under ten minutes, you have gone from an empty directory to a fully functional tool server that any MCP-compatible AI agent can use. The protocol handles all the complexity of discovery, schema negotiation, and communication — you just focus on the logic that makes your tool useful.

The MCP ecosystem is growing rapidly, and there is enormous demand for high-quality tools. Whether you are building internal tools for your team or creating products for the broader community, MCP gives you a universal standard that works across all major AI platforms.

Ready to share your creation? Publish your MCP server on MCPlug and start reaching AI agent users today. Or explore the marketplace to see what others have built for inspiration.