Stateless & serverless servers

Serverless MCP servers (Vercel, Lambda, Cloud Run scaled to zero) handle initialize and each tool call on different instances. Two things break without help: session identity (calls stop lining up into one session) and delivery (the platform freezes your process before background events are sent). Both fixes are one-liners.

1. Use `await` delivery

Background delivery relies on the process staying alive after the response. In serverless, send events before returning instead:

createMcpAnalyticsServer(buildServer, {
  armature: { delivery: "await" },
});

instrument_fastmcp(mcp, {"armature": {"delivery": "await"}})

config.Delivery = armatureanalytics.DeliveryAwait

2. Resolve the session per request

The SDK mints identity-bearing session IDs (mcp_<client>_v_<version>_<uuid>) on initialize and reads them back on later requests, so client attribution survives across instances.

TypeScript
Python
Go

Call resolveStatelessHttpSession per request and pass the results to the transport and dispatch context:

import { resolveStatelessHttpSession } from "@armature-tech/mcp-analytics";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

const session = resolveStatelessHttpSession({
  body: requestBody,
  headers: requestHeaders,
});

const transport = new StreamableHTTPServerTransport({
  sessionIdGenerator: session.sessionIdGenerator,
  enableJsonResponse: true,
});

// with a custom dispatcher:
await analytics.dispatch(name, args, { ...context, ...session.dispatchContext });

Wrap your ASGI app in the dependency-free middleware — it handles minting and echoing automatically:

from armature_mcp_analytics import StatelessHttpSessionMiddleware

# standalone FastMCP
app = StatelessHttpSessionMiddleware(
    mcp.http_app(stateless_http=True, json_response=True)
)

# official MCP Python SDK
# mcp = FastMCP("Customer MCP", stateless_http=True, json_response=True)
# app = StatelessHttpSessionMiddleware(mcp.streamable_http_app())

Resolve the session per request and hand it to the server options:

session := armatureanalytics.ResolveStatelessHTTPSession(armatureanalytics.StatelessHTTPInput{
	Body:    body,
	Headers: r.Header,
})

// official go-sdk
s, shutdown := official.NewMCPServer(impl, &mcp.ServerOptions{
	GetSessionID: session.SessionIDGenerator(),
})
// serve with &mcp.StreamableHTTPOptions{Stateless: true, JSONResponse: true}

// mark3labs/mcp-go
srv := server.NewMCPServer(name, version,
	server.WithSessionIdManager(session.Mark3labsSessionIDManager()),
)

Session IDs are attribution metadata, not a security boundary — they are echoed by clients unsigned. Keep authorization on your own auth layer.

Getting started

Dashboard

SDKs

Armature MCP

Privacy & security

Stateless & serverless servers

1. Use `await` delivery

2. Resolve the session per request

​1. Use await delivery

​2. Resolve the session per request

1. Use `await` delivery

2. Resolve the session per request