┌─────────────────────────────────────┐
│         アプリケーション層           │
│    （Claude、OpenClaw など）         │
├─────────────────────────────────────┤
│           MCP クライアント                │
│    （機能探索、ルーティング）  │
├─────────────────────────────────────┤
│         トランスポート層             │
│    （stdio、HTTP/SSE、WebSocket）     │
├─────────────────────────────────────┤
│           MCP サーバー                │
│    （リソース、ツール、プロンプト）      │
├─────────────────────────────────────┤
│         データソース                │
│    （ファイル、API、データベース）         │
└─────────────────────────────────────┘

// github-server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

class GitHubMCPServer {
  private server: Server;

  constructor() {
    this.server = new Server(
      {
        name: "github-mcp-server",
        version: "1.0.0",
      },
      {
        capabilities: {
          resources: {},
          tools: {},
        },
      }
    );

    this.setupHandlers();
  }

返却形式: {"translated": "翻訳されたHTML"}private setupHandlers(): void {
    // 使用可能なツールを一覧表示します
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: "get_repository",
            description: "GitHub からリポジトリ情報を取得します",
            inputSchema: {
              type: "object",
              properties: {
                owner: {
                  type: "string",
                  description: "リポジトリの所有者",
                },
                repo: {
                  type: "string",
                  description: "リポジトリ名",
                },
              },
              required: ["owner", "repo"],
            },
          },
          {
            name: "list_issues",
            description: "リポジトリのオープンなイシューを一覧表示します",
            inputSchema: {
              type: "object",
              properties: {
                owner: { type: "string" },
                repo: { type: "string" },
                state: {
                  type: "string",
                  enum: ["open", "closed", "all"],
                  default: "open",
                },
              },
              required: ["owner", "repo"],
            },
          },
        ],
      };
    });

    // ツール呼び出しを実行します
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;switch (name) {
        case "get_repository":
          return await this.getRepository(args.owner, args.repo);
        case "list_issues":
          return await this.listIssues(args.owner, args.repo, args.state);
        default:
          throw new Error(`不明なツール: ${name}`);
      }
    });

    // 利用可能なリソースを一覧表示
    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
      return {
        resources: [
          {
            uri: "github://trending",
            name: "トレンドのリポジトリ",
            mimeType: "application/json",
            description: "GitHub で現在トレンドになっているリポジトリ",
          },
        ],
      };
    });

    // リソースのコンテンツを読み取る
    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
      const uri = request.params.uri;

      if (uri === "github://trending") {
        const trending = await this.fetchTrending();
        return {
          contents: [
            {
              uri,
              mimeType: "application/json",
              text: JSON.stringify(trending, null, 2),
            },
          ],
        };
      }

      throw new Error(`不明なリソース: ${uri}`);
    });
  }

  private async getRepository(owner: string, repo: string) {
    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`);
    const data = await response.json();return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            name: data.name,
            description: data.description,
            stars: data.stargazers_count,
            forks: data.forks_count,
            language: data.language,
            open_issues: data.open_issues_count,
          }, null, 2),
        },
      ],
    };
  }

  private async listIssues(owner: string, repo: string, state: string = "open") {
    const response = await fetch(
      `https://api.github.com/repos/${owner}/${repo}/issues?state=${state}`
    );
    const data = await response.json();

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            data.map((issue: any) => ({
              number: issue.number,
              title: issue.title,
              state: issue.state,
              created_at: issue.created_at,
            })),
            null,
            2
          ),
        },
      ],
    };
  }

  private async fetchTrending() {
    // 流行（トレンド）のリポジトリを取得するための実装
    return { message: "Trending data would be fetched here" };
  }

  async run(): Promise<void> {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error("GitHub MCP Server running on stdio");
  }
}

// サーバーを起動
const server = new GitHubMCPServer();
server.run().catch(console.error);

{
  "name": "github-mcp-server",
  "version": "1.0.0",
  "type": "module",
  "bin": {
    "github-mcp-server": "./dist/github-server.js"
  },
  "scripts": {
    "build": "tsc",
    "start": "node dist/github-server.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "typescript": "^5.0.0"
  }
}
}

// mcp-client.ts
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

async function createMCPClient() {
  const transport = new StdioClientTransport({
    command: "node",
    args: ["./dist/github-server.js"],
  });

  const client = new Client(
    {
      name: "my-mcp-client",
      version: "1.0.0",
    },
    {
      capabilities: {
        resources: {},
        tools: {},
      },
    }
  );

  await client.connect(transport);

  // 利用可能なツールを発見する
  const tools = await client.listTools();
  console.log("Available tools:", tools.tools.map(t => t.name));

  // 利用可能なリソースを発見する
  const resources = await client.listResources();
  console.log("Available resources:", resources.resources.map(r => r.name));

  // ツールを呼び出す
  const result = await client.callTool({
    name: "get_repository",
    arguments: {
      owner: "anthropics",
      repo: "anthropic-cookbook",
    },
  });

  console.log("Repository info:", result);

this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
  // ストリーミング応答のために
  return {
    content: [
      { type: "text", text: "処理を開始しています..." },
    ],
    isError: false,
  };
});

// サーバー側
this.server.setRequestHandler(SubscribeRequestSchema, async (request) => {
  const uri = request.params.uri;
  // このリソースの変更通知を設定
  this.subscriptions.add(uri);
  return {};
});

// OAuth 2.0 フロー
const authProvider = {
  type: "oauth",
  authorizationUrl: "https://github.com/login/oauth/authorize",
  tokenUrl: "https://github.com/login/oauth/access_token",
  scopes: ["repo", "read:user"],
};

// APIキー
const apiKeyAuth = {
  type: "apiKey",
  headerName: "X-API-Key",
};

// 良い: 単一目的のサーバ
name: "stripe-mcp-server",
capabilities: {
  tools: ["create_payment", "refund_charge", "list_customers"]
}

// 避ける: 万能(キッチンシンク)サーバ
name: "everything-server",
capabilities: {
  tools: ["github_repo", "stripe_payment", "slack_message", "...100 more"]
}

this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
  try {
    const result = await executeTool(request.params);
    return { content: [{ type: "text", text: result }] };
  } catch (error) {
    return {
      content: [{ type: "text", text: `Error: ${error.message}` }],
      isError: true,
    };
  }
});

{
  name: "complex_query",
  description: `フィルタリング付きで複雑なデータベースクエリを実行します。

  パラメータ:
  - table: クエリ対象のテーブル名
  - filters: {column, operator, value} オブジェクトの配列
  - limit: 返す最大行数（デフォルト: 100）

  例:
  {
    "table": "users",
    "filters": [{"column": "active", "operator": "=", "value": true}],
    "limit": 50
  }`,
  inputSchema: { /* ... */ }
}

import { RateLimiter } from "limiter";

const limiter = new RateLimiter({ tokensPerInterval: 100, interval: "minute" });

async function rateLimitedFetch(url: string) {
  await limiter.removeTokens(1);
  return fetch(url);
}