Files

T

wehub-resource-sync c275ba2868 chore: import upstream snapshot with attribution

2026-07-13 13:31:35 +08:00

43 KiB

Raw Permalink Blame History

MCPのはじめ方

Model Context Protocol（MCP）へようこそ！MCPが初めての方も、理解を深めたい方も、このガイドは基本的なセットアップと開発プロセスを案内します。MCPがAIモデルとアプリケーションのシームレスな統合をどのように可能にするかを発見し、MCPを活用したソリューション構築とテストのために環境を素早く準備する方法を学べます。

TLDR; AIアプリを作るなら、LLM（大規模言語モデル）にツールやその他のリソースを追加して知識を増やせます。しかし、それらのツールやリソースをサーバーに配置すると、そのアプリやサーバー機能はLLMの有無に関わらず、どんなクライアントでも利用可能になります。

概要

このレッスンでは、MCP環境をセットアップし、初めてのMCPアプリケーションを構築するための実践的なガイダンスを提供します。必要なツールやフレームワークの設定、基本的なMCPサーバーの構築、ホストアプリケーションの作成、実装のテスト方法を学びます。

Model Context Protocol (MCP) は、アプリケーションがLLMにコンテキストを提供する方法を標準化するオープンプロトコルです。MCPはAIアプリケーションのためのUSB-Cポートのようなもので、AIモデルをさまざまなデータソースやツールに接続する標準化された方法を提供します。

学習目標

このレッスンを終える頃には、以下ができるようになります：

C#, Java, Python, TypeScript, Rust向けMCPの開発環境をセットアップする
カスタム機能（リソース、プロンプト、ツール）を備えた基本的なMCPサーバーを構築し展開する
MCPサーバーに接続するホストアプリケーションを作成する
MCP実装のテストとデバッグを行う

MCP環境のセットアップ

MCPで作業を始める前に、開発環境の準備と基本的なワークフローの理解が重要です。このセクションでは、MCPをスムーズに始めるための初期セットアップ手順を案内します。

前提条件

MCPの開発に入る前に、以下を用意してください：

開発環境: 選択した言語（C#, Java, Python, TypeScript, Rust）
IDE/エディター: Visual Studio、Visual Studio Code、IntelliJ、Eclipse、PyCharm、または任意の最新コードエディター
パッケージマネージャー: NuGet、Maven/Gradle、pip、npm/yarn、またはCargo
APIキー: ホストアプリケーションで使用予定のAIサービスのAPIキー

基本的なMCPサーバー構造

MCPサーバーは通常、以下を含みます：

サーバー設定: ポート、認証、その他の設定のセットアップ
リソース: LLMに提供されるデータとコンテキスト
ツール: モデルが呼び出せる機能
プロンプト: テキスト生成や構造化のテンプレート

TypeScriptでの簡単な例を示します：

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// MCPサーバーを作成する
const server = new McpServer({
  name: "Demo",
  version: "1.0.0"
});

// 追加ツールを追加する
server.tool("add",
  { a: z.number(), b: z.number() },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }]
  })
);

// 動的な挨拶リソースを追加する
server.resource(
  "file",
  // 'list'パラメータはリソースが利用可能なファイルを一覧表示する方法を制御します。これをundefinedに設定すると、このリソースの一覧表示が無効になります。
  new ResourceTemplate("file://{path}", { list: undefined }),
  async (uri, { path }) => ({
    contents: [{
      uri: uri.href,
      text: `File, ${path}!`
    }]
  })
);

// ファイルの内容を読み取るファイルリソースを追加する
server.resource(
  "file",
  new ResourceTemplate("file://{path}", { list: undefined }),
  async (uri, { path }) => {
    let text;
    try {
      text = await fs.readFile(path, "utf8");
    } catch (err) {
      text = `Error reading file: ${err.message}`;
    }
    return {
      contents: [{
        uri: uri.href,
        text
      }]
    };
  }
);

