MCPServer

import { openai } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { createTool } from "@mastra/core/tools";
import { MCPServer } from "@mastra/mcp";
import { z } from "zod";
import { dataProcessingWorkflow } from "../workflows/dataProcessingWorkflow";
 
const myAgent = new Agent({
  name: "MyExampleAgent",
  description: "A generalist to help with basic questions."
  instructions: "You are a helpful assistant.",
  model: openai("gpt-4o-mini"),
});
 
const weatherTool = createTool({
  id: "getWeather",
  description: "Gets the current weather for a location.",
  inputSchema: z.object({ location: z.string() }),
  execute: async ({ context }) => `Weather in ${context.location} is sunny.`,
});
 
const server = new MCPServer({
  name: "My Custom Server",
  version: "1.0.0",
  tools: { weatherTool },
  agents: { myAgent }, // このエージェントはツール「ask_myAgent」になります
  workflows: {
    dataProcessingWorkflow, // このワークフローはツール「run_dataProcessingWorkflow」になります
  }
});

async startStdio(): Promise<void>

const server = new MCPServer({
  // example configuration above
});
await server.startStdio();

async startSSE({
  url,
  ssePath,
  messagePath,
  req,
  res,
}: {
  url: URL;
  ssePath: string;
  messagePath: string;
  req: any;
  res: any;
}): Promise<void>

import http from "http";
 
const httpServer = http.createServer(async (req, res) => {
  await server.startSSE({
    url: new URL(req.url || "", `http://localhost:1234`),
    ssePath: "/sse",
    messagePath: "/message",
    req,
    res,
  });
});
 
httpServer.listen(PORT, () => {
  console.log(`HTTP server listening on port ${PORT}`);
});

async startHonoSSE({
  url,
  ssePath,
  messagePath,
  req,
  res,
}: {
  url: URL;
  ssePath: string;
  messagePath: string;
  req: any;
  res: any;
}): Promise<void>

import http from "http";
 
const httpServer = http.createServer(async (req, res) => {
  await server.startHonoSSE({
    url: new URL(req.url || "", `http://localhost:1234`),
    ssePath: "/hono-sse",
    messagePath: "/message",
    req,
    res,
  });
});
 
httpServer.listen(PORT, () => {
  console.log(`HTTP server listening on port ${PORT}`);
});

async startHTTP({
  url,
  httpPath,
  req,
  res,
  options = { sessionIdGenerator: () => randomUUID() },
}: {
  url: URL;
  httpPath: string;
  req: http.IncomingMessage;
  res: http.ServerResponse<http.IncomingMessage>;
  options?: StreamableHTTPServerTransportOptions;
}): Promise<void>

import http from "http";
 
const httpServer = http.createServer(async (req, res) => {
  await server.startHTTP({
    url: new URL(req.url || '', 'http://localhost:1234'),
    httpPath: `/mcp`,
    req,
    res,
    options: {
      sessionIdGenerator: undefined,
    },
  });
});
 
httpServer.listen(PORT, () => {
  console.log(`HTTP server listening on port ${PORT}`);
});

async close(): Promise<void>

getServerInfo(): ServerInfo

getServerDetail(): ServerDetail

getToolListInfo(): ToolListInfo

getToolInfo(toolName: string): ToolInfo

executeTool(toolName: string, input: any): Promise<any>

getStdioTransport(): StdioServerTransport | undefined

getSseTransport(): SSEServerTransport | undefined

getSseHonoTransport(): SSETransport | undefined

getStreamableHTTPTransport(): StreamableHTTPServerTransport | undefined

async executeTool(
  toolId: string,
  args: any,
  executionContext?: { messages?: any[]; toolCallId?: string },
): Promise<any>

