MCP Test Server

A Model Context Protocol (MCP) server implementation with multiple tools for testing and demonstration purposes.

Overview

This server provides three main tools:

• BMI Calculator: Calculate Body Mass Index from weight and height
• Weather Service: Get weather information for any city (with API key support)
• Echo Tool: Simple echo functionality for testing

Features

• Built with TypeScript and Express.js
• Streamable HTTP transport for MCP
• Environment-based configuration
• Hot reload development support
• Modular tool architecture

Prerequisites

• Node.js (v18 or higher)
• npm or yarn package manager

Installation

1. Clone or download this repository

2. Install dependencies:

   npm install
   

3. Copy the environment example file:

   cp .env.example .env
   

4. (Optional) Add your weather API key to .env:

   WEATHER_API_KEY=your_openweathermap_api_key_here
   

Build and Run

Development Mode

# Build and start with hot reload
npm run dev

Production Mode

# Build the project
npm run build

# Start the server
npm start

The server will start on http://localhost:3000 (or the port specified in your PORT environment variable).

API Endpoint

The MCP server is accessible at:

POST http://localhost:3000/mcp

Available Tools

1. BMI Calculator (calculate-bmi)

Calculate Body Mass Index from weight and height.

Parameters:

• weightKg (number): Weight in kilograms
• heightM (number): Height in meters

2. Weather Service (get-weather)

Get current weather information for a city.

Parameters:

• city (string): City name
• country (string, optional): Country code (e.g., "IN", "US")

3. Echo Tool (echo)

Simple echo functionality for testing purposes.

Parameters:

• message (string): Message to echo back

Testing the Server

Using MCP Inspector

For a GUI interface to test MCP server:

1. Start server:

   npm start
   

2. In another terminal, run the MCP inspector:

   npm run inspector
   

VS Code Integration

If you're using VS Code with MCP support, add this server to your settings:

{
  "mcp": {
    "servers": {
      "mcp-test-server": {
        "url": "http://localhost:3000/mcp"
      }
    }
  }
}

Project Structure

├── src/
│   ├── index.ts          # Main server file
│   └── tools/            # Tool implementations
│       ├── bmi.ts        # BMI calculator tool
│       ├── weather.ts    # Weather service tool
│       └── echo.ts       # Echo tool
├── build/                # Compiled JavaScript files
├── package.json          # Project configuration
├── tsconfig.json         # TypeScript configuration
├── .env.example          # Environment variables example
└── README.md             # This file

Development

Adding New Tools

1. Create a new tool file in src/tools/:

   import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
   import { z } from 'zod';
   
   export const myTool = {
     name: 'my-tool',
     schema: {
       param1: z.string(),
       param2: z.number(),
     },
     handler: async ({ param1, param2 }: { param1: string; param2: number }): Promise<CallToolResult> => {
       return {
         content: [
           {
             type: 'text',
             text: `Result: ${param1} - ${param2}`,
           },
         ],
       };
     },
   };
   

2. Import and register it in src/index.ts:

   import { myTool } from './tools/my-tool.js';
   
   // In the getServer() function:
   server.tool(
     myTool.name,
     'Description of my tool',
     myTool.schema,
     myTool.handler
   );
   

Available Scripts

• npm run build - Compile TypeScript to JavaScript
• npm run watch - Watch for changes and recompile
• npm run dev - Development mode with hot reload
• npm start - Start the compiled server
• npm run inspector - Launch MCP inspector