Deno + Lambda Web Adapterを使ってリモートMCPサーバーをLambdaで動かす

import { McpServer } from "npm:@modelcontextprotocol/sdk/server/mcp.js";

export function createMCPServer() {
  const server = new McpServer({
    name: "sample-mcp-server",
    version: "1.0.0",
  });

  // コイントスツール
  server.registerTool(
    "coin_flip",
    {
      title: "コイントス",
      description: "コインを投げて表(heads)か裏(tails)を返します",
      inputSchema: {},
    },
    () => {
      const result = Math.random() < 0.5 ? "表(heads)" : "裏(tails)";
      return {
        content: [{
          type: "text" as const,
          text: `コインの結果: ${result}`,
        }],
      };
    },
  );

  return server;
}

import express, { type Request, type Response } from "npm:express";
import cors from "npm:cors";
import basicAuth from "npm:basic-auth";
import { StreamableHTTPServerTransport } from "npm:@modelcontextprotocol/sdk/server/streamableHttp.js";
import { createMCPServer } from "./server.ts";

const PORT = parseInt(Deno.env.get("PORT") || "8080");
const USERNAME = Deno.env.get("USERNAME");
const PASSWORD = Deno.env.get("PASSWORD");

if (!USERNAME || !PASSWORD) {
  Deno.exit(1);
}

const app = express();

app.use(cors({
  origin: true,
  credentials: true,
}));

app.use(express.json());

// Basic認証
const authenticate = (req: Request, res: Response, next: () => void) => {
  const credentials = basicAuth(req);

  if (!credentials || credentials.name !== USERNAME || credentials.pass !== PASSWORD) {
    res.status(401).set("WWW-Authenticate", 'Basic realm="Sample MCP Server"').json({
      error: "Authentication required",
    });
    return;
  }

  next();
};

// Streamable HTTPのエンドポイント
app.post("/mcp", authenticate, async (req: Request, res: Response) => {
  try {
    const transport: StreamableHTTPServerTransport = new StreamableHTTPServerTransport({
      sessionIdGenerator: undefined,
    });
    const server = createMCPServer();

    res.on("close", () => {
      console.log("Request closed");
      transport.close();
      server.close();
    });

    await server.connect(transport);
    await transport.handleRequest(req, res, req.body);
  } catch (error) {
    console.error("Error handling MCP request:", error);
    if (!res.headersSent) {
      res.status(500).json({
        jsonrpc: "2.0",
        error: {
          code: -32603,
          message: "Internal server error",
        },
        id: null,
      });
    }
  }
});

app.listen(PORT, () => {
  console.log(`MCP Server running on port ${PORT}`);
  console.log(`MCP endpoint: http://localhost:${PORT}/mcp`);
});

// Lambda関数URL用のエクスポート
export default app;

FROM public.ecr.aws/awsguru/aws-lambda-adapter:0.9.1 AS aws-lambda-adapter
FROM denoland/deno:bin-2.3.6 AS deno_bin
FROM debian:bookworm-20230703-slim AS deno_runtime

COPY --from=aws-lambda-adapter /lambda-adapter /opt/extensions/lambda-adapter
COPY --from=deno_bin /deno /usr/local/bin/deno

EXPOSE 8080
RUN mkdir /var/deno_dir
ENV DENO_DIR=/var/deno_dir

WORKDIR "/var/task"
COPY . /var/task

# Warmup caches
RUN timeout 20s deno task start || [ $? -eq 124 ] || exit 1

CMD ["deno", "task", "start"]

#!/bin/bash

set -e

REGION="ap-northeast-1"
ECR_REGISTRY="123456789012.dkr.ecr.ap-northeast-1.amazonaws.com"
IMAGE_NAME="sample-mcp-server"

aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ECR_REGISTRY

docker build --platform=linux/amd64 -t $IMAGE_NAME .

docker tag $IMAGE_NAME:latest $ECR_REGISTRY/$IMAGE_NAME:latest

docker push $ECR_REGISTRY/$IMAGE_NAME:latest

echo "Deployed to $ECR_REGISTRY/$IMAGE_NAME:latest"

#!/usr/bin/env -S deno run --allow-all

import { App } from "npm:aws-cdk-lib";
import { SampleMcpServerStack } from "./stack.ts";

const app = new App();

const env = {
    account: Deno.env.get("CDK_DEFAULT_ACCOUNT"),
    region: Deno.env.get("CDK_DEFAULT_REGION"),
};

const appContext: AppContext = app.node.tryGetContext("config");
if (!appContext) {
    console.error("Error: 'env' context not found in cdk.json");
    Deno.exit(1);
}

new SampleMcpServerStack(app, 'SampleMcpServerStack', {
    appContext,
    env,
});

export interface AppContext {
    ecrRepoName: string;
}

import { Duration, Stack, StackProps } from "npm:aws-cdk-lib";
import * as lambda from "npm:aws-cdk-lib/aws-lambda";
import * as ecr from "npm:aws-cdk-lib/aws-ecr";
import * as iam from "npm:aws-cdk-lib/aws-iam";
import { Construct } from "npm:constructs";
import { AppContext } from "./app.ts";

export interface SampleMcpServerStackProps extends StackProps {
    appContext: AppContext;
}

export class SampleMcpServerStack extends Stack {
    public readonly mcpServerFunction: lambda.Function;

    constructor(scope: Construct, id: string, props: SampleMcpServerStackProps) {
        super(scope, id, props);

        const lambdaRole = new iam.Role(this, 'McpServerLambdaRole', {
            assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
            managedPolicies: [
                iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSLambdaBasicExecutionRole"),
            ]
        });

        this.mcpServerFunction = new lambda.Function(this, 'McpServerFunction', {
            functionName: 'remote-mcp-server-sample',
            code: lambda.Code.fromEcrImage(
                ecr.Repository.fromRepositoryName(
                    this,
                    `McpServerEcrRepo`,
                    props.appContext.ecrRepoName
                )
            ),
            environment: {
                USERNAME: "hoge",
                PASSWORD: "hoge",
            },
            handler: lambda.Handler.FROM_IMAGE,
            runtime: lambda.Runtime.FROM_IMAGE,
            role: lambdaRole,
            timeout: Duration.seconds(30),
            memorySize: 256,
        });

        this.mcpServerFunction.addFunctionUrl({
            authType: lambda.FunctionUrlAuthType.NONE,
            cors: {
                allowCredentials: true,
                allowedHeaders: ["*"],
                allowedMethods: [lambda.HttpMethod.ALL],
                allowedOrigins: ["*"],
                maxAge: Duration.days(1),
            },
        });
    }

deno run --allow-all npm:aws-cdk --app 'deno run --allow-all cdk/app.ts' deploy

claude mcp add mcp-server-sample --transport http --header "Authorization: Basic $(echo -n 'username:password' | base64)" -- https://xxx.lambda-url.ap-northeast-1.on.aws/mcp

╭─────────────────────────────────────────────────────────────────────╮
│ ✻ Welcome to Claude Code!                                           │
│                                                                     │
│   /help for help, /status for your current setup                    │
│                                                                     │
│   cwd: /Users/sato.naoya/WebstormProjects/remote-mcp-server-sample  │
╰─────────────────────────────────────────────────────────────────────╯

 ※ Tip: Run /install-github-app to tag @claude right from your Github issues and PRs

╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ > コイントスして                                                                                                                                                            │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
> コイントスして
  ⎿  コインの結果: 裏(tails)

⏺ 裏(tails)が出ました。