Adding custom headers?

[bojan2501]

Hi,
In the docs I can see get_http_headers() and this is good for reading of http headers.
But I was wondering how to add custom headers?
For example I need to add:

X-Accel-Buffering: no

As I found it that this is needed if MCP's are behind nginx or ALB.
My idea was to do this in Middleware. But no examples are provided.

Any ideas?

[pedro-inf-custodio]

Actually, I’m running into a similar issue, but in my case it’s not about creating a new header — it’s about overriding the value of the Authorization header.

I tried implementing this via middleware, but it doesn’t seem to work as expected. I haven’t been able to find any clear examples in the docs either.

That said, I did come across this discussion which might be helpful for your use case as well: #1362

For reference, here’s the middleware implementation I tried while proxying requests to a downstream mcp server:

from fastmcp.server.middleware import Middleware, MiddlewareContext
from starlette.datastructures import MutableHeaders


class AuthMiddleware(Middleware):
    async def _override_auth_header(self, context: MiddlewareContext, auth_token: str | None):
        """
        Override the Authorization header in the request.
        
        Args:
            context: The middleware context containing the request
            auth_token: The token to set, or None to remove the header
            
        Returns:
            Modified context with updated headers
        """
        request = context.fastmcp_context.request_context.request
        new_headers = MutableHeaders(request._headers)

        if auth_token:
            new_headers["authorization"] = auth_token
        else:
            del new_headers["authorization"]

        request._headers = new_headers
        context.fastmcp_context.request_context.request.scope.update(headers=request.headers.raw)
        return context

    async def on_call_tool(self, context: MiddlewareContext, call_next):
        """
        Intercept tool calls to modify auth headers.
        """
        # Override auth header based on tool being called
        # Example: Different tools might need different auth mechanisms
        if "service_name" in context.message.name:
            context = await self._override_auth_header(context, auth_token="Bearer <token>")

        return await call_next(context)

[bojan2501]

Hi @pedro-inf-custodio,

Thanks for the hint. I also did not manage to make it work for now.
I also found this: https://gofastmcp.com/servers/middleware#custom-middleware-example
But it is not that helpful.

Will continue working on it and if there is a solution will post it here.

All best
Bojan

[pedro-inf-custodio]

@bojan2501 Just to give you a bit more insight into what I’ve discovered so far, the current error occurs at /Users/.../.venv/lib/python3.12/site-packages/fastmcp/client/client.py, inside the call_tool_mcp method:

result = await self.session.send_request(
    request=request,  # type: ignore[arg-type]
    result_type=mcp.types.CallToolResult,
    request_read_timeout_seconds=timeout,  # type: ignore[arg-type]
    progress_callback=progress_handler or self._progress_handler,
)

If you look into the send_request method, you’ll see that it actually comes from the https://github.com/modelcontextprotocol/python-sdk in this file /Users/.../.venv/lib/python3.12/site-packages/mcp/shared/session.py. The failure appears to happen at this line:

response_or_error = await response_stream_reader.receive()

It fails silently, without any warning or debug output. I wasn’t able to debug this further—even after setting the Python logging level to DEBUG, I couldn’t find any meaningful logs (at least none that I could identify).

[Michael-WhiteCapData]

For X-Accel-Buffering, this is an HTTP response concern, so MCP operation middleware is the wrong layer. Either configure Nginx directly with proxy_buffering off; (my preference), or wrap the ASGI app and add the header on http.response.start.

A pure ASGI wrapper preserves streaming:

class NoBuffering:
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        async def send_with_header(message):
            if message["type"] == "http.response.start":
                headers = list(message.get("headers", []))
                headers.append((b"x-accel-buffering", b"no"))
                message = {**message, "headers": headers}
            await send(message)

        await self.app(scope, receive, send_with_header)

mcp_app = mcp.http_app()
app = NoBuffering(mcp_app)

Run app with your ASGI server instead of calling mcp.run(). The wrapper passes lifespan events through to mcp_app, which matters for Streamable HTTP session setup/cleanup.

Do not use this technique to overwrite the inbound Authorization header: response headers and request authentication are separate paths. For a proxy's outgoing backend credentials, configure the upstream FastMCP client transport/auth instead.

Also check the whole path: X-Accel-Buffering: no is understood by Nginx, but an ALB or another proxy can have its own idle timeout/buffering behavior. Verify with curl -N -D - at the public endpoint, not only against localhost.