> ## Documentation Index > Fetch the complete documentation index at: https://fastmcp-docs-v3-beta2-feature-tracking.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # dependencies # `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 ### `get_task_context` ```python theme={null} get_task_context() -> TaskContextInfo | None ``` Get the current task context if running inside a background task worker. This function extracts task information from the Docket execution context. Returns None if not running in a task context (e.g., foreground execution). **Returns:** * TaskContextInfo with task\_id and session\_id, or None if not in a task. ### `register_task_session` ```python theme={null} register_task_session(session_id: str, session: ServerSession) -> None ``` Register a session for Context access in background tasks. Called automatically when a task is submitted to Docket. The session is stored as a weakref so it doesn't prevent garbage collection when the client disconnects. **Args:** * `session_id`: The session identifier * `session`: The ServerSession instance ### `get_task_session` ```python theme={null} get_task_session(session_id: str) -> ServerSession | None ``` Get a registered session by ID if still alive. **Args:** * `session_id`: The session identifier **Returns:** * The ServerSession if found and alive, None otherwise ### `is_docket_available` ```python theme={null} is_docket_available() -> bool ``` Check if pydocket is installed. ### `require_docket` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} get_context() -> Context ``` Get the current FastMCP Context instance directly. ### `get_server` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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` ```python theme={null} 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) ### `CurrentRequest` ```python theme={null} CurrentRequest() -> Request ``` Get the current HTTP request. This dependency provides access to the Starlette Request object for the current HTTP request. Only available when running over HTTP transports (SSE or Streamable HTTP). **Returns:** * A dependency that resolves to the active Starlette Request **Raises:** * `RuntimeError`: If no HTTP request in context (e.g., STDIO transport) ### `CurrentHeaders` ```python theme={null} CurrentHeaders() -> dict[str, str] ``` Get the current HTTP request headers. This dependency provides access to the HTTP headers for the current request. Returns an empty dictionary when no HTTP request is available, making it safe to use in code that might run over any transport. **Returns:** * A dependency that resolves to a dictionary of header name -> value ### `CurrentAccessToken` ```python theme={null} CurrentAccessToken() -> AccessToken ``` Get the current access token for the authenticated user. This dependency provides access to the AccessToken for the current authenticated request. Raises an error if no authentication is present. **Returns:** * A dependency that resolves to the active AccessToken **Raises:** * `RuntimeError`: If no authenticated user (use get\_access\_token() for optional) ## Classes ### `TaskContextInfo` Information about the current background task context. Returned by `get_task_context()` when running inside a Docket worker. Contains identifiers needed to communicate with the MCP session. ### `ProgressLike` Protocol for progress tracking interface. Defines the common interface between InMemoryProgress (server context) and Docket's Progress (worker context). **Methods:** #### `current` ```python theme={null} current(self) -> int | None ``` Current progress value. #### `total` ```python theme={null} total(self) -> int ``` Total/target progress value. #### `message` ```python theme={null} message(self) -> str | None ``` Current progress message. #### `set_total` ```python theme={null} set_total(self, total: int) -> None ``` Set the total/target value for progress tracking. #### `increment` ```python theme={null} increment(self, amount: int = 1) -> None ``` Atomically increment the current progress value. #### `set_message` ```python theme={null} 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` ```python theme={null} current(self) -> int | None ``` #### `total` ```python theme={null} total(self) -> int ``` #### `message` ```python theme={null} message(self) -> str | None ``` #### `set_total` ```python theme={null} set_total(self, total: int) -> None ``` Set the total/target value for progress tracking. #### `increment` ```python theme={null} increment(self, amount: int = 1) -> None ``` Atomically increment the current progress value. #### `set_message` ```python theme={null} 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.