export type MCPServerResources = {
  // 利用可能なリソースを一覧するコールバック
  listResources: () => Promise<Resource[]>;
 
  // 特定のリソースの内容を取得するコールバック
  getResourceContent: ({
    uri,
  }: {
    uri: string;
  }) => Promise<MCPServerResourceContent | MCPServerResourceContent[]>;
 
  // 利用可能なリソーステンプレートを一覧する任意のコールバック
  resourceTemplates?: () => Promise<ResourceTemplate[]>;
};
 
export type MCPServerResourceContent = { text?: string } | { blob?: string };

import { MCPServer } from "@mastra/mcp";
import type {
  MCPServerResourceContent,
  Resource,
  ResourceTemplate,
} from "@mastra/mcp";
 
// リソースやリソーステンプレートは、通常は動的に取得されます。
const myResources: Resource[] = [
  { uri: "file://data/123.txt", name: "Data File", mimeType: "text/plain" },
];
 
const myResourceContents: Record<string, MCPServerResourceContent> = {
  "file://data.txt/123": { text: "This is the content of the data file." },
};
 
const myResourceTemplates: ResourceTemplate[] = [
  {
    uriTemplate: "file://data/{id}",
    name: "Data File",
    description: "A file containing data.",
    mimeType: "text/plain",
  },
];
 
const myResourceHandlers: MCPServerResources = {
  listResources: async () => myResources,
  getResourceContent: async ({ uri }) => {
    if (myResourceContents[uri]) {
      return myResourceContents[uri];
    }
    throw new Error(`Resource content not found for ${uri}`);
  },
  resourceTemplates: async () => myResourceTemplates,
};
 
const serverWithResources = new MCPServer({
  name: "Resourceful Server",
  version: "1.0.0",
  tools: {
    /* ... your tools ... */
  },
  resources: myResourceHandlers,
});

async server.resources.notifyUpdated({ uri: string }): Promise<void>

// 'file://data.txt' の内容を更新した後
await serverWithResources.resources.notifyUpdated({ uri: "file://data.txt" });

async server.resources.notifyListChanged(): Promise<void>

// 'myResourceHandlers.listResources' が管理する一覧に新しいリソースを追加した後
await serverWithResources.resources.notifyListChanged();

export type MCPServerPrompts = {
  // 利用可能なプロンプトを一覧するコールバック
  listPrompts: () => Promise<Prompt[]>;
 
  // 特定のプロンプトのメッセージ/コンテンツを取得するコールバック
  getPromptMessages?: ({
    name,
    version,
    args,
  }: {
    name: string;
    version?: string;
    args?: any;
  }) => Promise<{ prompt: Prompt; messages: PromptMessage[] }>;
};

import { MCPServer } from "@mastra/mcp";
import type { Prompt, PromptMessage, MCPServerPrompts } from "@mastra/mcp";
 
const prompts: Prompt[] = [
  {
    name: "analyze-code",
    description: "Analyze code for improvements",
    version: "v1"
  },
  {
    name: "analyze-code",
    description: "Analyze code for improvements (new logic)",
    version: "v2"
  }
];
 
const myPromptHandlers: MCPServerPrompts = {
  listPrompts: async () => prompts,
  getPromptMessages: async ({ name, version, args }) => {
    if (name === "analyze-code") {
      if (version === "v2") {
        const prompt = prompts.find(p => p.name === name && p.version === "v2");
        if (!prompt) throw new Error("Prompt version not found");
        return {
          prompt,
          messages: [
            {
              role: "user",
              content: { type: "text", text: `Analyze this code with the new logic: ${args.code}` }
            }
          ]
        };
      }
      // デフォルトまたは v1
      const prompt = prompts.find(p => p.name === name && p.version === "v1");
      if (!prompt) throw new Error("Prompt version not found");
      return {
        prompt,
        messages: [
          {
            role: "user",
            content: { type: "text", text: `Analyze this code: ${args.code}` }
          }
        ]
      };
    }
    throw new Error("Prompt not found");
  }
};
 
const serverWithPrompts = new MCPServer({
  name: "Promptful Server",
  version: "1.0.0",
  tools: { /* ... */ },
  prompts: myPromptHandlers,
});

