AWS のサービスとリソースを学習および管理するためのカスタム MCP クライアントを作成する

{
  "name": "amazon-ivs-mcp-client-demo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "private": false,
  "engines": {
    "node": ">= 14.0.0",
    "npm": ">= 6.0.0"
  },
  "homepage": "",
  "repository": {
    "type": "git",
    "url": ""
  },
  "bugs": "",
  "keywords": [],
  "contributors": [],
  "scripts": {
    "dev": "",
    "test": ""
  },
  "dependencies": {
    "@aws-sdk/client-bedrock-runtime": "^3.774.0",
    "@modelcontextprotocol/sdk": "^1.7.0"
  }
}

Amazon IVS MCP Client

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
import { BedrockRuntimeClient, ConverseCommand } from '@aws-sdk/client-bedrock-runtime';
import readline from 'node:readline';
import util from 'node:util';
import fs from 'node:fs';

const banner = fs.readFileSync('banner.txt', 'utf8');
const printBanner = () => {
  const red = '\x1b[31m';
  const reset = '\x1b[0m';
  console.log(`\n${red}${banner}${reset}\n`);
};
printBanner();

const MAX_TURNS = 75;
let currentTurn = 0;

const IVS_SERVER_PATH = process.env.IVS_SERVER_PATH;
if (!IVS_SERVER_PATH) {
  throw new Error('IVS_SERVER_PATH environment variable is not set. This variable must point to the custom IVS MCP Server on this machine!');
}
if (!fs.existsSync(IVS_SERVER_PATH)) {
  throw new Error(`IVS_SERVER_PATH environment variable is set to ${IVS_SERVER_PATH} but this path does not exist!`);
}

const VERBOSE = process.env.VERBOSE?.toLowerCase() === 'true' || false;

// a list of allowed dirs for the Filesystem MCP server
// ex: ALLOWED_DIRS="/path/to/dir,/another/dir"
const allowedDirs = process.env.ALLOWED_DIRS.split(',');
const MODEL_ID = process.env.MODEL_ID || 'us.anthropic.claude-3-7-sonnet-20250219-v1:0';
const bedrockRuntimeClient = new BedrockRuntimeClient({
  region: process.env.AWS_REGION,
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  },
});

let sessionMessages = [];
let sessionUsage = [];

const ivsTransport = new StdioClientTransport({
  command: "node",
  args: [IVS_SERVER_PATH],
  env: {
    ...process.env,
    RAG_KNOWLEDGEBASE_ID: process.env.RAG_KNOWLEDGEBASE_ID,
    AWS_ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID,
    AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY,
    AWS_REGION: process.env.AWS_REGION,
  }
});

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

await ivsClient.connect(ivsTransport);

const fileSystemTransport = new StdioClientTransport({
  command: "npx",
  args: [
    "-y",
    "@modelcontextprotocol/server-filesystem",
    ...allowedDirs,
  ],
});

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

await fileSystemClient.connect(fileSystemTransport);

const availableTools = {
  ivs: (await ivsClient.listTools()),
  filesystem: (await fileSystemClient.listTools())
};
const clients = {
  ivs: ivsClient,
  filesystem: fileSystemClient
};

const sleep = (ms) => {
  return new Promise(resolve => setTimeout(resolve, ms));
};

const startThinking = () => {
  const characters = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
  const cursorEsc = {
    hide: '\u001B[?25l',
    show: '\u001B[?25h',
  };
  process.stdout.write(cursorEsc.hide);

  let i = 0;
  const timer = setInterval(function () {
    process.stdout.write('\r' + characters[i++] + ' Thinking...');
    i = i >= characters.length ? 0 : i;
  }, 150);

  return () => {
    clearInterval(timer);
    process.stdout.write('\r');
    process.stdout.write(cursorEsc.show);
    process.stdout.write('\n');
  };
};

const bedrockConverse = async (messages) => {
  const stopThinking = startThinking();
  const inferenceConfig = {
    topP: 0.1,
    temperature: 0.2,
  };
  const input = {
    modelId: MODEL_ID,
    messages,
    inferenceConfig,
    toolConfig: toolsToBedrockSchema(availableTools),
    system: [
      {
        text: `Your specialty is Amazon Interactive Video Service (Amazon IVS). 
        Wherever possible, take advantage of the tools available to you to help users 
        learn as much as possible about Amazon IVS. 
        If you are asked to generate or evaluate code, you can query IVS 
        knowledge base tool to query for the latest documentation. 
        Since IVS is a newer service, with new versions being published often, 
        reinforce your knowledge by directly fetching the latest version of any 
        documentation returned from the knowledge base.
        If you are asked to edit a file, first summarize your changes and ask the user 
        to confirm them before writing or editing any file on the filesystem.`
      }
    ],
  };
  const converseRequest = new ConverseCommand(input);
  let converseResponse;
  try {
    converseResponse = await bedrockRuntimeClient.send(converseRequest);
  }
  catch (error) {
    stopThinking();
    if (error.name == 'ThrottlingException') {
      console.log(`🛑 Bedrock API Call Throttled. Trying again after 60 second cooldown...`);
      await sleep(60000);
      return await bedrockConverse(messages);
    }
    else {
      console.error(error);
    }
  }
  stopThinking();
  return converseResponse;
};

const toolsToBedrockSchema = (availableTools) => {
  const tools = [];
  Object.keys(availableTools).forEach((server) => {
    tools.push(availableTools[server].tools.map(tool => {
      let props = {};
      Object.keys(tool.inputSchema.properties).forEach(prop => {
        props[prop] = {
          "type": tool.inputSchema.properties[prop].type,
          "description": tool.inputSchema.properties[prop]?.description || prop,
        };
      });
      return {
        "toolSpec": {
          "name": tool.name,
          "description": tool?.description || tool.name,
          "inputSchema": {
            "json": {
              "type": tool.inputSchema.type,
              "properties": props,
              "required": tool.inputSchema.required || []
            }
          }
        }
      };
    }));
  });
  return {
    tools: tools.flat()
  };
};

