Skip to main content

​
fastmcp.server.dependencies

Dependency injection for FastMCP. DI features (Depends, CurrentContext, CurrentFastMCP) work without pydocket using a vendored DI engine. Only task-related dependencies (CurrentDocket, CurrentWorker) and background task execution require fastmcp[tasks].

​
Functions

​
is_docket_available 

is_docket_available() -> bool
Check if pydocket is installed.

​
require_docket 

require_docket(feature: str) -> None
Raise ImportError with install instructions if docket not available. Args:
  • feature: Description of what requires docket (e.g., “task=True”, “CurrentDocket()”). Will be included in the error message.

​
transform_context_annotations 

transform_context_annotations(fn: Callable[..., Any]) -> Callable[..., Any]
Transform ctx: Context into ctx: Context = CurrentContext(). Transforms ALL params typed as Context to use Docket’s DI system, unless they already have a Dependency-based default (like CurrentContext()). This unifies the legacy type annotation DI with Docket’s Depends() system, allowing both patterns to work through a single resolution path. Note: Only POSITIONAL_OR_KEYWORD parameters are reordered (params with defaults after those without). KEYWORD_ONLY parameters keep their position since Python allows them to have defaults in any order. Args:
  • fn: Function to transform
Returns:
  • Function with modified signature (same function object, updated signature)

​
get_context 

get_context() -> Context
Get the current FastMCP Context instance directly.

​
get_server 

get_server() -> FastMCP
Get the current FastMCP server instance directly. Returns:
  • The active FastMCP server
Raises:
  • RuntimeError: If no server in context

​
get_http_request 

get_http_request() -> Request
Get the current HTTP request. Tries MCP SDK’s request_ctx first, then falls back to FastMCP’s HTTP context.

​
get_http_headers 

get_http_headers(include_all: bool = False) -> dict[str, str]
Extract headers from the current HTTP request if available. Never raises an exception, even if there is no active HTTP request (in which case an empty dict is returned). By default, strips problematic headers like content-length that cause issues if forwarded to downstream clients. If include_all is True, all headers are returned.

​
get_access_token 

get_access_token() -> AccessToken | None
Get the FastMCP access token from the current context. This function first tries to get the token from the current HTTP request’s scope, which is more reliable for long-lived connections where the SDK’s auth_context_var may become stale after token refresh. Falls back to the SDK’s context var if no request is available. Returns:
  • The access token if an authenticated user is available, None otherwise.

​
without_injected_parameters 

without_injected_parameters(fn: Callable[..., Any]) -> Callable[..., Any]
Create a wrapper function without injected parameters. Returns a wrapper that excludes Context and Docket dependency parameters, making it safe to use with Pydantic TypeAdapter for schema generation and validation. The wrapper internally handles all dependency resolution and Context injection when called. Handles:
  • Legacy Context injection (always works)
  • Depends() injection (always works - uses docket or vendored DI engine)
Args:
  • fn: Original function with Context and/or dependencies
Returns:
  • Async wrapper function without injected parameters

​
resolve_dependencies 

resolve_dependencies(fn: Callable[..., Any], arguments: dict[str, Any]) -> AsyncGenerator[dict[str, Any], None]
Resolve dependencies for a FastMCP function. This function:
  1. Filters out any dependency parameter names from user arguments (security)
  2. Resolves Depends() parameters via the DI system
The filtering prevents external callers from overriding injected parameters by providing values for dependency parameter names. This is a security feature. Note: Context injection is handled via transform_context_annotations() which converts ctx: Context to ctx: Context = Depends(get_context) at registration time, so all injection goes through the unified DI system. Args:
  • fn: The function to resolve dependencies for
  • arguments: User arguments (may contain keys that match dependency names, which will be filtered out)

​
CurrentContext 

CurrentContext() -> Context
Get the current FastMCP Context instance. This dependency provides access to the active FastMCP Context for the current MCP operation (tool/resource/prompt call). Returns:
  • A dependency that resolves to the active Context instance
Raises:
  • RuntimeError: If no active context found (during resolution)

​
CurrentDocket 

CurrentDocket() -> Docket
Get the current Docket instance managed by FastMCP. This dependency provides access to the Docket instance that FastMCP automatically creates for background task scheduling. Returns:
  • A dependency that resolves to the active Docket instance
Raises:
  • RuntimeError: If not within a FastMCP server context
  • ImportError: If fastmcp[tasks] not installed

​
CurrentWorker 

CurrentWorker() -> Worker
Get the current Docket Worker instance managed by FastMCP. This dependency provides access to the Worker instance that FastMCP automatically creates for background task processing. Returns:
  • A dependency that resolves to the active Worker instance
Raises:
  • RuntimeError: If not within a FastMCP server context
  • ImportError: If fastmcp[tasks] not installed

​
CurrentFastMCP 

CurrentFastMCP() -> FastMCP
Get the current FastMCP server instance. This dependency provides access to the active FastMCP server. Returns:
  • A dependency that resolves to the active FastMCP server
Raises:
  • RuntimeError: If no server in context (during resolution)

​
Classes

​
ProgressLike

Protocol for progress tracking interface. Defines the common interface between InMemoryProgress (server context) and Docket’s Progress (worker context). Methods:

​
current 

current(self) -> int | None
Current progress value.

​
total 

total(self) -> int
Total/target progress value.

​
message 

message(self) -> str | None
Current progress message.

​
set_total 

set_total(self, total: int) -> None
Set the total/target value for progress tracking.

​
increment 

increment(self, amount: int = 1) -> None
Atomically increment the current progress value.

​
set_message 

set_message(self, message: str | None) -> None
Update the progress status message.

​
InMemoryProgress

In-memory progress tracker for immediate tool execution. Provides the same interface as Docket’s Progress but stores state in memory instead of Redis. Useful for testing and immediate execution where progress doesn’t need to be observable across processes. Methods:

​
current 

current(self) -> int | None

​
total 

total(self) -> int

​
message 

message(self) -> str | None

​
set_total 

set_total(self, total: int) -> None
Set the total/target value for progress tracking.

​
increment 

increment(self, amount: int = 1) -> None
Atomically increment the current progress value.

​
set_message 

set_message(self, message: str | None) -> None
Update the progress status message.

​
Progress

FastMCP Progress dependency that works in both server and worker contexts. Handles three execution modes:
  • In Docket worker: Uses the execution’s progress (observable via Redis)
  • In FastMCP server with Docket: Falls back to in-memory progress
  • In FastMCP server without Docket: Uses in-memory progress
This allows tools to use Progress() regardless of whether they’re called immediately or as background tasks, and regardless of whether pydocket is installed.