Vercelで始めるMCPサーバー構築入門

import { createMcpHandler } from '@vercel/mcp-adapter';
import { z } from 'zod';
import OpenAI from 'openai';
import * as dotenv from 'dotenv';
import { to } from 'await-to-js';

dotenv.config({ path: '.env.local' });

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const handler = createMcpHandler(server => {
  server.tool(
    'roll_dice',
    'Rolls an N-sided die',
    { sides: z.number().int().min(2) },
    async ({ sides }) => {
      const value = 1 + Math.floor(Math.random() * sides);
      return { content: [{ type: 'text', text: `🎲 You rolled a ${value}!` }] };
    }
  );

  server.tool(
    'generate_text',
    'Generates text based on a prompt using OpenAI API',
    {
      prompt: z.string(),
      max_tokens: z.number().int().min(1).max(4000).optional(),
      temperature: z.number().min(0).max(2).optional(),
      model: z.string().optional()
    },
    async ({ prompt, max_tokens = 1000, temperature = 0.7, model = "gpt-3.5-turbo" }) => {
      const [error, response] = await to(openai.chat.completions.create({
        model,
        messages: [{ role: "user", content: prompt }],
        max_tokens,
        temperature
      }));

      if (error) {
        console.error("OpenAI API error:", error);
        return {
          content: [{
            type: 'text',
            text: `エラーが発生しました: ${error.message || 'Unknown error'}`
          }]
        };
      }

      return {
        content: [{
          type: 'text',
          text: response.choices[0].message.content || "テキスト生成に失敗しました。"
        }]
      };
    }
  );
});

export { handler as GET, handler as POST, handler as DELETE };

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
import { to } from 'await-to-js';

const origin = process.argv[2];
const toolNameToCall = process.argv[3];
const jsonInputString = process.argv[4];

async function main() {
  const transport = new SSEClientTransport(new URL(`${origin}/sse`));

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

  const [connectErr] = await to(client.connect(transport));
  if (connectErr) {
    console.error("Error connecting to server:", connectErr);
    return;
  }

  console.log("Connected", client.getServerCapabilities());

  if (toolNameToCall) {
    let input = jsonInputString ? JSON.parse(jsonInputString) : {};

    if (input.sides !== undefined) {
      input.sides = Number(input.sides);
    }
    console.log(`Calling tool: ${toolNameToCall} with input:`, input);

    const [callErr, result] = await to(client.callTool({
      name: toolNameToCall,
      arguments: input,
    }));

    if (callErr) {
      console.error("Error calling tool:", callErr);
    } else {
      console.log("Tool call result:", result);
    }
  }

  client.close();
}

const [mainErr] = await to(main());
if (mainErr) {
  console.error(mainErr);
}