Merge branch 'main' into mcp-stateless-ecs

Author: krokoko

samples/mcp-stateless-lambda/.gitignore

@@ -1,4 +1,4 @@
-*.js
+
 !jest.config.js
 *.d.ts
 node_modules

samples/mcp-stateless-lambda/README.md

@@ -49,7 +49,7 @@ Default output format [None]: json
 ```
 
 - Node.js: v18.12.1
-- [AWS CDK](https://github.com/aws/aws-cdk/releases/tag/v2.114.0): 2.114.0
+- [AWS CDK](https://github.com/aws/aws-cdk/releases/tag/v2.189.1): 2.189.1
 - jq: jq-1.6
 
 ### Deploy the solution

samples/mcp-stateless-lambda/lambdas/authorizer/index.js

@@ -0,0 +1,28 @@
+
+export const handler = async (event) => {
+    const authToken = event.authorizationToken;
+    if (!authToken) {
+        return generatePolicy('Deny', event.methodArn);
+    }
+
+    if (authToken === 'Bearer good_access_token') {
+        return generatePolicy('Allow', event.methodArn);
+    }
+
+    return generatePolicy('Deny', event.methodArn);
+
+};
+
+const generatePolicy = (effect, resource) => {
+    return {
+        principalId: 'user',
+        policyDocument: {
+            Version: '2012-10-17',
+            Statement: [{
+                Action: 'execute-api:Invoke',
+                Effect: effect,
+                Resource: resource
+            }]
+        }
+    };
+};

samples/mcp-stateless-lambda/lambdas/mcpserver/index.js

@@ -0,0 +1,36 @@
+import './logging.js';
+import log4js from 'log4js';
+import express from 'express';
+import metadata from './metadata.js';
+import transport from './transport.js';
+
+await metadata.init();
+
+const l = log4js.getLogger();
+const PORT = 3000;
+
+// This function is using Lambda Web Adapter to run express.js on Lambda
+// https://github.com/awslabs/aws-lambda-web-adapter
+const app = express();
+app.use(express.json());
+
+app.get('/health', (req, res) => {
+    res.json(metadata.all);
+});
+
+app.use(async (req, res, next) => {
+    l.debug(`> ${req.method} ${req.originalUrl}`);
+    l.debug(req.body);
+    // l.debug(req.headers);
+    return next();
+});
+
+await transport.bootstrap(app); 
+
+app.listen(PORT, () => {
+    l.debug(metadata.all);
+    l.debug(`listening on http://localhost:${PORT}`);
+});
+
+
+

samples/mcp-stateless-lambda/lambdas/mcpserver/logging.js

@@ -0,0 +1,23 @@
+import log4js from 'log4js';
+
+const layout = {
+    type: 'pattern',
+    pattern: '%p [%f{1}:%l:%M] %m%'
+}
+
+log4js.configure({
+    appenders: {
+        stdout: {
+            type: 'stdout',
+            enableCallStack: true,
+            layout
+        }
+    },
+    categories: {
+        default: {
+            appenders: ['stdout'],
+            level: 'debug',
+            enableCallStack: true
+        }
+    }
+});

samples/mcp-stateless-lambda/lambdas/mcpserver/mcp-errors.js

@@ -0,0 +1,35 @@
+const TEMPLATE = {
+    jsonrpc: '2.0',
+    error: {
+        code: 0,
+        message: 'n/a',
+    },
+    id: null,
+};
+
+function build(code, message){
+    const result = {...TEMPLATE};
+    result.error.code = code;
+    result.error.message = message;
+    return result;
+}
+
+
+export default {
+    get internalServerError(){
+        return build(-32603, 'Internal Server Error');
+    },
+
+    get noValidSessionId(){
+        return build(-32000, 'No valid session ID');
+    },
+
+    get invalidOrMissingSessionId(){
+        return build(-32000, 'Invalid or missing session ID');
+    },
+
+    get methodNotAllowed(){
+        return build(-32000, 'Method not allowed');
+    }
+
+}

samples/mcp-stateless-lambda/lambdas/mcpserver/mcp-server.js

