2.0.0
Transports handle the underlying connection between your client and MCP servers. While the client can automatically select a transport based on what you pass to it, instantiating transports explicitly gives you full control over configuration.
STDIO Transport
STDIO transport communicates with MCP servers through subprocess pipes. When using STDIO, your client launches and manages the server process, controlling its lifecycle and environment.Path: inferring a subprocess from a bare string like Client("my_server.py") is deprecated as of 4.0 — it warns, and in FastMCP 5 a string will only ever mean a URL:
Environment Variables
Values you pass throughenv are merged on top of the inherited allowlist, so you add configuration rather than replacing the base environment. Anything your server needs beyond the allowlist has to be listed explicitly.
Selective forwarding passes only the variables your server needs:
Session Persistence
STDIO transports maintain sessions across multiple client contexts by default (keep_alive=True). This reuses the same subprocess for multiple connections, improving performance.
Client(timeout=...) restarts an idle
subprocess. If another client is still connected, the new client shares its
session and that session’s timeout, and FastMCP logs a warning; use separate
transports when concurrent clients need different defaults. Per-call timeout
overrides do not restart the session.
For complete isolation between connections, disable session persistence:
loop.run_until_complete(...)), reuse from another loop raises until you close the client on the original loop.
HTTP Transport
New in version2.3.0
HTTP transport connects to MCP servers running as web services. This is the recommended transport for production deployments.
Incoming SSE events are limited to 1 MiB by default. If a server returns larger
tool results or resources, set max_sse_event_size on StreamableHttpTransport
to a byte limit that accommodates them, or use None to disable the limit:
max_sse_event_size on an MCP config’s remote server entry, which forwards it when building the transport. A client created from a bare URL (Client("https://api.example.com/mcp")) keeps the 1 MiB default; pass an explicit StreamableHttpTransport as above to raise or disable it.
SSL Verification
By default, HTTPS connections verify the server’s SSL certificate using the operating system’s trust store through HTTPX2. You can customize this behavior with theverify parameter; see HTTPX2’s SSL guide.
Keep the trust store used by your deployment current. Updating certifi does not update the operating system’s CA store or a custom bundle selected by SSL_CERT_FILE, SSL_CERT_DIR, or verify. Custom client factories configure their own TLS verification. Rebuild containers and restart processes after updating trust stores. This also matters for servers making outbound HTTPS requests to OAuth providers, JWKS endpoints, and upstream APIs.
For the October 2026 eMudhra CA incident, follow the FastMCP security notice. A FastMCP package upgrade alone does not remediate every trust store.
The verify parameter on Client accepts a boolean, a CA bundle path, or an ssl.SSLContext:
verify parameter is also available directly on StreamableHttpTransport and SSETransport:
Custom HTTP Client
For anything beyond SSL settings — proxies, mTLS, event hooks — pass anhttpx_client_factory. The factory receives headers, auth, and follow_redirects, plus timeout when the client has one configured (for example Client(transport, timeout=60)). Accept **kwargs so the factory stays forward-compatible.
When no client timeout is configured, the factory owns the timeout: none is passed, and an httpx2.AsyncClient built without one uses httpx’s 5 second default, which is too short for many MCP tool calls. Set a default with setdefault, so an explicit client timeout still wins:
SSE Transport
Server-Sent Events transport is maintained for backward compatibility. Use Streamable HTTP for new deployments unless you have specific infrastructure requirements.In-Memory Transport
In-memory transport connects directly to a FastMCP server instance within the same Python process. This eliminates both subprocess management and network overhead, making it ideal for testing.Unlike STDIO transports, in-memory servers share the same memory space and environment variables as your client code.
Multi-Server Configuration
New in version2.4.0
Connect to multiple servers defined in a configuration dictionary:
Per-server Timeouts
Settimeout on a server entry to limit how long its requests can wait. Entry timeouts use milliseconds, apply to HTTP, SSE, and STDIO servers, and take precedence over the timeout passed to Client. An omitted or null entry timeout uses the client timeout; 0 disables the timeout for that backend session.
For example, give the weather server 5 seconds and use a 30-second client timeout for entries without their own limit:
timeout cannot extend those sessions’ configured limits. sse_read_timeout remains a separate setting for the SSE connection.
Tool Transformations
FastMCP supports tool transformations within the configuration. You can change names, descriptions, tags, and arguments for tools from a server. Key each transformation by the tool’s name on that server, before any server-name prefix is added.include_tags or exclude_tags at the server level:
include_tags to leave inclusion unrestricted. An empty include_tags list
includes no tools, while an empty exclude_tags list excludes none. These filters
apply to each server in both single-server and multi-server configurations.