MCPServer

import { openai } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { MCPServer, createMCPTool } 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 = createMCPTool({
  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({
  // 上記の設定例
});
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: "これはデータファイルの内容です。" },
};
 
const myResourceTemplates: ResourceTemplate[] = [
  {
    uriTemplate: "file://data/{id}",
    name: "Data File",
    description: "データを含むファイル。",
    mimeType: "text/plain",
  },
];
 
const myResourceHandlers: MCPServerResources = {
  listResources: async () => myResources,
  getResourceContent: async ({ uri }) => {
    if (myResourceContents[uri]) {
      return myResourceContents[uri];
    }
    throw new Error(`${uri}のリソースコンテンツが見つかりません`);
  },
  resourceTemplates: async () => myResourceTemplates,
};
 
const serverWithResources = new MCPServer({
  name: "Resourceful Server",
  version: "1.0.0",
  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: "コードの改善点を分析",
    version: "v1"
  },
  {
    name: "analyze-code",
    description: "コードの改善点を分析（新しいロジック）",
    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("プロンプトバージョンが見つかりません");
        return {
          prompt,
          messages: [
            {
              role: "user",
              content: { type: "text", text: `新しいロジックでこのコードを分析してください：${args.code}` }
            }
          ]
        };
      }
      // デフォルトまたはv1
      const prompt = prompts.find(p => p.name === name && p.version === "v1");
      if (!prompt) throw new Error("プロンプトバージョンが見つかりません");
      return {
        prompt,
        messages: [
          {
            role: "user",
            content: { type: "text", text: `このコードを分析してください：${args.code}` }
          }
        ]
      };
    }
    throw new Error("プロンプトが見つかりません");
  }
};
 
const serverWithPrompts = new MCPServer({
  name: "Promptful Server",
  version: "1.0.0",
  tools: { /* ... */ },
  prompts: myPromptHandlers,
});

await serverWithPrompts.prompts.notifyListChanged();

execute: async (params, { elicitation, extra }) => {
  // params には検証済みのツール入力パラメータが含まれます
  // elicitation はユーザーとの対話機能を提供します
  // extra には MCP 固有のコンテキスト (認証、セッションなど) が含まれます
  
  // 認証情報へのアクセス (利用可能な場合)
  if (extra?.authInfo) {
    console.log('Authenticated request from:', extra.authInfo.clientId);
  }
  
  // Elicitation 機能を使用
  const result = await elicitation.sendRequest({
    message: "Please provide information",
    requestedSchema: { /* schema */ }
  });
  
  return result;
}

import { MCPServer, createMCPTool } from "@mastra/mcp";
import { z } from "zod";
 
const server = new MCPServer({
  name: "Interactive Server",
  version: "1.0.0",
  tools: {
    collectContactInfo: createMCPTool({
      id: "collectContactInfo",
      description: "Collects user contact information through elicitation",
      inputSchema: z.object({
        reason: z.string().optional().describe("Reason for collecting contact info"),
      }),
      execute: async (params, { context, elicitation, extra }) => {
        const { reason } = params;
        
        // 利用可能であればセッション情報をログ出力
        console.log('Request from session:', extra?.sessionId);
 
        try {
          // Elicitation 経由でユーザー入力をリクエスト
          const result = await elicitation.sendRequest({
            message: reason 
              ? `Please provide your contact information. ${reason}`
              : 'Please provide your contact information',
            requestedSchema: {
              type: 'object',
              properties: {
                name: {
                  type: 'string',
                  title: 'Full Name',
                  description: 'Your full name',
                },
                email: {
                  type: 'string',
                  title: 'Email Address', 
                  description: 'Your email address',
                  format: 'email',
                },
                phone: {
                  type: 'string',
                  title: 'Phone Number',
                  description: 'Your phone number (optional)',
                },
              },
              required: ['name', 'email'],
            },
          });
 
          // ユーザーのレスポンスを処理
          if (result.action === 'accept') {
            return `Contact information collected: ${JSON.stringify(result.content, null, 2)}`;
          } else if (result.action === 'decline') {
            return 'Contact information collection was declined by the user.';
          } else {
            return 'Contact information collection was cancelled by the user.';
          }
        } catch (error) {
          return `Error collecting contact information: ${error}`;
        }
      },
    }),
  },
});

{
  type: 'object',
  properties: {
    name: {
      type: 'string',
      title: '氏名',
      description: 'フルネームを入力してください',
    },
    age: {
      type: 'number',
      title: '年齢',
      minimum: 18,
      maximum: 120,
    },
    newsletter: {
      type: 'boolean',
      title: 'ニュースレターを購読する',
      default: false,
    },
  },
  required: ['name'],
}

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

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

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