MCP Method for consuming FastMCP server context logs?

[yevhenp]

The FastMCP docs describe enabling server-to-client logs via Context here: https://gofastmcp.com/servers/context#logging , and here: https://gofastmcp.com/servers/logging - for example, ctx.info("My message to the client here!").

Which MCP "method" are these sent over, per the spec? Curious about the client-side implementation to consume these. After establishing an MCP connection via "method":"initialize", and before calling a tool via "method":"tools/call", what needs to happen to receive these logs? An SSE connection? A request to "notifications/message"? Something else?

Many thanks!

[Urus1201]

Those log messages are sent over the MCP notifications channel using the notifications/message JSON-RPC notification — exactly what you suspected.

How it works (protocol level)

After the initialize handshake, the server can push log notifications to the client at any time:

{
  "jsonrpc": "2.0",
  "method": "notifications/message",
  "params": {
    "level": "info",
    "logger": "my_server",
    "data": "My message to the client here!"
  }
}

The level field maps to the MCP LoggingLevel enum ("debug", "info", "warning", "error", "critical", etc.).

Transport differences

SSE transport: notifications arrive as data: events on the existing SSE stream — no extra subscription needed. Once your SSE connection is open you receive both responses and notifications on the same channel.

Streamable-HTTP transport (newer): notifications are delivered in the response stream of the POST /mcp request that triggered the tool call, or via a separate GET SSE stream if you establish one.

Client-side (Python mcp SDK)

If you are using the official mcp Python SDK, hook into the LoggingMessageNotification handler:

from mcp import ClientSession
from mcp.types import LoggingMessageNotification

async with ClientSession(read, write) as session:
    await session.initialize()

    session.set_notification_handler(
        LoggingMessageNotification,
        lambda n: print(f"[{n.params.level}] {n.params.data}")
    )

    # Now call tools normally — log notifications arrive via the handler
    result = await session.call_tool("my_tool", {})

No special initialize flags are needed; the server starts emitting notifications/message as soon as it calls ctx.info() / ctx.warning() / etc. in a tool handler.

[Michael-WhiteCapData]

At the wire level, yes: ctx.info() is emitted as a JSON-RPC notification whose method is notifications/message. The client does not send a request to subscribe to it.

One correction to the earlier client example: FastMCP clients receive this through the message_handler supplied when the Client is constructed; there is no public session.set_notification_handler(...) API in the current client.

import mcp.types
from fastmcp import Client
from fastmcp.client.messages import MessageHandler

class Logs(MessageHandler):
    async def on_logging_message(
        self, notification: mcp.types.LoggingMessageNotification
    ) -> None:
        p = notification.params
        print(f"[{p.level}] {p.logger or '-'}: {p.data}")

client = Client("server.py", message_handler=Logs())

async with client:
    await client.call_tool("my_tool", {})

With Streamable HTTP, the notification arrives on the response stream already opened by the call; there is no second SSE connection required just to receive a log emitted during that call.

There is also a version distinction now: on the modern 2026-07-28 protocol, logging/setLevel was removed, but notifications/message remains. Filter client-side in the handler, and set the server's client_log_level if you want to suppress lower levels before they go over the wire.

References: FastMCP notification handlers and the current logging FAQ.