import { FastMCP } from "fastmcp";

const mcp = new FastMCP({ name: "My Server" });

mcp.addTool({
  name: "add",
  description: "Add two numbers",
  parameters: z.object({ a: z.number(), b: z.number() }),
  execute: async ({ a, b }) => String(a + b),
});

mcp.start({ transportType: "stdio" });

package main

import (
    "github.com/mark3labs/mcp-go/mcp"
    "github.com/mark3labs/mcp-go/server"
)

func main() {
    s := server.NewMCPServer("My Server", "1.0.0")

    tool := mcp.NewTool("add",
        mcp.WithDescription("Add two numbers"),
        mcp.WithNumber("a", mcp.Required()),
        mcp.WithNumber("b", mcp.Required()),
    )
    s.AddTool(tool, func(args mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        a := args.Params.Arguments["a"].(float64)
        b := args.Params.Arguments["b"].(float64)
        return mcp.NewToolResultText(fmt.Sprintf("%v", a+b)), nil
    })
    server.ServeStdio(s)
}

use rust_mcp_sdk::prelude::*;

#[mcp_tool(description = "Add two numbers")]
async fn add(a: f64, b: f64) -> McpResult<f64> {
    Ok(a + b)
}

#[tokio::main]
async fn main() {
    McpServer::builder()
        .name("My Server")
        .version("1.0.0")
        .tool(add)
        .build()
        .run_stdio()
        .await
        .unwrap();
}

@SpringBootApplication
public class MyMcpServer {
    public static void main(String[] args) {
        SpringApplication.run(MyMcpServer.class, args);
    }

    @Bean
    public McpServerFeatures.SyncToolSpecification addTool() {
        return new McpServerFeatures.SyncToolSpecification(
            new Tool("add", "Add two numbers",
                schema(Map.of("a", "number", "b", "number"))),
            (exchange, args) -> {
                double result = (Double)args.get("a") + (Double)args.get("b");
                return new CallToolResult(result);
            }
        );
    }
}

import io.modelcontextprotocol.kotlin.sdk.*

fun main() {
    val server = Server(
        Implementation(name = "My Server", version = "1.0.0")
    )

    server.addTool(
        name = "add",
        description = "Add two numbers",
        inputSchema = Tool.Input(properties = buildJsonObject {
            put("a", buildJsonObject { put("type", "number") })
            put("b", buildJsonObject { put("type", "number") })
        })
    ) { request ->
        val a = request.arguments["a"]!!.jsonPrimitive.double
        val b = request.arguments["b"]!!.jsonPrimitive.double
        CallToolResult(content = listOf(TextContent("${a + b}")))
    }

    server.connect(StdioServerTransport())
}