Sample Cpp MCP Servers

🚀 mcp-sample-cpp-servers

A sample project of MCP Servers implemented in C++. It provides a complete implementation of an MCP server, including initialization, tool registration, and tool call handling.

🚀 Quick Start

Prerequisites

• Ensure that a C++ compiler (such as gcc or MSVC) and necessary development libraries are installed.

Steps

1. Add the project to your IDE and build it.
2. After compiling and generating the executable file, run it in the terminal to start the MCP server.

💻 Usage Examples

Basic Usage

# Send a request for the tool list
curl -X POST http://localhost:5000/tools/list

# Call the evaluate-scores tool
curl -X POST http://localhost:5000/tools/call \
     -H "Content-Type: application/json" \
     -d '{"tool":"evaluate-scores","params":{"scores":[1,2,3,4,5]}}'

Output

• The tool list request returns information about the registered tools.
• The score evaluation call returns the total score and average score.

📚 Documentation

Code Structure

This is a complete implementation of an MCP server, demonstrating how to initialize the server, register tools, and handle tool calls.

Features

• Initialize the MCP server and set the protocol version and server information.
• Register a tool named evaluate-scores for evaluating a set of scores.
• Implement the call handling logic for the evaluate-scores tool to calculate the total score and average score.

Platform-Specific Code

For the Windows environment, the binary mode is set to solve file operation problems.

💻 Code Example

Basic Usage

#include <iostream>
#include <fstream>
#include <chrono>
#include <unordered_map>
#include "mcp-server.hpp"

#if defined(_MSC_VER)
#include <fcntl.h>
#include <io.h>
#endif

/// <summary>
/// Get a formatted string representing the time
/// </summary>
/// <returns>A formatted string representing the time</returns>
auto getTimeString() {
    const std::chrono::time_zone* tz = std::chrono::current_zone();
    return std::format("[{:%Y-%m-%d %H:%M:%S}]", tz->to_local(std::chrono::system_clock::now()));
}

int main() {
#if defined(_MSC_VER)
    // To solve the automatic CRLF↔LF conversion problem in Windows text mode, set standard input and output to binary mode
    _setmode(_fileno(stdin), _O_BINARY);
    _setmode(_fileno(stdout), _O_BINARY);
#endif

    mcp::MCPServer server;

    // MCP server initialization
    server.request.onInitialize = [&](const mcp::InitializeRequest& params) {
        std::cerr << getTimeString() << "initialize" << std::endl;

        return mcp::InitializeResult{
            .protocolVersion = params.protocolVersion,
            .capabilities = {
                .tools = mcp::ServerCapabilities::ToolsInner{}
            },
            .serverInfo = {
                .name = "ABC Game",
                .version = "1.0.0"
            }
        };
    };

    // MCP server initialization completed
    server.notification.onInitialized = [&]() {
        std::cerr << getTimeString() << "notifications/initialized" << std::endl;
    };

    // Tool registration
    server.request.tools.onList = [&]() {
        std::cerr << getTimeString() << "tools/list" << std::endl;

        return mcp::ListToolsResult{
            .tools = {
                {
                    .name = "evaluate-scores",
                    .description = "Score evaluation for ABC Game",
                    // Equivalent to the following JSON schema definition in Zod
                    // z.object({ score: z.number().min(0).describe("Score (points)") })
                    .inputSchema = nlohmann::json::object({
                        {"type", "object"},
                        {"properties", {
                            {"score", {
                                {"type", "number"},
                                {"minimum", 0},
                                {"description", "Score (points)"}
                            }}
                        }},
                        {"required", ["score"]}
                    })
                }
            }
        };
    };

    // Handle tool calls
    server.request.tools.onCall = [&](const std::string& toolName, const nlohmann::json& input) {
        std::cerr << getTimeString() << "tools/call " << toolName << " " << input.dump(4) << std::endl;

        if (toolName == "evaluate-scores") {
            if (!input["scores"].is_array()) {
                throw nlohmann::json::invalid_argument("Expected 'scores' to be an array");
            }

            size_t scoreCount = input["scores"].size();
            double total = 0.0;
            for (const auto& score : input["scores"]) {
                if (!score.is_number()) {
                    throw nlohmann::json::invalid_argument("Each score must be a number");
                }
                total += score.get<double>();
            }

            return nlohmann::json{
                {"total", static_cast<int64_t>(total)},
                {"average", total / scoreCount}
            };
        }

        throw nlohmann::json::invalid_argument("Unknown tool: " + toolName);
    };

    // Start the MCP server
    std::cerr << getTimeString() << "Start MCP Server" << std::endl;
    server.start();

    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    return 0;
}

Additional Information

• This project is a complete copy of the C++ implementation from the following article: Getting Started with MCP Servers.
• Only the standard input and output functions have been verified.
• Since the purpose is to demonstrate the use of the protocol, only support for function calls is implemented.
• This repository is planned to be deleted after creating a code release page on the blog (after n months).