server.prompt(
  "review-code",
  { code: z.string() },
  ({ code }) => ({
    messages: [{
      role: "user",
      content: {
        type: "text",
        text: `Please review this code:\n\n${code}`
      }
    }]
  })
);

// stdinでメッセージの受信を開始し、stdoutでメッセージの送信を開始する
const transport = new StdioServerTransport();
await server.connect(transport);

このコードでは：

MCP TypeScript SDKから必要なクラスをインポート
新しいMCPサーバーインスタンスを作成および設定
カスタムツール（calculator）をハンドラ関数とともに登録
MCPリクエストの待機を開始

テストとデバッグ

MCPサーバーのテストを始める前に、利用可能なツールとデバッグのベストプラクティスを理解しておくことが重要です。効果的なテストはサーバーの期待通りの動作を保証し、問題の迅速な特定と解決に役立ちます。以下のセクションでは、MCP実装の検証に推奨される方法を示します。

MCPはサーバーのテストとデバッグに役立つツールを提供します：

Inspectorツール：グラフィカルなインターフェースでサーバーに接続し、ツール、プロンプト、リソースをテスト可能
curl：curlなどのコマンドラインツールやHTTPコマンドを作成・実行できるクライアントを使ってサーバーに接続可能

MCP Inspectorの使用

MCP Inspector は、以下の機能を持つ視覚的なテストツールです：

サーバーの機能発見：利用可能なリソース、ツール、プロンプトを自動検出
ツール実行のテスト：さまざまなパラメータを試し、リアルタイムでレスポンスを確認
サーバーメタデータの閲覧：サーバー情報、スキーマ、設定を確認

# 例 TypeScript、MCP Inspectorのインストールと実行
npx @modelcontextprotocol/inspector node build/index.js

上記コマンドを実行すると、MCP Inspectorがブラウザーでローカルウェブインターフェースを起動します。登録済みのMCPサーバー、利用可能なツール、リソース、プロンプトを表示するダッシュボードが見られます。インターフェースではツールの実行をインタラクティブにテストし、サーバーメタデータを調査し、リアルタイムレスポンスを閲覧できるため、MCPサーバーの検証とデバッグが容易になります。

利用イメージのスクリーンショット：

よくあるセットアップの問題と解決方法

問題	可能な解決策
接続拒否	サーバーが起動中か、ポートが正しいか確認
ツール実行エラー	パラメータ検証やエラーハンドリングを見直す
認証失敗	APIキーや権限を確認
スキーマ検証エラー	パラメータが定義されたスキーマに合っているか確認
サーバーが起動しない	ポートの競合や依存関係が不足していないか確認
CORSエラー	クロスオリジンリクエスト用に正しいCORSヘッダーを設定
認証トークン問題	トークンの有効性や権限を確認

ローカル開発

ローカル開発とテストのために、MCPサーバーを自分のマシン上で直接実行できます：

サーバープロセスを起動：MCPサーバーアプリケーションを実行
ネットワーク設定：サーバーが期待されるポートでアクセス可能か確認
クライアント接続：http://localhost:3000のようなローカル接続URLを使用

# 例: TypeScript MCPサーバーをローカルで実行する
npm run start
# サーバーは http://localhost:3000 で実行中

はじめてのMCPサーバー構築

以前のレッスンのコアコンセプトを学んだので、知識を活用しましょう。

サーバーができること

コードを書く前に、サーバーができることを再確認します：

MCPサーバーは例えば：

ローカルファイルやデータベースにアクセス
リモートAPIに接続
計算処理を実行
他のツールやサービスと統合
ユーザーインターフェースを提供

さあ、できることを知ったので、コーディングを始めましょう。

演習：サーバーの作成

サーバーを作成するには、以下のステップを実行します：

MCP SDKをインストールする
プロジェクトを作成し、プロジェクト構造をセットアップする
サーバーコードを書く
サーバーをテストする

-1- プロジェクト作成

TypeScript

