`fastmcp.utilities.types`

Common types used across FastMCP.

Functions

`get_fn_name`

get_fn_name(fn: Callable[..., Any]) -> str

`get_function_type_hints`

get_function_type_hints(fn: Callable[..., Any]) -> dict[str, Any]

Resolve a function’s type hints, keeping Annotated metadata. Before Python 3.11, typing.get_type_hints wraps the hint of every parameter that defaults to None in Optional[...]. For Annotated[int | None, Field(title="Limit")] = None that produces Optional[Annotated[...]], which buries the Field metadata in a nested union branch of the JSON schema. Hints are resolved here without that wrapping, so every supported Python version yields the same schema.

`get_cached_typeadapter`

get_cached_typeadapter(cls: T) -> TypeAdapter[T]

TypeAdapters are heavy objects, and in an application context we’d typically create them once in a global scope and reuse them as often as possible. However, this isn’t feasible for user-generated functions. Instead, we use a cache to minimize the cost of creating them as much as possible.

`issubclass_safe`

issubclass_safe(cls: type, base: type) -> bool

Check if cls is a subclass of base, even if cls is a type variable.

`is_class_member_of_type`

is_class_member_of_type(cls: Any, base: type) -> bool

Check if cls is a member of base, even if cls is a type variable. Base can be a type, a UnionType, or an Annotated type. Generic types are not considered members (e.g. T is not a member of list[T]).

`find_kwarg_by_type`

find_kwarg_by_type(fn: Callable, kwarg_type: type) -> str | None

Find the name of the kwarg that is of type kwarg_type. Includes union types that contain the kwarg_type, as well as Annotated types.

`create_function_without_params`

create_function_without_params(fn: Callable[..., Any], exclude_params: list[str]) -> Callable[..., Any]

Create a new function with the same code but without the specified parameters in annotations. This is used to exclude parameters from type adapter processing when they can’t be serialized. The excluded parameters are removed from the function’s annotations dictionary.

`replace_type`

replace_type(type_, type_map: dict[type, type])

Given a (possibly generic, nested, or otherwise complex) type, replaces all instances of keys in type_map with their corresponding values. This is useful for transforming types when creating tools. Args:

type_: The type to transform.
type_map: A mapping of types to replace (keys are replaced by values).

Examples:

>>> replace_type(list[int | bool], {int: str})
list[str | bool]

>>> replace_type(list[list[int]], {int: str})
list[list[str]]

Classes

`FastMCPBaseModel`

Base model for FastMCP models.

`Image`

Helper class for returning images from tools. Methods:

`to_image_content`

to_image_content(self, mime_type: str | None = None, annotations: Annotations | None = None) -> mcp_types.ImageContent

Convert to MCP ImageContent.

`to_data_uri`

to_data_uri(self, mime_type: str | None = None) -> str

Get image as a data URI.

`Audio`

Helper class for returning audio from tools. Methods:

`to_audio_content`

to_audio_content(self, mime_type: str | None = None, annotations: Annotations | None = None) -> mcp_types.AudioContent

`File`

Helper class for returning file data from tools. Methods:

`to_resource_content`

to_resource_content(self, mime_type: str | None = None, annotations: Annotations | None = None) -> mcp_types.EmbeddedResource

fastmcp.apps

fastmcp.cli

fastmcp.client

fastmcp.experimental

fastmcp.prompts

fastmcp.resources

fastmcp.server

fastmcp.tools