TestMcpServer MCP Server: Simplifying Model Context Protocol Implementation

Overview: What is TestMcpServer MCP Server?

TestMcpServer is an MCP (Model Context Protocol) Server example built to streamline the integration of AI applications with various data sources and tools through a standardized protocol. Inspired by the need for clearer, more comprehensible examples, this server offers developers a straightforward approach to building their own MCP Servers. It supports popular AI applications such as Claude Desktop, Continue, and Cursor. By following the provided guidelines, users can easily add new tools or customize existing ones, enhancing the functionality of both their servers and connected applications.

🔧 Core Features & MCP Capabilities

TestMcpServer encapsulates key features essential for robust MCP implementations:

• Tool Definition Files: Organized in categories like maths, where each tool has a unique definition. This ensures scalability and maintainability.
• Controller Implementation: Each controller handles specific tools, ensuring that the logic is encapsulated logically and efficiently.
• Tool Registry: A central hub that maps tools to their respective handlers, facilitating seamless execution of requests.
• Server Configuration & Request Handling: The server setup includes both tool registration and request handling mechanisms, making it flexible for various use cases.

⚙️ MCP Architecture & Protocol Implementation

The architecture follows a strict adherence to the Model Context Protocol:

1. Tool Definitions - Located in /src/definitions, these files outline the operation of each tool.
2. Controllers - Organized under /src/controllers, handlers implement the actual logic for executing tools.
3. Tool Registry - Registers controllers and their corresponding methods, ensuring they are ready for server registration.
4. Server Setup - Configured to use the registry, enabling both tool listing and execution through standardized requests.

🚀 Getting Started with Installation

To get started with TestMcpServer, ensure you have Node.js and npm installed on your system. After cloning the repository, run npm install. For ease of development, you can use npm run dev to watch for changes and automatically build and run the server.

# Cloning the repository
git clone https://github.com/your-repo/TestMcpServer.git

# Navigate into the project directory and install dependencies
cd TestMcpServer
npm install

# Start the development environment
npm run dev

💡 Key Use Cases in AI Workflows

Imagine integrating a text summarization tool directly from within an AI application, like Claude Desktop, or using Cursor to manage complex workflows involving multiple data points.

Use Case 1: Dynamic Calculations for Financial Analysis

Using the addition and subtraction tools defined in TestMcpServer, you can create dynamic financial analysis dashboards. For instance:

// Example tool definition
import { Tool } from "@modelcontextprotocol/sdk/types.js";

export const ADDITION = {
  name: "addition",
  description: "Add two numbers together",
};

class FinancialController {
  async handleAddition(a: number, b: number) {
    const result = a + b;
    return {
      content: [
        { type: "text", text: `Sum: ${result}` },
      ],
      isError: false,
    };
  }
}

This tool can be easily added to the server and accessed by any MCP client, enabling real-time financial calculations directly within the application.

Use Case 2: Contextual Data Sourcing for Content Generation

With TestMcpServer, you can source contextual data from various APIs or local tools. For example, integrating a weather API tool allows AI applications to dynamically generate content based on current conditions:

// Example controller and handler method
import { Tool } from "@modelcontextprotocol/sdk/types.js";

export const WEATHER_FETCH = {
  name: "weather_fetch",
  description: "Fetch live weather data.",
};

class WeatherController {
  async handleWeatherFetch() {
    // Fetching external API data
    try {
      const response = await fetch("https://api.openweathermap.org/data/2.5/weather");
      const data = await response.json();
      return { content: [{ text: "Current temperature is " + data.main.temp }], isError: false };
    } catch (error) {
      return { isError: true, content: [{ text: `Error fetching weather data` }] };
    }
  }
}

This setup allows content generation to be contextually relevant and up-to-date.

🔌 Integration with MCP Clients

To integrate TestMcpServer with popular MCP clients:

1. Open Settings: Access the settings of your chosen client (e.g., Cursor).
2. Go to Features: Navigate to the feature section where MCP servers are managed.
3. Add New MCP Server: Click on "Add new MCP server" and provide relevant details.

For example, with Cursor:

• Name: TestMcpServer
• Type: Command
• Server URL: node <absolute path to project>\build\index.js

Once configuration is done, the tool should be ready for use within your AI application ecosystem.

📊 Performance & Compatibility Matrix

TestMcpServer ensures seamless compatibility with multiple MCP clients through its versatile architecture:

• Claude Desktop: Full Support
• Continue: Full Support
• Cursor: Tools Only (No Prompts Integration)

🛠️ Advanced Configuration & Security

Configuring and securing TestMcpServer involves several steps:

1. Environment Variables - Define necessary environment variables for security, such as API_KEY.

{
  "mcpServers": {
    "TestMcpServer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-test"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

2. Security Best Practices - Implement authentication, authorization, and rate limiting to ensure secure access.

❓ Frequently Asked Questions (FAQ)

1. How do I add a new tool? Follow the guidelines provided in this documentation:

   • Create your tool definition.
   • Add it to the appropriate category folder.
   • Define controller implementation for the handler method.
   • Register the tool in toolRegistry.ts.

2. Which MCP clients are compatible with TestMcpServer? The compatibility matrix shows full support from Claude Desktop and Continue, while Cursor supports tools but not prompts.

3. How can I optimize performance? Consider caching results where appropriate, using efficient database queries, and optimizing network requests.

4. Can I customize the server's appearance or branding? Yes, you can modify the files under /src to suit your branding needs.

5. Are there any known issues with TestMcpServer? While we strive for stability, issues may arise due to changes in MCP specifications. Regular updates and testing are recommended.

👨‍💻 Development & Contribution Guidelines

Contributors can help enhance TestMcpServer by:

• Adding New Tools: Ensure they follow the naming conventions.
• Refactoring Code: Improve readability and maintainability.
• Reporting Issues: Use GitHub issues for bugs or suggestions.
• Testing Changes: Regularly update tests to cover new functionalities.

🌐 MCP Ecosystem & Resources

For more information about Model Context Protocol, visit:

• Official MCP Documentation
• MCP GitHub Repository

Explore the wider MCP ecosystem for additional use cases and integrations.

Mermaid Diagrams

1. MCP Protocol Flow

graph TD
    A[AI Application] -->|MCP Client| B[MCP Protocol]
    B --> C[MCP Server]
    C --> D[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

2. Data Architecture

graph TD
    A[MCP Client] --> B[Tool Request]
    B --> C[MCP Server]
    C --> D[Database/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

Example Flow

1. Create Tool Definition - Define the tool in a TypeScript file:

   import { Tool } from "@modelcontextprotocol/sdk/types.js";
   
   export const ADDITION = {
     name: "addition",
     description: "Add two numbers together",
     inputSchema: {
       type: "object",
       properties: {
         a: {
           type: "number",
           description: "First number to add",
         },
         b: {
           type: "number",
           description: "Second number to add",
         },
       },
       required: ["a", "b"],
     },
   };
   

2. Add Tool to Controller - Implement the logic in a controller:

   class FinancialController {
     async handleAddition(a: number, b: number) {
       const result = a + b;
       return { content: [{ text: `Sum: ${result}` }], isError: false };
     }
   }
   

3. Register Tool in Registry - Map the tool to its controller method:

   import { ToolRegistry } from "@modelcontextprotocol/server-test";
   
   const addTool = ToolRegistry.register({
     name: "addition",
     handler: new FinancialController().handleAddition,
   });
   

4. Server Configuration - Set up the server to use the registry:

   import { Server } from "@modelcontextprotocol/server-test";
   
   const server = new Server();
   server.registerTools(ToolRegistry.get());
   server.start();
   

By following these steps, developers can seamlessly integrate TestMcpServer into their AI application ecosystems.