# プロジェクトディレクトリを作成し、npmプロジェクトを初期化する
mkdir calculator-server
cd calculator-server
npm init -y

Python

# プロジェクトディレクトリを作成する
mkdir calculator-server
cd calculator-server
# Visual Studio Codeでフォルダーを開く - 別のIDEを使用している場合はスキップしてください
code .

.NET

dotnet new console -n McpCalculatorServer
cd McpCalculatorServer

Java

Javaの場合、Spring Bootプロジェクトを作成します：

curl https://start.spring.io/starter.zip \
  -d dependencies=web \
  -d javaVersion=21 \
  -d type=maven-project \
  -d groupId=com.example \
  -d artifactId=calculator-server \
  -d name=McpServer \
  -d packageName=com.microsoft.mcp.sample.server \
  -o calculator-server.zip

zipファイルを解凍：

unzip calculator-server.zip -d calculator-server
cd calculator-server
# オプションで未使用のテストを削除する
rm -rf src/test/java

pom.xmlファイルに以下の完全な設定を追加：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <!-- Spring Boot parent for dependency management -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.5.0</version>
        <relativePath />
    </parent>

    <!-- Project coordinates -->
    <groupId>com.example</groupId>
    <artifactId>calculator-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Calculator Server</name>
    <description>Basic calculator MCP service for beginners</description>

    <!-- Properties -->
    <properties>
        <java.version>21</java.version>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>

    <!-- Spring AI BOM for version management -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.ai</groupId>
                <artifactId>spring-ai-bom</artifactId>
                <version>1.0.0-SNAPSHOT</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- Dependencies -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-starter-mcp-server-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
    </dependencies>

    <!-- Build configuration -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <release>21</release>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- Repositories for Spring AI snapshots -->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>
</project>

Rust

mkdir calculator-server
cd calculator-server
cargo init

-2- 依存関係の追加

プロジェクト作成後、依存関係を追加しましょう：

TypeScript

# まだインストールされていない場合は、TypeScriptをグローバルにインストールします
npm install typescript -g

# MCP SDKとスキーマ検証のためのZodをインストールします
npm install @modelcontextprotocol/sdk zod
npm install -D @types/node typescript

Python

# 仮想環境を作成し、依存関係をインストールします
python -m venv venv
venv\Scripts\activate
pip install "mcp[cli]"

Java

cd calculator-server
./mvnw clean install -DskipTests

Rust

cargo add rmcp --features server,transport-io
cargo add serde
cargo add tokio --features rt-multi-thread

-3- プロジェクトファイル作成

TypeScript

package.jsonを開き、ビルドやサーバー実行ができるよう以下に置き換えます：

{
  "name": "calculator-server",
  "version": "1.0.0",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "build": "tsc",
    "start": "npm run build && node ./build/index.js",
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "A simple calculator server using Model Context Protocol",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.16.0",
    "zod": "^3.25.76"
  },
  "devDependencies": {
    "@types/node": "^24.0.14",
    "typescript": "^5.8.3"
  }
}

tsconfig.jsonを作成し、以下の内容を記述：

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

ソースコード用ディレクトリを作成：

mkdir src
touch src/index.ts

Python

server.pyファイルを作成：

touch server.py

.NET

必要なNuGetパッケージをインストール：

dotnet add package ModelContextProtocol --prerelease
dotnet add package Microsoft.Extensions.Hosting

Java

Java Spring Boot プロジェクトでは、プロジェクト構造は自動作成されます。

Rust

Rustの場合、cargo init実行時にsrc/main.rsが作成されます。開いてデフォルトコードを削除してください。

-4- サーバーコード作成

TypeScript

index.tsファイルを作成し、以下のコードを追加：

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
 
// MCPサーバーを作成する
const server = new McpServer({
  name: "Calculator MCP Server",
  version: "1.0.0"
});

これでサーバーはできましたが、できることは少ないので修正します。

Python

# server.py
from mcp.server.fastmcp import FastMCP

# MCPサーバーを作成する
mcp = FastMCP("Demo")