await serverWithPrompts.prompts.notifyListChanged();

execute: async ({ context }, options) => {
  // context にはツールの入力パラメータが含まれます
  // options にはエリシテーションや認証情報などのサーバー機能が含まれます
  
  // 認証情報にアクセス（利用可能な場合）
  if (options.extra?.authInfo) {
    console.log('Authenticated request from:', options.extra.authInfo.clientId);
  }
  
  // エリシテーション機能を使用
  const result = await options.elicitation.sendRequest({
    message: "Please provide information",
    requestedSchema: { /* schema */ }
  });
  
  return result;
}

import { MCPServer } from "@mastra/mcp";
import { createTool } from "@mastra/core/tools";
import { z } from "zod";
 
const server = new MCPServer({
  name: "Interactive Server",
  version: "1.0.0",
  tools: {
    collectContactInfo: createTool({
      id: "collectContactInfo",
      description: "エリシテーションを通じてユーザーの連絡先情報を収集します",
      inputSchema: z.object({
        reason: z.string().optional().describe("連絡先情報を収集する理由"),
      }),
      execute: async ({ context }, options) => {
        const { reason } = context;
        
        // セッション情報があればログに記録
        console.log('Request from session:', options.extra?.sessionId);
 
        try {
          // エリシテーションでユーザー入力を要求
          const result = await options.elicitation.sendRequest({
            message: reason 
              ? `連絡先情報をご提供ください。${reason}`
              : '連絡先情報をご提供ください',
            requestedSchema: {
              type: 'object',
              properties: {
                name: {
                  type: 'string',
                  title: '氏名',
                  description: 'フルネーム',
                },
                email: {
                  type: 'string',
                  title: 'メールアドレス', 
                  description: 'あなたのメールアドレス',
                  format: 'email',
                },
                phone: {
                  type: 'string',
                  title: '電話番号',
                  description: 'あなたの電話番号（任意）',
                },
              },
              required: ['name', 'email'],
            },
          });
 
          // ユーザーの応答を処理
          if (result.action === 'accept') {
            return `連絡先情報を収集しました: ${JSON.stringify(result.content, null, 2)}`;
          } else if (result.action === 'decline') {
            return 'ユーザーが連絡先情報の収集を拒否しました。';
          } else {
            return 'ユーザーが連絡先情報の収集をキャンセルしました。';
          }
        } catch (error) {
          return `連絡先情報の収集中にエラーが発生しました: ${error}`;
        }
      },
    }),
  },
});

{
  type: 'object',
  properties: {
    name: {
      type: 'string',
      title: 'Full Name',
      description: 'Your complete name',
    },
    age: {
      type: 'number',
      title: 'Age',
      minimum: 18,
      maximum: 120,
    },
    newsletter: {
      type: 'boolean',
      title: 'Subscribe to Newsletter',
      default: false,
    },
  },
  required: ['name'],
}

// ツールの execute 関数内
execute: async ({ context }, options) => {
  // ユーザー入力にエリシテーションを使用
  const result = await options.elicitation.sendRequest({
    message: string,           // ユーザーに表示するメッセージ
    requestedSchema: object    // 期待される応答構造を定義する JSON スキーマ
  }): Promise<ElicitResult>
  
  // 必要に応じて認証情報にアクセス
  if (options.extra?.authInfo) {
    // options.extra.authInfo.token などを使用
  }
}

type ElicitResult = {
  action: 'accept' | 'decline' | 'cancel';
  content?: any; // action が 'accept' の場合にのみ存在
}

execute: async ({ context }, options) => {
  if (!options.extra?.authInfo?.token) {
    return "Authentication required";
  }
  
  // 認証トークンを使用
  const response = await fetch('/api/data', {
    headers: { Authorization: `Bearer ${options.extra.authInfo.token}` },
    signal: options.extra.signal,
  });
  
  return response.json();
}