Next.js + Mastra環境でMCPを使うのは難しい。。 #bedrock – Qiita

  import { mastra } from "@/mastra";
+ import { MCPClient } from "@mastra/mcp";
  
  // Allow streaming responses up to 30 seconds
  export const maxDuration = 30;
  
  export async function POST(req: Request) {
+   const mcp = new MCPClient({
+     servers: {
+       playwright: {
+         command: "docker",
+         args: [
+           "run",
+           "-i",
+           "--rm",
+           "--init",
+           "mcr.microsoft.com/playwright/mcp",
+         ],
+       },
+     },
+   });
  
    const { messages } = await req.json();
  
    const myAgent = mastra.getAgent("myAgent");

-   const result = await myAgent.stream(messages);
+   const result = await myAgent.stream(messages, {
+     toolsets: await mcp.getToolsets(),
+   });
  
    return result.toDataStreamResponse();
  }

try{
    return result.toDataStreamResponse();
} finally {
    mcp.disconnect()
}

import { mastra } from "@/mastra";
import { MCPClient } from "@mastra/mcp";

// Allow streaming responses up to 30 seconds
export const maxDuration = 30;

export async function POST(req: Request) {
  // 各リクエストで独立したMCPClientを作成（ユニークなIDを使用）
  const requestId = `mcp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  const mcp = new MCPClient({
    id: requestId, // メモリリーク防止のためのユニークID
    servers: {
      playwright: {
        command: "docker",
        args: [
          "run",
          "-i",
          "--rm",
          "--init",
          "mcr.microsoft.com/playwright/mcp",
        ],
      },
    },
  });

  // クリーンアップ関数
  const cleanup = async () => {
    try {
      await mcp.disconnect();
      console.log(`MCP Client ${requestId} disconnected`);
    } catch (error) {
      console.error(`Error disconnecting MCP Client ${requestId}:`, error);
    }
  };

  // リクエストがキャンセルされた場合のクリーンアップ
  req.signal?.addEventListener('abort', () => {
    console.log(`Request ${requestId} aborted, cleaning up...`);
    cleanup();
  });

  try {
    const { messages } = await req.json();
    const myAgent = mastra.getAgent("myAgent");

    const result = await myAgent.stream(messages, {
      toolsets: await mcp.getToolsets(),
    });

    // ストリーミングレスポンスを取得
    const response = result.toDataStreamResponse();
    
    // レスポンスのbodyストリームをラップして、完了時にクリーンアップを実行
    const originalBody = response.body;
    if (originalBody) {
      let cleanupCalled = false;
      
      const safeCleanup = async () => {
        if (!cleanupCalled) {
          cleanupCalled = true;
          await cleanup();
        }
      };

      const wrappedStream = new ReadableStream({
        start(controller) {
          const reader = originalBody.getReader();
          
          const pump = async () => {
            try {
              while (true) {
                const { done, value } = await reader.read();
                
                if (done) {
                  controller.close();
                  // ストリーム完了時にクリーンアップ
                  await safeCleanup();
                  break;
                }
                
                controller.enqueue(value);
              }
            } catch (error) {
              controller.error(error);
              // エラー時もクリーンアップ
              await safeCleanup();
            }
          };
          
          pump();
        },
        cancel() {
          // ストリームがキャンセルされた時もクリーンアップ
          safeCleanup();
        }
      });

      // 新しいレスポンスを作成
      return new Response(wrappedStream, {
        headers: response.headers,
        status: response.status,
        statusText: response.statusText,
      });
    }

    // bodyがない場合は元のレスポンスを返してクリーンアップ
    await cleanup();
    return response;

  } catch (error) {
    console.error("Error in chat2 API:", error);
    // エラー時もクリーンアップ
    await cleanup();
    
    return new Response(
      JSON.stringify({ error: "Internal server error" }),
      {
        status: 500,
        headers: { "Content-Type": "application/json" },
      }
    );
  }
}