Struct StreamableHttpService 

pub struct StreamableHttpService<S, M = LocalSessionManager> {
    pub config: StreamableHttpServerConfig,
    /* private fields */
}

Streamable HTTP server

An HTTP service that implements the Streamable HTTP transport for MCP servers.

Session management

When StreamableHttpServerConfig::stateful_mode is true (the default), the server creates a session for each client that sends an initialize request. The session ID is returned in the Mcp-Session-Id response header and the client must include it on all subsequent requests.

Two tool calls carrying the same Mcp-Session-Id come from the same logical session (typically one conversation in an LLM client). Different session IDs mean different sessions.

The SessionManager trait controls how sessions are stored and routed:

• LocalSessionManager — in-memory session store (default).
• NeverSessionManager — disables sessions entirely (stateless mode).

Accessing HTTP request data from tool handlers

The service consumes the request body but injects the remaining http::request::Parts into crate::model::Extensions, which is accessible through crate::service::RequestContext.

Reading the raw HTTP parts

use rmcp::handler::server::tool::Extension;
use http::request::Parts;
async fn my_tool(Extension(parts): Extension<Parts>) {
    tracing::info!("http parts:{parts:?}")
}

Reading the session ID inside a tool handler

use rmcp::handler::server::tool::Extension;
use rmcp::service::RequestContext;
use rmcp::model::RoleServer;

#[tool(description = "session-aware tool")]
async fn my_tool(
    &self,
    Extension(parts): Extension<http::request::Parts>,
) -> Result<CallToolResult, rmcp::ErrorData> {
    if let Some(session_id) = parts.headers.get("mcp-session-id") {
        tracing::info!(?session_id, "called from session");
    }
    // ...
}

Accessing custom axum/tower extension state

State added via axum’s Extension layer is available inside Parts.extensions:

use rmcp::service::RequestContext;
use rmcp::model::RoleServer;

#[derive(Clone)]
struct AppState { /* ... */ }

#[tool(description = "example")]
async fn my_tool(
    &self,
    ctx: RequestContext<RoleServer>,
) -> Result<CallToolResult, rmcp::ErrorData> {
    let parts = ctx.extensions.get::<http::request::Parts>().unwrap();
    let state = parts.extensions.get::<AppState>().unwrap();
    // use state...
}

Fields

config: StreamableHttpServerConfig

Implementations

impl<S, M> StreamableHttpService<S, M>

where S: Service<RoleServer> + Send + 'static, M: SessionManager,

pub fn new( service_factory: impl Fn() -> Result<S, Error> + Send + Sync + 'static, session_manager: Arc<M>, config: StreamableHttpServerConfig, ) -> StreamableHttpService<S, M>

pub async fn handle<B>( &self, request: Request<B>, ) -> Response<BoxBody<Bytes, Infallible>>

where B: Body + Send + 'static, <B as Body>::Error: Display,

Trait Implementations

impl<S, M> Clone for StreamableHttpService<S, M>

fn clone(&self) -> StreamableHttpService<S, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<RequestBody, S, M> Service<Request<RequestBody>> for StreamableHttpService<S, M>

where RequestBody: Body + Send + 'static, S: Service<RoleServer>, M: SessionManager, <RequestBody as Body>::Error: Display, <RequestBody as Body>::Data: Send + 'static,

type Response = Response<BoxBody<Bytes, Infallible>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<StreamableHttpService<S, M> as Service<Request<RequestBody>>>::Response, <StreamableHttpService<S, M> as Service<Request<RequestBody>>>::Error>> + Send>>

The future response value.

fn call( &mut self, req: Request<RequestBody>, ) -> <StreamableHttpService<S, M> as Service<Request<RequestBody>>>::Future

Process the request and return the response asynchronously.

fn poll_ready( &mut self, _cx: &mut Context<'_>, ) -> Poll<Result<(), <StreamableHttpService<S, M> as Service<Request<RequestBody>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.