Serverless Deployments

import { FastMCP } from "fastmcp";
import { z } from "zod";
import { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";

const server = new FastMCP({
  name: "Lambda MCP Server",
  version: "1.0.0",
});

server.addTool({
  name: "process_data",
  description: "Process data in Lambda",
  parameters: z.object({
    input: z.string(),
  }),
  execute: async ({ input }) => {
    return `Processed: ${input}`;
  },
});

// Start in stateless mode
let serverStarted = false;
const startServer = async () => {
  if (!serverStarted) {
    await server.start({
      transportType: "httpStream",
      httpStream: {
        port: 0, // Port not used in Lambda
        stateless: true,
      },
    });
    serverStarted = true;
  }
};

export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  await startServer();

  // Convert API Gateway event to Request
  const request = new Request(
    `https://${event.headers.Host}${event.path}`,
    {
      method: event.httpMethod,
      headers: event.headers,
      body: event.body,
    }
  );

  // Handle with FastMCP internal handler
  // Note: This requires accessing internal methods
  // For production, consider using a middleware adapter

  return {
    statusCode: 200,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ message: "Success" }),
  };
};

import { FastMCP } from "fastmcp";
import { z } from "zod";
import { Request, Response } from "@google-cloud/functions-framework";

const server = new FastMCP({
  name: "GCP MCP Server",
  version: "1.0.0",
});

server.addTool({
  name: "cloud_process",
  description: "Process data in Google Cloud",
  parameters: z.object({
    data: z.string(),
  }),
  execute: async ({ data }) => {
    return `Processed in GCP: ${data}`;
  },
});

let initialized = false;

export const mcpHandler = async (req: Request, res: Response) => {
  if (!initialized) {
    await server.start({
      transportType: "httpStream",
      httpStream: {
        port: 0,
        stateless: true,
      },
    });
    initialized = true;
  }

  // Handle request with FastMCP
  res.status(200).json({ message: "Success" });
};

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
import { FastMCP } from "fastmcp";
import { z } from "zod";

const server = new FastMCP({
  name: "Azure MCP Server",
  version: "1.0.0",
});

server.addTool({
  name: "azure_process",
  description: "Process data in Azure",
  parameters: z.object({
    input: z.string(),
  }),
  execute: async ({ input }) => {
    return `Processed in Azure: ${input}`;
  },
});

let started = false;

export async function mcpHandler(
  request: HttpRequest,
  context: InvocationContext
): Promise<HttpResponseInit> {
  if (!started) {
    await server.start({
      transportType: "httpStream",
      httpStream: {
        port: 0,
        stateless: true,
      },
    });
    started = true;
  }

  return {
    status: 200,
    jsonBody: { message: "Success" },
  };
}

app.http("mcp", {
  methods: ["GET", "POST"],
  authLevel: "anonymous",
  handler: mcpHandler,
});

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  },
  "functionTimeout": "00:01:00"
}