.NET

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;
using System.ComponentModel;

var builder = Host.CreateApplicationBuilder(args);
builder.Logging.AddConsole(consoleLogOptions =>
{
    // Configure all logs to go to stderr
    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
});

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();
await builder.Build().RunAsync();

// add features

Java

Javaでコアサーバーコンポーネントを作成します。まず、メインアプリケーションクラスを修正：

src/main/java/com/microsoft/mcp/sample/server/McpServerApplication.java:

package com.microsoft.mcp.sample.server;

import org.springframework.ai.tool.ToolCallbackProvider;
import org.springframework.ai.tool.method.MethodToolCallbackProvider;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import com.microsoft.mcp.sample.server.service.CalculatorService;

@SpringBootApplication
public class McpServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(McpServerApplication.class, args);
    }
    
    @Bean
    public ToolCallbackProvider calculatorTools(CalculatorService calculator) {
        return MethodToolCallbackProvider.builder().toolObjects(calculator).build();
    }
}

計算サービス src/main/java/com/microsoft/mcp/sample/server/service/CalculatorService.java を作成：

package com.microsoft.mcp.sample.server.service;

import org.springframework.ai.tool.annotation.Tool;
import org.springframework.stereotype.Service;

/**
 * Service for basic calculator operations.
 * This service provides simple calculator functionality through MCP.
 */
@Service
public class CalculatorService {

    /**
     * Add two numbers
     * @param a The first number
     * @param b The second number
     * @return The sum of the two numbers
     */
    @Tool(description = "Add two numbers together")
    public String add(double a, double b) {
        double result = a + b;
        return formatResult(a, "+", b, result);
    }

    /**
     * Subtract one number from another
     * @param a The number to subtract from
     * @param b The number to subtract
     * @return The result of the subtraction
     */
    @Tool(description = "Subtract the second number from the first number")
    public String subtract(double a, double b) {
        double result = a - b;
        return formatResult(a, "-", b, result);
    }

    /**
     * Multiply two numbers
     * @param a The first number
     * @param b The second number
     * @return The product of the two numbers
     */
    @Tool(description = "Multiply two numbers together")
    public String multiply(double a, double b) {
        double result = a * b;
        return formatResult(a, "*", b, result);
    }

    /**
     * Divide one number by another
     * @param a The numerator
     * @param b The denominator
     * @return The result of the division
     */
    @Tool(description = "Divide the first number by the second number")
    public String divide(double a, double b) {
        if (b == 0) {
            return "Error: Cannot divide by zero";
        }
        double result = a / b;
        return formatResult(a, "/", b, result);
    }

    /**
     * Calculate the power of a number
     * @param base The base number
     * @param exponent The exponent
     * @return The result of raising the base to the exponent
     */
    @Tool(description = "Calculate the power of a number (base raised to an exponent)")
    public String power(double base, double exponent) {
        double result = Math.pow(base, exponent);
        return formatResult(base, "^", exponent, result);
    }

    /**
     * Calculate the square root of a number
     * @param number The number to find the square root of
     * @return The square root of the number
     */
    @Tool(description = "Calculate the square root of a number")
    public String squareRoot(double number) {
        if (number < 0) {
            return "Error: Cannot calculate square root of a negative number";
        }
        double result = Math.sqrt(number);
        return String.format("√%.2f = %.2f", number, result);
    }

    /**
     * Calculate the modulus (remainder) of division
     * @param a The dividend
     * @param b The divisor
     * @return The remainder of the division
     */
    @Tool(description = "Calculate the remainder when one number is divided by another")
    public String modulus(double a, double b) {
        if (b == 0) {
            return "Error: Cannot divide by zero";
        }
        double result = a % b;
        return formatResult(a, "%", b, result);
    }

    /**
     * Calculate the absolute value of a number
     * @param number The number to find the absolute value of
     * @return The absolute value of the number
     */
    @Tool(description = "Calculate the absolute value of a number")
    public String absolute(double number) {
        double result = Math.abs(number);
        return String.format("|%.2f| = %.2f", number, result);
    }