const findClient = (toolName) => {
  let client;
  Object.keys(availableTools).forEach((label) => {
    const tool = availableTools[label].tools.find(tool => tool.name === toolName);
    if (tool) client = clients[label];
  });
  return client;
};

const useTool = async (response) => {
  const item = response.output.message.content.find(item => Object.keys(item).indexOf('toolUse') > -1);
  const toolInfo = item.toolUse;
  console.log(`🔨 Calling MCP Server tool '${toolInfo.name}' ${VERBOSE ? 'with input: ' : ''}`);
  if (VERBOSE) {
    console.log(util.inspect(toolInfo?.input, {
      showHidden: false,
      depth: 20,
      colors: true,
    }));
  }
  await callTool(toolInfo);
  console.log(`🔎 Sending MCP Server's '${toolInfo.name}' response to Bedrock...`);
  return await bedrockConverse(sessionMessages);
};

const callTool = async (toolInfo) => {
  try {
    const toolName = toolInfo.name;
    const client = findClient(toolName);
    const result = await client.callTool({ name: toolName, arguments: toolInfo.input });
    sessionMessages.push({
      role: "user",
      content: [{ toolResult: { ...result, toolUseId: toolInfo.toolUseId } }]
    });
    return sessionMessages;
  }
  catch (error) {
    console.error('Error handling tool call:', error);
    return [`[Error calling tool ${toolInfo?.name || 'unknown'}: ${error.message}]`];
  }
};

const handleResponse = async (response) => {
  let ret = { isFinished: true, response };
  if (VERBOSE) {
    console.log(util.inspect(response, {
      showHidden: false,
      depth: 20,
      colors: true,
    }));
  }
  if (response?.output?.message?.content[0]?.text) {
    // bedrock output
    console.log('\n🟢 ' + response?.output?.message?.content[0]?.text + '\n');
  };
  if (response.stopReason === 'tool_use') {
    response = await useTool(response);
    sessionMessages.push(response.output.message);
    ret = { isFinished: false, response };
  }
  return ret;
};

const handlePrompt = async (prompt) => {
  sessionMessages.push({
    role: "user",
    content: [{ text: prompt }],
  });
  let response = await bedrockConverse(sessionMessages);
  updateUsage(response?.usage);
  sessionMessages.push(response.output.message);
  let isFinished = false;
  currentTurn = 0;
  while (!isFinished) {
    currentTurn++;
    const processedResponse = await handleResponse(response);
    isFinished = processedResponse.isFinished;
    response = processedResponse.response;
    updateUsage(response?.usage);
    if (response.stopReason === 'tool_use' && currentTurn >= MAX_TURNS && !isFinished) {
      console.log(`🚨 Reached max turns (${MAX_TURNS}). Let's stop here...`);
      const item = response.output.message.content.find(item => Object.keys(item).indexOf('toolUse') > -1);
      sessionMessages.push({
        role: "user",
        content: [
          {
            toolResult: {
              toolUseId: item.toolUse.toolUseId,
              content: [{
                text: 'Reached the maximum number of turns. Provide a detailed summary of your progress so far.',
              }]
            }
          }
        ]
      });
      response = await bedrockConverse(sessionMessages);
      if (response?.output?.message?.content[0]?.text === undefined) {
        console.log(`⚠️  Bedrock response was empty. Trying again...`);
        sessionMessages.push({
          role: 'user',
          content: [{
            text: 'Reached the maximum number of turns. Provide a detailed summary of your progress so far.'
          }]
        });
        response = await bedrockConverse(sessionMessages);
      }
      await handleResponse(response);
      isFinished = true;
    }
  };
};

const updateUsage = (usage) => {
  if (!usage) return;
  sessionUsage.push(usage);
};

const getSessionUsage = () => {
  return sessionUsage.reduce((acc, cur) => {
    acc.inputTokens += cur.inputTokens;
    acc.outputTokens += cur.outputTokens;
    acc.totalTokens += cur.totalTokens;
    return acc;
  }, { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
};

const printUsage = (label = true) => {
  console.log(`📈 ${label ? 'Current Session Usage: ' : ''}${util.inspect(getSessionUsage(), { colors: true, depth: null })}`);
};

const init = () => {
  console.log(`\n❓ Ask a question, or try the following commands: clear-context, session-usage. Use 'quit' to exit.\n`);

  let userInput = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    historySize: 50,
    prompt: '\x1b[34m> \x1b[0m',
  });
  userInput.on('line', async (prompt) => {
    switch (prompt) {
      case 'help':
        console.log(`❓ Ask a question, or try the following commands: clear-context, session-usage. Use 'quit' to exit.`);
        break;
      case 'quit':
      case 'exit':
        console.log(`✌️ Thanks for using the IVS MCP Client.`);
        printUsage();
        process.exit(0);
        break;
      case 'clear-context':
      case 'clear':
        sessionMessages = [];
        console.log('🧹 Session context window cleared.');
        console.log('⭐️ Let\'s start over!');
        break;
      case 'session-usage':
      case 'usage':
        printUsage();
        break;
      default:
        await handlePrompt(prompt);
        break;
    }
    userInput.prompt();
  });
  userInput.on('SIGINT', () => {
    console.log(`\n✌️ Thanks for using the IVS MCP Client.`);
    printUsage();
    process.exit(0);
  });
  userInput.prompt();
};

init();