Modal logo
FeaturedGetting started Hello, worldSimple web scraperServing web endpointsLarge language models (LLMs) Deploy an OpenAI-compatible LLM service with vLLMRun DeepSeek-R1 and Phi-4 with llama.cppLow-latency, serverless TensorRT-LLMRun Vision-Language Models with SGLangEfficient LLM Finetuning with UnslothRun a multimodal RAG chatbot to answer questions about PDFsDeploy and benchmark the Tokasaurus high-throughput LLM serverFine-tune an LLM to replace your CEODeploy a stateless MCP with FastMCPImages, video, & 3D Edit images with Flux KontextFine-tune Wan2.1 video models on your faceRun Flux fast with torch.compileFine-tune Flux with LoRAAnimate images with LTX-VideoGenerate video clips with LTX-VideoRun Stable Diffusion with a CLI, API, and web UIAudio Deploy a Moshi voice chatbotStream transcripts at the speed of speech using Kyutai STTMake music with ACE-StepGenerate speech with ChatterboxRun high throughput batched transcription with WhisperFine-tune Whisper to recognize new wordsReal-time communication (WebRTC) Serverless WebRTCWebRTC quickstart with FastRTCComputational biology Fold proteins with Chai-1Build a protein-folding dashboardFold proteins with Boltz-2Modal Sandboxes Build a scalable AI coding platformRun a LangGraph agent's code in a secure GPU sandboxControl a sandboxed computer with an LLMBuild a stateful, sandboxed code interpreterRun Node.js, Ruby, and more in a SandboxRun a sandboxed Jupyter notebookReinforcement Learning Train a model to solve math problems using GRPO and verlTrain a model to solve coding problems using GRPO and TRLEmbeddings Embed millions of documents with TEITurn satellite images into vectors and store them in MongoDBParallel processing and job scheduling Transcribe podcasts with WhisperDeploy a Hacker News SlackbotRun a Document OCR job queueServe a Document OCR web appTraining models from scratch Train an SLM with early-stopping grid search over hyperparametersRun long, resumable training jobsHosting popular libraries YOLO: Fine-tune and serve computer vision modelsBlender: Build a 3D render farmStreamlit: Run and deploy Streamlit appsComfyUI: Run Flux on ComfyUI as an APISQLite: Publish explorable data with DatasetteAlgolia: Build docsearch with a crawlerConnecting to other APIs Discord: Deploy and run a Discord BotGoogle Sheets: Sync databases and APIs to a Google SheetOpenAI: Run a RAG Q&A chatbotTailscale: Add Modal Apps to your VPNPrometheus: Publish custom metrics with PushgatewayManaging data Mount S3 buckets in Modal appsBuild your own data warehouse with DuckDB, DBT, and ModalCreate a LoRA Playground with Modal, Gradio, and S3Miscellaneous
View on GitHub

Deploy a remote, stateless MCP server on Modal with FastMCP

This example demonstrates how to deploy a simple MCP server on Modal.

The server provides a tool to get the current date and time in a given timezone. It is a stateless MCP server, meaning that it does not store any state between requests, which is important for mapping onto Modal’s serverless Functions. It uses the “streamable HTTP” transport type.

Building the MCP server 

First, we define our dependencies.

We use the FastMCP library to create the MCP server. We wrap with a FastAPI server to expose it to the Internet.

import modal

app = modal.App("example-mcp-server-stateless")

image = modal.Image.debian_slim(python_version="3.12").uv_pip_install(
    "fastapi==0.115.14",
    "fastmcp==2.10.6",
    "pydantic==2.11.10",
)

Next, we create the MCP server itself using FastMCP and add a tool to it that allows LLMs to get the current date and time in a given timezone.

def make_mcp_server():
    from fastmcp import FastMCP

    mcp = FastMCP("Date and Time MCP Server")

    @mcp.tool()
    async def current_date_and_time(timezone: str = "UTC") -> str:
        """Get the current date and time.

        Args:
            timezone: The timezone to get the date and time in (optional). Defaults to UTC.

        Returns:
            The current date and time in the given timezone, in ISO 8601 format.
        """
        from datetime import datetime
        from zoneinfo import ZoneInfo

        try:
            tz = ZoneInfo(timezone)
        except Exception:
            raise ValueError(
                f"Invalid timezone '{timezone}'. Please use a valid timezone like 'UTC', "
                "'America/New_York', or 'Europe/Stockholm'."
            )
        return datetime.now(tz).isoformat()

    return mcp

We then use FastMCP to create a Starlette app with streamable-http as transport type, and set stateless_http=True to make it stateless.

This will be mounted by the FastAPI app, which we deploy as a Modal web endpoint using the asgi_app decorator:

@app.function(image=image)
@modal.asgi_app()
def web():
    """ASGI web endpoint for the MCP server"""
    from fastapi import FastAPI

    mcp = make_mcp_server()
    mcp_app = mcp.http_app(transport="streamable-http", stateless_http=True)

    fastapi_app = FastAPI(lifespan=mcp_app.router.lifespan_context)
    fastapi_app.mount("/", mcp_app, "mcp")

    return fastapi_app

And we’re done!

Testing the MCP server 

Now you can serve the MCP server by running:

modal serve mcp_server_stateless.py

Then open the MCP inspector:

npx @modelcontextprotocol/inspector

Enter the URL of the MCP server that was printed by the modal serve command above, suffixed with /mcp/ (so for example https://modal-labs-examples--datetime-mcp-server-web-dev.modal.run/mcp/). Also make sure to select “Streamable HTTP” as the “Transport Type”.

After connecting and clicking “List Tools” in the “Tools” tab you should see your current_date_and_time tool listed, and if you “Run Tool” it should give you the current date and time in UTC!

To automatically test the MCP server, we spin up a client and have it list the tools.

@app.function(image=image)
async def test_tool(tool_name: str | None = None):
    from fastmcp import Client
    from fastmcp.client.transports import StreamableHttpTransport

    if tool_name is None:
        tool_name = "current_date_and_time"

    transport = StreamableHttpTransport(url=f"{web.get_web_url()}/mcp/")
    client = Client(transport)

    async with client:
        tools = await client.list_tools()

        for tool in tools:
            print(tool)
            if tool.name == tool_name:
                result = await client.call_tool(tool_name)
                print(result.data)
                return

    raise Exception(f"could not find tool {tool_name}")

This test is executed by running the script with modal run:

modal run mcp_server_stateless::test_tool

Deploying the MCP server 

modal serve creates an ephemeral, hot-reloading server, which is useful for testing and development.

When it’s time to move to production, you can deploy the server with

modal deploy mcp_server_stateless