    /**
     * Get help about available calculator operations
     * @return Information about available operations
     */
    @Tool(description = "Get help about available calculator operations")
    public String help() {
        return "Basic Calculator MCP Service\n\n" +
               "Available operations:\n" +
               "1. add(a, b) - Adds two numbers\n" +
               "2. subtract(a, b) - Subtracts the second number from the first\n" +
               "3. multiply(a, b) - Multiplies two numbers\n" +
               "4. divide(a, b) - Divides the first number by the second\n" +
               "5. power(base, exponent) - Raises a number to a power\n" +
               "6. squareRoot(number) - Calculates the square root\n" + 
               "7. modulus(a, b) - Calculates the remainder of division\n" +
               "8. absolute(number) - Calculates the absolute value\n\n" +
               "Example usage: add(5, 3) will return 5 + 3 = 8";
    }

    /**
     * Format the result of a calculation
     */
    private String formatResult(double a, String operator, double b, double result) {
        return String.format("%.2f %s %.2f = %.2f", a, operator, b, result);
    }
}

本番環境向けのオプションコンポーネント：

起動設定 src/main/java/com/microsoft/mcp/sample/server/config/StartupConfig.java を作成：

package com.microsoft.mcp.sample.server.config;

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class StartupConfig {
    
    @Bean
    public CommandLineRunner startupInfo() {
        return args -> {
            System.out.println("\n" + "=".repeat(60));
            System.out.println("Calculator MCP Server is starting...");
            System.out.println("SSE endpoint: http://localhost:8080/sse");
            System.out.println("Health check: http://localhost:8080/actuator/health");
            System.out.println("=".repeat(60) + "\n");
        };
    }
}

ヘルスコントローラー src/main/java/com/microsoft/mcp/sample/server/controller/HealthController.java を作成：

package com.microsoft.mcp.sample.server.controller;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

@RestController
public class HealthController {
    
    @GetMapping("/health")
    public ResponseEntity<Map<String, Object>> healthCheck() {
        Map<String, Object> response = new HashMap<>();
        response.put("status", "UP");
        response.put("timestamp", LocalDateTime.now().toString());
        response.put("service", "Calculator MCP Server");
        return ResponseEntity.ok(response);
    }
}

例外ハンドラー src/main/java/com/microsoft/mcp/sample/server/exception/GlobalExceptionHandler.java を作成：

package com.microsoft.mcp.sample.server.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleIllegalArgumentException(IllegalArgumentException ex) {
        ErrorResponse error = new ErrorResponse(
            "Invalid_Input", 
            "Invalid input parameter: " + ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    public static class ErrorResponse {
        private String code;
        private String message;

        public ErrorResponse(String code, String message) {
            this.code = code;
            this.message = message;
        }

        // ゲッター
        public String getCode() { return code; }
        public String getMessage() { return message; }
    }
}

カスタムバナー src/main/resources/banner.txt を作成：

_____      _            _       _             
 / ____|    | |          | |     | |            
| |     __ _| | ___ _   _| | __ _| |_ ___  _ __ 
| |    / _` | |/ __| | | | |/ _` | __/ _ \| '__|
| |___| (_| | | (__| |_| | | (_| | || (_) | |   
 \_____\__,_|_|\___|\__,_|_|\__,_|\__\___/|_|   
                                                
Calculator MCP Server v1.0
Spring Boot MCP Application

Rust

src/main.rsの先頭に以下を追加。必要なライブラリとモジュールをインポートします。

use rmcp::{
    handler::server::{router::tool::ToolRouter, tool::Parameters},
    model::{ServerCapabilities, ServerInfo},
    schemars, tool, tool_handler, tool_router,
    transport::stdio,
    ServerHandler, ServiceExt,
};
use std::error::Error;

計算サーバーは2つの数字を加算するシンプルなものです。計算リクエストを表すstructを作成します。

#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
pub struct CalculatorRequest {
    pub a: f64,
    pub b: f64,
}

次に、ツールの登録に使うツールルーターを保持する計算サーバーを表すstructを作成します。

#[derive(Debug, Clone)]
pub struct Calculator {
    tool_router: ToolRouter<Self>,
}

Calculator structを実装し、サーバーの新しいインスタンスを生成し、サーバーハンドラーを実装してサーバー情報を提供します。

#[tool_router]
impl Calculator {
    pub fn new() -> Self {
        Self {
            tool_router: Self::tool_router(),
        }
    }
}

#[tool_handler]
impl ServerHandler for Calculator {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            instructions: Some("A simple calculator tool".into()),
            capabilities: ServerCapabilities::builder().enable_tools().build(),
            ..Default::default()
        }
    }
}

最後に、サーバーを起動するmain関数を実装します。この関数はCalculatorのインスタンスを作成し、標準入出力でサービスを提供します。

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let service = Calculator::new().serve(stdio()).await?;
    service.waiting().await?;
    Ok(())
}

サーバーは基本情報を提供できるようになりました。次に加算ツールを追加します。

-5- ツールとリソースの追加

以下のコードを追加してツールとリソースを加えます：

TypeScript

server.tool(
  "add",
  { a: z.number(), b: z.number() },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }]
  })
);

