> ## Documentation Index > Fetch the complete documentation index at: https://gofastmcp.com/llms.txt > Use this file to discover all available pages before exploring further. # elicitation # `fastmcp.server.elicitation` ## Functions ### `parse_elicit_response_type` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} parse_elicit_response_type(response_type: Any) -> ElicitConfig ``` Parse response\_type into schema and handling configuration. Supports multiple syntaxes: * None: Empty object schema, expect empty response * dict: `{"low": {"title": "..."}}` -> single-select titled enum * list patterns: * `[["a", "b"]]` -> multi-select untitled * `[{"low": {...}}]` -> multi-select titled * `["a", "b"]` -> single-select untitled * `list[X]` type annotation: multi-select with type * Scalar types (bool, int, float, str, Literal, Enum): single value * Other types (dataclass, BaseModel): use directly ### `handle_elicit_accept` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} handle_elicit_accept(config: ElicitConfig, content: Any) -> AcceptedElicitation[Any] ``` Handle an accepted elicitation response. **Args:** * `config`: The elicitation configuration from parse\_elicit\_response\_type * `content`: The response content from the client **Returns:** * AcceptedElicitation with the extracted/validated data ### `get_elicitation_schema` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} get_elicitation_schema(response_type: type[T]) -> dict[str, Any] ``` Get the schema for an elicitation response. **Args:** * `response_type`: The type of the response ### `validate_elicitation_json_schema` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} validate_elicitation_json_schema(schema: dict[str, Any]) -> None ``` Validate that a JSON schema follows MCP elicitation requirements. This ensures the schema is compatible with MCP elicitation requirements: * Must be an object schema * Must only contain primitive field types (string, number, integer, boolean) * Must be flat (no nested objects or arrays of objects) * Allows const fields (for Literal types) and enum fields (for Enum types) * Only primitive types and their nullable variants are allowed **Args:** * `schema`: The JSON schema to validate **Raises:** * `TypeError`: If the schema doesn't meet MCP elicitation requirements ## Classes ### `ElicitationJsonSchema` Custom JSON schema generator for MCP elicitation that always inlines enums. MCP elicitation requires inline enum schemas without $ref/$defs references. This generator ensures enums are always generated inline for compatibility. Optionally adds enumNames for better UI display when available. **Methods:** #### `generate_inner` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} generate_inner(self, schema: core_schema.CoreSchema) -> JsonSchemaValue ``` Override to prevent ref generation for enums and handle list schemas. #### `list_schema` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} list_schema(self, schema: core_schema.ListSchema) -> JsonSchemaValue ``` Generate schema for list types, detecting enum items for multi-select. #### `enum_schema` ```python theme={"theme":{"light":"snazzy-light","dark":"dark-plus"}} enum_schema(self, schema: core_schema.EnumSchema) -> JsonSchemaValue ``` Generate inline enum schema. Always generates enum pattern: `{"enum": [value, ...]}` Titled enums are handled separately via dict-based syntax in ctx.elicit(). ### `AcceptedElicitation` Result when user accepts the elicitation. ### `ScalarElicitationType` ### `ElicitConfig` Configuration for an elicitation request. **Attributes:** * `schema`: The JSON schema to send to the client * `response_type`: The type to validate responses with (None for raw schemas) * `is_raw`: True if schema was built directly (extract "value" from response)