@@ -0,0 +1,42 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import metadata from "./metadata.js";
+
+let SHORT_DELAY = true;
+const LONG_DELAY_MS = 100;
+const SHORT_DELAY_MS = 50;
+
+const create = () => {
+  const mcpServer = new McpServer({
+    name: "demo-mcp-server",
+    version: metadata.version
+  }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+
+  mcpServer.tool("ping", async () => {
+    const startTime = Date.now();
+    SHORT_DELAY=!SHORT_DELAY;
+
+    if (SHORT_DELAY){
+      await new Promise((resolve) => setTimeout(resolve, SHORT_DELAY_MS));
+    } else {
+      await new Promise((resolve) => setTimeout(resolve, LONG_DELAY_MS));
+    }
+    const duration = Date.now() - startTime;
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `pong! logStream=${metadata.logStreamName} v=${metadata.version} d=${duration}`
+        }
+      ]
+    }
+  });
+
+  return mcpServer
+};
+
+export default { create };

samples/mcp-stateless-lambda/lambdas/mcpserver/metadata.js

@@ -0,0 +1,25 @@
+import packageInfo from './package.json' with { type: 'json'};
+
+const metadata = {
+}
+
+async function init() {
+    metadata.version = packageInfo.version;
+    metadata.logStreamName = process.env.AWS_LAMBDA_LOG_STREAM_NAME || 'unknown';
+}
+
+export default {
+    init,
+
+    get all() {
+        return metadata;
+    },
+
+    get version() {
+        return metadata.version;
+    },
+    
+    get logStreamName() {
+        return metadata.logStreamName;
+    }
+};

samples/mcp-stateless-lambda/lambdas/mcpserver/transport.js

@@ -0,0 +1,49 @@
+import log4js from 'log4js';
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import mcpServer from './mcp-server.js';
+import mcpErrors from './mcp-errors.js';
+
+const MCP_PATH = '/mcp';
+
+const l = log4js.getLogger();
+
+const bootstrap = async (app) => {
+    app.post(MCP_PATH, postRequestHandler);
+    app.get(MCP_PATH, sessionRequestHandler);
+    app.delete(MCP_PATH, sessionRequestHandler);
+}
+
+const postRequestHandler = async (req, res) => {
+    try {
+        // Create new instances of MCP Server and Transport for each incoming request
+        const newMcpServer = mcpServer.create();
+        const transport = new StreamableHTTPServerTransport({
+            // This is a stateless MCP server, so we don't need to keep track of sessions
+            sessionIdGenerator: undefined,
+
+            // Change to `false` if you want to enable SSE in responses. 
+            enableJsonResponse: true,            
+        });
+
+        res.on('close', () => {
+            l.debug(`request processing complete`);
+            transport.close();
+            newMcpServer.close();
+        });
+        await newMcpServer.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    } catch (err) {
+        l.error(`Error handling MCP request ${err}`);
+        if (!res.headersSent) {
+            res.status(500).json(mcpErrors.internalServerError)
+        }
+    }
+}
+
+const sessionRequestHandler = async (req, res) => {
+    res.status(405).set('Allow', 'POST').json(mcpErrors.methodNotAllowed);
+}
+
+export default {
+    bootstrap
+}

samples/mcp-stateless-lambda/mcp_client/index.js

@@ -0,0 +1,36 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+const ENDPOINT_URL = process.env.MCP_SERVER_ENDPOINT || 'http://localhost:3000/mcp';
+
+const fake_token = 'good_access_token'; 
+
+console.log(`Connecting ENDPOINT_URL=${ENDPOINT_URL}`);
+
+const transport = new StreamableHTTPClientTransport(new URL(ENDPOINT_URL), {
+    requestInit: {
+        headers: {
+            'Authorization': `Bearer ${fake_token}`
+        }
+    }
+});
+
+const client = new Client({
+    name: "node-client",
+    version: "0.0.1"
+})
+
+await client.connect(transport);
+console.log('connected');
+
+const tools = await client.listTools();
+console.log(`listTools response: `, tools);
+
+for (let i = 0; i < 2; i++) {
+    let result = await client.callTool({
+        name: "ping"
+    });
+    console.log(`callTool:ping response: `, result);
+}
+
+await client.close();