server.resource(
  "greeting",
  new ResourceTemplate("greeting://{name}", { list: undefined }),
  async (uri, { name }) => ({
    contents: [{
      uri: uri.href,
      text: `Hello, ${name}!`
    }]
  })
);

ツールはパラメータaとbを受け取り、以下の形式でレスポンスを生成します：

{
  contents: [{
    type: "text", content: "some content"
  }]
}

リソースは文字列 "greeting" でアクセスされ、パラメータnameを取り、ツールに類似したレスポンスを生成します：

{
  uri: "<href>",
  text: "a text"
}

Python

# 追加ツールを追加する
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b


# 動的な挨拶リソースを追加する
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"

このコードで：

パラメータaとb（整数）を取るツールaddを定義
パラメータnameを取るリソースgreetingを作成

.NET

Program.csファイルに以下を追加：

[McpServerToolType]
public static class CalculatorTool
{
    [McpServerTool, Description("Adds two numbers")]
    public static string Add(int a, int b) => $"Sum {a + b}";
}

Java

ツールは前の段階で既に作成済みです。

Rust

impl Calculator ブロック内に新しいツールを追加：

#[tool(description = "Adds a and b")]
async fn add(
    &self,
    Parameters(CalculatorRequest { a, b }): Parameters<CalculatorRequest>,
) -> String {
    (a + b).to_string()
}

-6- 最終コード

サーバーを起動できるように最後のコードを追加しましょう：

TypeScript

// stdinでのメッセージ受信を開始し、stdoutでのメッセージ送信を開始する
const transport = new StdioServerTransport();
await server.connect(transport);

完全なコードはこちら：

// index.ts
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// MCPサーバーを作成する
const server = new McpServer({
  name: "Calculator MCP Server",
  version: "1.0.0"
});

// 追加ツールを追加する
server.tool(
  "add",
  { a: z.number(), b: z.number() },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }]
  })
);

// 動的な挨拶リソースを追加する
server.resource(
  "greeting",
  new ResourceTemplate("greeting://{name}", { list: undefined }),
  async (uri, { name }) => ({
    contents: [{
      uri: uri.href,
      text: `Hello, ${name}!`
    }]
  })
);

// stdinでメッセージの受信を開始し、stdoutでメッセージの送信を開始する
const transport = new StdioServerTransport();
server.connect(transport);

Python

# server.py
from mcp.server.fastmcp import FastMCP

# MCPサーバーを作成する
mcp = FastMCP("Demo")


# 追加ツールを追加する
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b


# 動的な挨拶リソースを追加する
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"

# メイン実行ブロック - サーバーを実行するために必要です
if __name__ == "__main__":
    mcp.run()

.NET

Program.csファイルを以下の内容で作成：

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;
using System.ComponentModel;

var builder = Host.CreateApplicationBuilder(args);
builder.Logging.AddConsole(consoleLogOptions =>
{
    // Configure all logs to go to stderr
    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
});

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();
await builder.Build().RunAsync();

[McpServerToolType]
public static class CalculatorTool
{
    [McpServerTool, Description("Adds two numbers")]
    public static string Add(int a, int b) => $"Sum {a + b}";
}

Java

メインアプリケーションクラスの完全版：

// McpServerApplication.java
package com.microsoft.mcp.sample.server;

import org.springframework.ai.tool.ToolCallbackProvider;
import org.springframework.ai.tool.method.MethodToolCallbackProvider;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import com.microsoft.mcp.sample.server.service.CalculatorService;

@SpringBootApplication
public class McpServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(McpServerApplication.class, args);
    }
    
    @Bean
    public ToolCallbackProvider calculatorTools(CalculatorService calculator) {
        return MethodToolCallbackProvider.builder().toolObjects(calculator).build();
    }
}

Rust

Rustサーバーの最終コードは以下の通り：

use rmcp::{
    ServerHandler, ServiceExt,
    handler::server::{router::tool::ToolRouter, tool::Parameters},
    model::{ServerCapabilities, ServerInfo},
    schemars, tool, tool_handler, tool_router,
    transport::stdio,
};
use std::error::Error;

#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
pub struct CalculatorRequest {
    pub a: f64,
    pub b: f64,
}

#[derive(Debug, Clone)]
pub struct Calculator {
    tool_router: ToolRouter<Self>,
}

#[tool_router]
impl Calculator {
    pub fn new() -> Self {
        Self {
            tool_router: Self::tool_router(),
        }
    }
    
    #[tool(description = "Adds a and b")]
    async fn add(
        &self,
        Parameters(CalculatorRequest { a, b }): Parameters<CalculatorRequest>,
    ) -> String {
        (a + b).to_string()
    }
}

#[tool_handler]
impl ServerHandler for Calculator {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            instructions: Some("A simple calculator tool".into()),
            capabilities: ServerCapabilities::builder().enable_tools().build(),
            ..Default::default()
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let service = Calculator::new().serve(stdio()).await?;
    service.waiting().await?;
    Ok(())
}

-7- サーバーのテスト

以下のコマンドでサーバーを起動します：

TypeScript

npm run build

Python

mcp run server.py

MCP Inspectorを使う場合は、mcp dev server.pyを使うとInspectorが自動起動し、必要なプロキシセッショントークンが提供されます。mcp run server.pyの場合は、手動でInspectorを起動して接続設定が必要です。

.NET

プロジェクトディレクトリにいることを確認：

cd McpCalculatorServer
dotnet run

Java

./mvnw clean install -DskipTests
java -jar target/calculator-server-0.0.1-SNAPSHOT.jar

Rust

フォーマットと実行のコマンド：

cargo fmt
cargo run

-8- Inspectorを使って実行

Inspectorはサーバー起動を補助し、操作しながら動作をテストできる便利なツールです。起動しましょう：

Note

"command"欄の内容は使用しているランタイムごとに異なる場合があります。

TypeScript

npx @modelcontextprotocol/inspector node build/index.js

またはpackage.jsonに "inspector": "npx @modelcontextprotocol/inspector node build/index.js" と追加し、npm run inspectorを実行します。

Python

PythonはNode.jsツールであるinspectorをラップしています。以下のように呼び出せます：

mcp dev server.py

ただし、すべてのメソッドを実装していないため、Node.jsツールを直接以下のように実行することが推奨されます：

npx @modelcontextprotocol/inspector mcp run server.py

スクリプト実行のコマンドや引数を設定できるツールやIDEを使っている場合、 Command フィールドに python を設定し、Arguments に server.py を設定することを必ず行ってください。これによりスクリプトが正しく実行されます。

.NET

プロジェクトディレクトリにいることを確認してください：

cd McpCalculatorServer
npx @modelcontextprotocol/inspector dotnet run

Java

Calculator サーバーが実行されていることを確認します次にインスペクターを起動します：

npx @modelcontextprotocol/inspector

インスペクターのウェブインターフェイスでは：

トランスポートタイプとして「SSE」を選択
URL を http://localhost:8080/sse に設定
「Connect」をクリック

これでサーバーに接続されました Java サーバーテストのセクションはこれで完了です

次のセクションはサーバーとのインタラクションについてです。

次のユーザーインターフェイスが表示されるはずです：

「Connect」ボタンを選択してサーバーに接続するサーバーに接続すると、以下が表示されます：

「Tools」と「listTools」を選択すると、「Add」が表示されるはずです。「Add」を選択し、パラメーター値を入力してください。

以下のレスポンス、すなわち "add" ツールの結果が表示されるはずです：

おめでとうございます、最初のサーバーを作成し実行できました！

Rust

Rust サーバーを MCP Inspector CLI で実行するには、次のコマンドを使用します：

npx @modelcontextprotocol/inspector cargo run --cli --method tools/call --tool-name add --tool-arg a=1 b=2

公式 SDK

MCP は複数言語の公式 SDK を提供しています：

C# SDK - Microsoft と連携してメンテナンス
Java SDK - Spring AI と連携してメンテナンス
TypeScript SDK - 公式の TypeScript 実装
Python SDK - 公式の Python 実装
Kotlin SDK - 公式の Kotlin 実装
Swift SDK - Loopwork AI と連携してメンテナンス
Rust SDK - 公式の Rust 実装

重要なポイント

言語別 SDK を使うと MCP 開発環境の構築が簡単
MCP サーバーの構築は、明確なスキーマを持つツールの作成と登録を含む
テストとデバッグは確かな MCP 実装に不可欠

サンプル

演習課題

お好きなツールを使って簡単な MCP サーバーを作成してください：

お好みの言語 (.NET、Java、Python、TypeScript、Rust) でツールを実装する。
入力パラメーターと戻り値を定義する。
インスペクターツールを実行し、サーバーが意図した通り動作することを確認する。
さまざまな入力で実装をテストする。

解答例

追加リソース

次にやること

次： MCP クライアントの始め方

免責事項:
本書類は AI 翻訳サービス Co-op Translator を使用して翻訳されています。正確性を追求していますが、自動翻訳には誤りや不正確な点が含まれる可能性があることをご承知おきください。原文となる母国語の文書が権威ある情報源とみなされるべきです。重要な情報については、専門の人間による翻訳を推奨します。本翻訳の使用により生じた誤解や誤訳について、当方は一切責任を負いません。

43 KiB Raw Permalink Blame History Unescape Escape

MCPのはじめ方

概要

学習目標

MCP環境のセットアップ

前提条件

基本的なMCPサーバー構造

テストとデバッグ

MCP Inspectorの使用

よくあるセットアップの問題と解決方法

ローカル開発

はじめてのMCPサーバー構築

サーバーができること

演習：サーバーの作成

-1- プロジェクト作成

TypeScript

Python

.NET

Java

Rust

-2- 依存関係の追加

TypeScript

Python

Java

Rust

-3- プロジェクトファイル作成

TypeScript

Python

.NET

Java

Rust

-4- サーバーコード作成

TypeScript

Python

.NET

Java

Rust

-5- ツールとリソースの追加

TypeScript

Python

.NET

Java

Rust

-6- 最終コード

TypeScript

Python

.NET

Java

Rust

-7- サーバーのテスト

TypeScript

Python

.NET

Java

Rust

-8- Inspectorを使って実行

TypeScript

Python

.NET

Java

Rust

公式 SDK

重要なポイント

サンプル

演習課題

解答例

追加リソース

次にやること

43 KiB

Raw Permalink Blame History