hack/tools/scripts/llm-key-hunter/results/_cache/content/charbeldaher34_agenticai-pydanticai.json

{"repo": "charbeldaher34/agenticai-pydanticai", "files": {"pydantic-ai-documentation/API_Reference/api/embeddings/index.md": {"15f949bc55c58b80ce34623e03e565f183db6683": {"t": 1786068570.1544094, "n": 195683, "h": "66d06237b2358b4c", "c": "# `pydantic_ai.embeddings`\n\n### EmbeddingModel\n\nBases: `ABC`\n\nAbstract base class for embedding models.\n\nImplement this class to create a custom embedding model. For most use cases, use one of the built-in implementations:\n\n- OpenAIEmbeddingModel\n- CohereEmbeddingModel\n- GoogleEmbeddingModel\n- BedrockEmbeddingModel\n- SentenceTransformerEmbeddingModel\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\nclass EmbeddingModel(ABC):\n    \"\"\"Abstract base class for embedding models.\n\n    Implement this class to create a custom embedding model. For most use cases,\n    use one of the built-in implementations:\n\n    - [`OpenAIEmbeddingModel`][pydantic_ai.embeddings.openai.OpenAIEmbeddingModel]\n    - [`CohereEmbeddingModel`][pydantic_ai.embeddings.cohere.CohereEmbeddingModel]\n    - [`GoogleEmbeddingModel`][pydantic_ai.embeddings.google.GoogleEmbeddingModel]\n    - [`BedrockEmbeddingModel`][pydantic_ai.embeddings.bedrock.BedrockEmbeddingModel]\n    - [`SentenceTransformerEmbeddingModel`][pydantic_ai.embeddings.sentence_transformers.SentenceTransformerEmbeddingModel]\n    \"\"\"\n\n    _settings: EmbeddingSettings | None = None\n\n    def __init__(\n        self,\n        *,\n        settings: EmbeddingSettings | None = None,\n    ) -> None:\n        \"\"\"Initialize the model with optional settings.\n\n        Args:\n            settings: Model-specific settings that will be used as defaults for this model.\n        \"\"\"\n        self._settings = settings\n\n    @property\n    def settings(self) -> EmbeddingSettings | None:\n        \"\"\"Get the default settings for this model.\"\"\"\n        return self._settings\n\n    @property\n    def base_url(self) -> str | None:\n        \"\"\"The base URL for the provider API, if available.\"\"\"\n        return None\n\n    @property\n    @abstractmethod\n    def model_name(self) -> str:\n        \"\"\"The name of the embedding model.\"\"\"\n        raise NotImplementedError()\n\n    @property\n    @abstractmethod\n    def system(self) -> str:\n        \"\"\"The embedding model provider/system identifier (e.g., 'openai', 'cohere').\"\"\"\n        raise NotImplementedError()\n\n    @abstractmethod\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Generate embeddings for the given inputs.\n\n        Args:\n            inputs: A single string or sequence of strings to embed.\n            input_type: Whether the inputs are queries or documents.\n            settings: Optional settings to override the model's defaults.\n\n        Returns:\n            An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing\n            the embeddings and metadata.\n        \"\"\"\n        raise NotImplementedError\n\n    def prepare_embed(\n        self, inputs: str | Sequence[str], settings: EmbeddingSettings | None = None\n    ) -> tuple[list[str], EmbeddingSettings]:\n        \"\"\"Prepare the inputs and settings for embedding.\n\n        This method normalizes inputs to a list and merges settings.\n        Subclasses should call this at the start of their `embed()` implementation.\n\n        Args:\n            inputs: A single string or sequence of strings.\n            settings: Optional settings to merge with defaults.\n\n        Returns:\n            A tuple of (normalized inputs list, merged settings).\n        \"\"\"\n        inputs = [inputs] if isinstance(inputs, str) else list(inputs)\n\n        settings = merge_embedding_settings(self._settings, settings) or {}\n\n        return inputs, settings\n\n    async def max_input_tokens(self) -> int | None:\n        \"\"\"Get the maximum number of tokens that can be input to the model.\n\n        Returns:\n            The maximum token count, or `None` if unknown.\n        \"\"\"\n        return None  # pragma: no cover\n\n    async def count_tokens(self, text: str) -> int:\n        \"\"\"Count the number of tokens in the given text.\n\n        Args:\n            text: The text to tokenize and count.\n\n        Returns:\n            The number of tokens.\n\n        Raises:\n            NotImplementedError: If the model doesn't support token counting.\n            UserError: If the model or tokenizer is not supported.\n        \"\"\"\n        raise NotImplementedError\n```\n\n#### __init__\n\n```python\n__init__(\n    *, settings: EmbeddingSettings | None = None\n) -> None\n```\n\nInitialize the model with optional settings.\n\nParameters:\n\n| Name       | Type                | Description | Default                                                               |\n| ---------- | ------------------- | ----------- | --------------------------------------------------------------------- |\n| `settings` | \\`EmbeddingSettings | None\\`      | Model-specific settings that will be used as defaults for this model. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\ndef __init__(\n    self,\n    *,\n    settings: EmbeddingSettings | None = None,\n) -> None:\n    \"\"\"Initialize the model with optional settings.\n\n    Args:\n        settings: Model-specific settings that will be used as defaults for this model.\n    \"\"\"\n    self._settings = settings\n```\n\n#### settings\n\n```python\nsettings: EmbeddingSettings | None\n```\n\nGet the default settings for this model.\n\n#### base_url\n\n```python\nbase_url: str | None\n```\n\nThe base URL for the provider API, if available.\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe name of the embedding model.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider/system identifier (e.g., 'openai', 'cohere').\n\n#### embed\n\n```python\nembed(\n    inputs: str | Sequence[str],\n    *,\n    input_type: EmbedInputType,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nGenerate embeddings for the given inputs.\n\nParameters:\n\n| Name         | Type                | Description                                  | Default                                             |\n| ------------ | ------------------- | -------------------------------------------- | --------------------------------------------------- |\n| `inputs`     | \\`str               | Sequence[str]\\`                              | A single string or sequence of strings to embed.    |\n| `input_type` | `EmbedInputType`    | Whether the inputs are queries or documents. | *required*                                          |\n| `settings`   | \\`EmbeddingSettings | None\\`                                       | Optional settings to override the model's defaults. |\n\nReturns:\n\n| Type              | Description                   |\n| ----------------- | ----------------------------- |\n| `EmbeddingResult` | An EmbeddingResult containing |\n| `EmbeddingResult` | the embeddings and metadata.  |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\n@abstractmethod\nasync def embed(\n    self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Generate embeddings for the given inputs.\n\n    Args:\n        inputs: A single string or sequence of strings to embed.\n        input_type: Whether the inputs are queries or documents.\n        settings: Optional settings to override the model's defaults.\n\n    Returns:\n        An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing\n        the embeddings and metadata.\n    \"\"\"\n    raise NotImplementedError\n```\n\n#### prepare_embed\n\n```python\nprepare_embed(\n    inputs: str | Sequence[str],\n    settings: EmbeddingSettings | None = None,\n) -> tuple[list[str], EmbeddingSettings]\n```\n\nPrepare the inputs and settings for embedding.\n\nThis method normalizes inputs to a list and merges settings. Subclasses should call this at the start of their `embed()` implementation.\n\nParameters:\n\n| Name       | Type                | Description     | Default                                   |\n| ---------- | ------------------- | --------------- | ----------------------------------------- |\n| `inputs`   | \\`str               | Sequence[str]\\` | A single string or sequence of strings.   |\n| `settings` | \\`EmbeddingSettings | None\\`          | Optional settings to merge with defaults. |\n\nReturns:\n\n| Type                                  | Description                                           |\n| ------------------------------------- | ----------------------------------------------------- |\n| `tuple[list[str], EmbeddingSettings]` | A tuple of (normalized inputs list, merged settings). |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\ndef prepare_embed(\n    self, inputs: str | Sequence[str], settings: EmbeddingSettings | None = None\n) -> tuple[list[str], EmbeddingSettings]:\n    \"\"\"Prepare the inputs and settings for embedding.\n\n    This method normalizes inputs to a list and merges settings.\n    Subclasses should call this at the start of their `embed()` implementation.\n\n    Args:\n        inputs: A single string or sequence of strings.\n        settings: Optional settings to merge with defaults.\n\n    Returns:\n        A tuple of (normalized inputs list, merged settings).\n    \"\"\"\n    inputs = [inputs] if isinstance(inputs, str) else list(inputs)\n\n    settings = merge_embedding_settings(self._settings, settings) or {}\n\n    return inputs, settings\n```\n\n#### max_input_tokens\n\n```python\nmax_input_tokens() -> int | None\n```\n\nGet the maximum number of tokens that can be input to the model.\n\nReturns:\n\n| Type  | Description |\n| ----- | ----------- |\n| \\`int | None\\`      |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\nasync def max_input_tokens(self) -> int | None:\n    \"\"\"Get the maximum number of tokens that can be input to the model.\n\n    Returns:\n        The maximum token count, or `None` if unknown.\n    \"\"\"\n    return None  # pragma: no cover\n```\n\n#### count_tokens\n\n```python\ncount_tokens(text: str) -> int\n```\n\nCount the number of tokens in the given text.\n\nParameters:\n\n| Name   | Type  | Description                     | Default    |\n| ------ | ----- | ------------------------------- | ---------- |\n| `text` | `str` | The text to tokenize and count. | *required* |\n\nReturns:\n\n| Type  | Description           |\n| ----- | --------------------- |\n| `int` | The number of tokens. |\n\nRaises:\n\n| Type                  | Description                                  |\n| --------------------- | -------------------------------------------- |\n| `NotImplementedError` | If the model doesn't support token counting. |\n| `UserError`           | If the model or tokenizer is not supported.  |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\nasync def count_tokens(self, text: str) -> int:\n    \"\"\"Count the number of tokens in the given text.\n\n    Args:\n        text: The text to tokenize and count.\n\n    Returns:\n        The number of tokens.\n\n    Raises:\n        NotImplementedError: If the model doesn't support token counting.\n        UserError: If the model or tokenizer is not supported.\n    \"\"\"\n    raise NotImplementedError\n```\n\n### InstrumentedEmbeddingModel\n\nBases: `WrapperEmbeddingModel`\n\nEmbedding model which wraps another model so that requests are instrumented with OpenTelemetry.\n\nSee the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/instrumented.py`\n\n```python\n@dataclass(init=False)\nclass InstrumentedEmbeddingModel(WrapperEmbeddingModel):\n    \"\"\"Embedding model which wraps another model so that requests are instrumented with OpenTelemetry.\n\n    See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.\n    \"\"\"\n\n    instrumentation_settings: InstrumentationSettings\n    \"\"\"Instrumentation settings for this model.\"\"\"\n\n    def __init__(\n        self,\n        wrapped: EmbeddingModel | str,\n        options: InstrumentationSettings | None = None,\n    ) -> None:\n        super().__init__(wrapped)\n        self.instrumentation_settings = options or InstrumentationSettings()\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        with self._instrument(inputs, input_type, settings) as finish:\n            result = await super().embed(inputs, input_type=input_type, settings=settings)\n            finish(result)\n            return result\n\n    @contextmanager\n    def _instrument(\n        self,\n        inputs: list[str],\n        input_type: EmbedInputType,\n        settings: EmbeddingSettings | None,\n    ) -> Iterator[Callable[[EmbeddingResult], None]]:\n        operation = 'embeddings'\n        span_name = f'{operation} {self.model_name}'\n\n        inputs_count = len(inputs)\n\n        attributes: dict[str, AttributeValue] = {\n            'gen_ai.operation.name': operation,\n            **self.model_attributes(self.wrapped),\n            'input_type': input_type,\n            'inputs_count': inputs_count,\n        }\n\n        if settings:\n            attributes['embedding_settings'] = json.dumps(self.serialize_any(settings))\n\n        if self.instrumentation_settings.include_content:\n            attributes['inputs'] = json.dumps(inputs)\n\n        attributes['logfire.json_schema'] = json.dumps(\n            {\n                'type': 'object',\n                'properties': {\n                    'input_type': {'type': 'string'},\n                    'inputs_count': {'type': 'integer'},\n                    'embedding_settings': {'type': 'object'},\n                    **(\n                        {'inputs': {'type': ['array']}, 'embeddings': {'type': 'array'}}\n                        if self.instrumentation_settings.include_content\n                        else {}\n                    ),\n                },\n            }\n        )\n\n        record_metrics: Callable[[], None] | None = None\n        try:\n            with self.instrumentation_settings.tracer.start_as_current_span(span_name, attributes=attributes) as span:\n\n                def finish(result: EmbeddingResult):\n                    # Prepare metric recording closure first so metrics are recorded\n                    # even if the span is not recording.\n                    provider_name = attributes[GEN_AI_PROVIDER_NAME_ATTRIBUTE]\n                    request_model = attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE]\n                    response_model = result.model_name or request_model\n                    price_calculation = None\n\n                    def _record_metrics():\n                        token_attributes = {\n                            GEN_AI_PROVIDER_NAME_ATTRIBUTE: provider_name,\n                            'gen_ai.operation.name': operation,\n                            GEN_AI_REQUEST_MODEL_ATTRIBUTE: request_model,\n                            'gen_ai.response.model': response_model,\n                            'gen_ai.token.type': 'input',\n                        }\n                        tokens = result.usage.input_tokens or 0\n                        if tokens:  # pragma: no branch\n                            self.instrumentation_settings.tokens_histogram.record(tokens, token_attributes)\n                            if price_calculation is not None:\n                                self.instrumentation_settings.cost_histogram.record(\n                                    float(getattr(price_calculation, 'input_price', 0.0)),\n                                    token_attributes,\n                                )\n\n                    nonlocal record_metrics\n                    record_metrics = _record_metrics\n\n                    if not span.is_recording():\n                        return  # pragma: lax no cover\n\n                    attributes_to_set: dict[str, AttributeValue] = {\n                        **result.usage.opentelemetry_attributes(),\n                        'gen_ai.response.model': response_model,\n                    }\n\n                    try:\n                        price_calculation = result.cost()\n                    except LookupError:\n                        # The cost of this provider/model is unknown, which is common.\n                        pass\n                    except Exception as e:  # pragma: no cover\n                        warnings.warn(\n                            f'Failed to get cost from response: {type(e).__name__}: {e}', CostCalculationFailedWarning\n                        )\n                    else:\n                        attributes_to_set['operation.cost'] = float(price_calculation.total_price)\n\n                    embeddings = result.embeddings\n                    if embeddings:  # pragma: no branch\n                        attributes_to_set['gen_ai.embeddings.dimension.count'] = len(embeddings[0])\n                        if self.instrumentation_settings.include_content:\n                            attributes['embeddings'] = json.dumps(embeddings)\n\n                    if result.provider_response_id is not None:\n                        attributes_to_set['gen_ai.response.id'] = result.provider_response_id\n\n                    span.set_attributes(attributes_to_set)\n\n                yield finish\n        finally:\n            if record_metrics:  # pragma: no branch\n                # Record metrics after the span finishes to avoid duplication.\n                record_metrics()\n\n    @staticmethod\n    def model_attributes(model: EmbeddingModel) -> dict[str, AttributeValue]:\n        attributes: dict[str, AttributeValue] = {\n            GEN_AI_PROVIDER_NAME_ATTRIBUTE: model.system,\n            GEN_AI_REQUEST_MODEL_ATTRIBUTE: model.model_name,\n        }\n        if base_url := model.base_url:\n            try:\n                parsed = urlparse(base_url)\n            except Exception:  # pragma: no cover\n                pass\n            else:\n                if parsed.hostname:  # pragma: no branch\n                    attributes['server.address'] = parsed.hostname\n                if parsed.port:\n                    attributes['server.port'] = parsed.port  # pragma: no cover\n\n        return attributes\n\n    @staticmethod\n    def serialize_any(value: Any) -> str:\n        try:\n            return ANY_ADAPTER.dump_python(value, mode='json')\n        except Exception:  # pragma: no cover\n            try:\n                return str(value)\n            except Exception as e:\n                return f'Unable to serialize: {e}'\n```\n\n#### instrumentation_settings\n\n```python\ninstrumentation_settings: InstrumentationSettings = (\n    options or InstrumentationSettings()\n)\n```\n\nInstrumentation settings for this model.\n\n### instrument_embedding_model\n\n```python\ninstrument_embedding_model(\n    model: EmbeddingModel,\n    instrument: InstrumentationSettings | bool,\n) -> EmbeddingModel\n```\n\nInstrument an embedding model with OpenTelemetry/logfire.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/instrumented.py`\n\n```python\ndef instrument_embedding_model(model: EmbeddingModel, instrument: InstrumentationSettings | bool) -> EmbeddingModel:\n    \"\"\"Instrument an embedding model with OpenTelemetry/logfire.\"\"\"\n    if instrument and not isinstance(model, InstrumentedEmbeddingModel):\n        if instrument is True:\n            instrument = InstrumentationSettings()\n\n        model = InstrumentedEmbeddingModel(model, instrument)\n\n    return model\n```\n\n### EmbeddingResult\n\nThe result of an embedding operation.\n\nThis class contains the generated embeddings along with metadata about the operation, including the original inputs, model information, usage statistics, and timing.\n\nExample:\n\n```python\nfrom pydantic_ai import Embedder\n\nembedder = Embedder('openai:text-embedding-3-small')\n\n\nasync def main():\n    result = await embedder.embed_query('What is AI?')\n\n    # Access embeddings by index\n    print(len(result.embeddings[0]))\n    #> 1536\n\n    # Access embeddings by original input text\n    print(result['What is AI?'] == result.embeddings[0])\n    #> True\n\n    # Check usage\n    print(f'Tokens used: {result.usage.input_tokens}')\n    #> Tokens used: 3\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/result.py`\n\n````python\n@dataclass\nclass EmbeddingResult:\n    \"\"\"The result of an embedding operation.\n\n    This class contains the generated embeddings along with metadata about\n    the operation, including the original inputs, model information, usage\n    statistics, and timing.\n\n    Example:\n    ```python\n    from pydantic_ai import Embedder\n\n    embedder = Embedder('openai:text-embedding-3-small')\n\n\n    async def main():\n        result = await embedder.embed_query('What is AI?')\n\n        # Access embeddings by index\n        print(len(result.embeddings[0]))\n        #> 1536\n\n        # Access embeddings by original input text\n        print(result['What is AI?'] == result.embeddings[0])\n        #> True\n\n        # Check usage\n        print(f'Tokens used: {result.usage.input_tokens}')\n        #> Tokens used: 3\n    ```\n    \"\"\"\n\n    embeddings: Sequence[Sequence[float]]\n    \"\"\"The computed embedding vectors, one per input text.\n\n    Each embedding is a sequence of floats representing the text in vector space.\n    \"\"\"\n\n    _: KW_ONLY\n\n    inputs: Sequence[str]\n    \"\"\"The original input texts that were embedded.\"\"\"\n\n    input_type: EmbedInputType\n    \"\"\"Whether the inputs were embedded as queries or documents.\"\"\"\n\n    model_name: str\n    \"\"\"The name of the model that generated these embeddings.\"\"\"\n\n    provider_name: str\n    \"\"\"The name of the provider (e.g., 'openai', 'cohere').\"\"\"\n\n    timestamp: datetime = field(default_factory=_now_utc)\n    \"\"\"When the embedding request was made.\"\"\"\n\n    usage: RequestUsage = field(default_factory=RequestUsage)\n    \"\"\"Token usage statistics for this request.\"\"\"\n\n    provider_details: dict[str, Any] | None = None\n    \"\"\"Provider-specific details from the response.\"\"\"\n\n    provider_response_id: str | None = None\n    \"\"\"Unique identifier for this response from the provider, if available.\"\"\"\n\n    def __getitem__(self, item: int | str) -> Sequence[float]:\n        \"\"\"Get the embedding for an input by index or by the original input text.\n\n        Args:\n            item: Either an integer index or the original input string.\n\n        Returns:\n            The embedding vector for the specified input.\n\n        Raises:\n            IndexError: If the index is out of range.\n            ValueError: If the string is not found in the inputs.\n        \"\"\"\n        if isinstance(item, str):\n            item = self.inputs.index(item)\n\n        return self.embeddings[item]\n\n    def cost(self) -> genai_types.PriceCalculation:\n        \"\"\"Calculate the cost of the embedding request.\n\n        Uses [`genai-prices`](https://github.com/pydantic/genai-prices) for pricing data.\n\n        Returns:\n            A price calculation object with `total_price`, `input_price`, and other cost details.\n\n        Raises:\n            LookupError: If pricing data is not available for this model/provider.\n        \"\"\"\n        assert self.model_name, 'Model name is required to calculate price'\n        return calc_price(\n            self.usage,\n            self.model_name,\n            provider_id=self.provider_name,\n            genai_request_timestamp=self.timestamp,\n        )\n````\n\n#### embeddings\n\n```python\nembeddings: Sequence[Sequence[float]]\n```\n\nThe computed embedding vectors, one per input text.\n\nEach embedding is a sequence of floats representing the text in vector space.\n\n#### inputs\n\n```python\ninputs: Sequence[str]\n```\n\nThe original input texts that were embedded.\n\n#### input_type\n\n```python\ninput_type: EmbedInputType\n```\n\nWhether the inputs were embedded as queries or documents.\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe name of the model that generated these embeddings.\n\n#### provider_name\n\n```python\nprovider_name: str\n```\n\nThe name of the provider (e.g., 'openai', 'cohere').\n\n#### timestamp\n\n```python\ntimestamp: datetime = field(default_factory=now_utc)\n```\n\nWhen the embedding request was made.\n\n#### usage\n\n```python\nusage: RequestUsage = field(default_factory=RequestUsage)\n```\n\nToken usage statistics for this request.\n\n#### provider_details\n\n```python\nprovider_details: dict[str, Any] | None = None\n```\n\nProvider-specific details from the response.\n\n#### provider_response_id\n\n```python\nprovider_response_id: str | None = None\n```\n\nUnique identifier for this response from the provider, if available.\n\n#### __getitem__\n\n```python\n__getitem__(item: int | str) -> Sequence[float]\n```\n\nGet the embedding for an input by index or by the original input text.\n\nParameters:\n\n| Name   | Type  | Description | Default                                               |\n| ------ | ----- | ----------- | ----------------------------------------------------- |\n| `item` | \\`int | str\\`       | Either an integer index or the original input string. |\n\nReturns:\n\n| Type              | Description                                   |\n| ----------------- | --------------------------------------------- |\n| `Sequence[float]` | The embedding vector for the specified input. |\n\nRaises:\n\n| Type         | Description                               |\n| ------------ | ----------------------------------------- |\n| `IndexError` | If the index is out of range.             |\n| `ValueError` | If the string is not found in the inputs. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/result.py`\n\n```python\ndef __getitem__(self, item: int | str) -> Sequence[float]:\n    \"\"\"Get the embedding for an input by index or by the original input text.\n\n    Args:\n        item: Either an integer index or the original input string.\n\n    Returns:\n        The embedding vector for the specified input.\n\n    Raises:\n        IndexError: If the index is out of range.\n        ValueError: If the string is not found in the inputs.\n    \"\"\"\n    if isinstance(item, str):\n        item = self.inputs.index(item)\n\n    return self.embeddings[item]\n```\n\n#### cost\n\n```python\ncost() -> PriceCalculation\n```\n\nCalculate the cost of the embedding request.\n\nUses [`genai-prices`](https://github.com/pydantic/genai-prices) for pricing data.\n\nReturns:\n\n| Type               | Description                                                                       |\n| ------------------ | --------------------------------------------------------------------------------- |\n| `PriceCalculation` | A price calculation object with total_price, input_price, and other cost details. |\n\nRaises:\n\n| Type          | Description                                               |\n| ------------- | --------------------------------------------------------- |\n| `LookupError` | If pricing data is not available for this model/provider. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/result.py`\n\n```python\ndef cost(self) -> genai_types.PriceCalculation:\n    \"\"\"Calculate the cost of the embedding request.\n\n    Uses [`genai-prices`](https://github.com/pydantic/genai-prices) for pricing data.\n\n    Returns:\n        A price calculation object with `total_price`, `input_price`, and other cost details.\n\n    Raises:\n        LookupError: If pricing data is not available for this model/provider.\n    \"\"\"\n    assert self.model_name, 'Model name is required to calculate price'\n    return calc_price(\n        self.usage,\n        self.model_name,\n        provider_id=self.provider_name,\n        genai_request_timestamp=self.timestamp,\n    )\n```\n\n### EmbeddingSettings\n\nBases: `TypedDict`\n\nCommon settings for configuring embedding models.\n\nThese settings apply across multiple embedding model providers. Not all settings are supported by all models - check the specific model's documentation for details.\n\nProvider-specific settings classes (e.g., OpenAIEmbeddingSettings, CohereEmbeddingSettings) extend this with additional provider-prefixed options.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/settings.py`\n\n```python\nclass EmbeddingSettings(TypedDict, total=False):\n    \"\"\"Common settings for configuring embedding models.\n\n    These settings apply across multiple embedding model providers.\n    Not all settings are supported by all models - check the specific\n    model's documentation for details.\n\n    Provider-specific settings classes (e.g.,\n    [`OpenAIEmbeddingSettings`][pydantic_ai.embeddings.openai.OpenAIEmbeddingSettings],\n    [`CohereEmbeddingSettings`][pydantic_ai.embeddings.cohere.CohereEmbeddingSettings])\n    extend this with additional provider-prefixed options.\n    \"\"\"\n\n    dimensions: int\n    \"\"\"The number of dimensions for the output embeddings.\n\n    Supported by:\n\n    * OpenAI\n    * Cohere\n    * Google\n    * Sentence Transformers\n    * Bedrock\n    * VoyageAI\n    \"\"\"\n\n    truncate: bool\n    \"\"\"Whether to truncate inputs that exceed the model's context length.\n\n    Defaults to `False`. If `True`, inputs that are too long will be truncated.\n    If `False`, an error will be raised for inputs that exceed the context length.\n\n    For more control over truncation, you can use\n    [`max_input_tokens()`][pydantic_ai.embeddings.Embedder.max_input_tokens] and\n    [`count_tokens()`][pydantic_ai.embeddings.Embedder.count_tokens] to implement\n    your own truncation logic.\n\n    Provider-specific truncation settings (e.g., `cohere_truncate`, `bedrock_cohere_truncate`)\n    take precedence if specified.\n\n    Supported by:\n\n    * Cohere\n    * Bedrock (Cohere and Nova models)\n    * VoyageAI\n    \"\"\"\n\n    extra_headers: dict[str, str]\n    \"\"\"Extra headers to send to the model.\n\n    Supported by:\n\n    * OpenAI\n    * Cohere\n    \"\"\"\n\n    extra_body: object\n    \"\"\"Extra body to send to the model.\n\n    Supported by:\n\n    * OpenAI\n    * Cohere\n    \"\"\"\n```\n\n#### dimensions\n\n```python\ndimensions: int\n```\n\nThe number of dimensions for the output embeddings.\n\nSupported by:\n\n- OpenAI\n- Cohere\n- Google\n- Sentence Transformers\n- Bedrock\n- VoyageAI\n\n#### truncate\n\n```python\ntruncate: bool\n```\n\nWhether to truncate inputs that exceed the model's context length.\n\nDefaults to `False`. If `True`, inputs that are too long will be truncated. If `False`, an error will be raised for inputs that exceed the context length.\n\nFor more control over truncation, you can use max_input_tokens() and count_tokens() to implement your own truncation logic.\n\nProvider-specific truncation settings (e.g., `cohere_truncate`, `bedrock_cohere_truncate`) take precedence if specified.\n\nSupported by:\n\n- Cohere\n- Bedrock (Cohere and Nova models)\n- VoyageAI\n\n#### extra_headers\n\n```python\nextra_headers: dict[str, str]\n```\n\nExtra headers to send to the model.\n\nSupported by:\n\n- OpenAI\n- Cohere\n\n#### extra_body\n\n```python\nextra_body: object\n```\n\nExtra body to send to the model.\n\nSupported by:\n\n- OpenAI\n- Cohere\n\n### merge_embedding_settings\n\n```python\nmerge_embedding_settings(\n    base: EmbeddingSettings | None,\n    overrides: EmbeddingSettings | None,\n) -> EmbeddingSettings | None\n```\n\nMerge two sets of embedding settings, with overrides taking precedence.\n\nParameters:\n\n| Name        | Type                | Description | Default                                                               |\n| ----------- | ------------------- | ----------- | --------------------------------------------------------------------- |\n| `base`      | \\`EmbeddingSettings | None\\`      | Base settings (typically from the embedder or model).                 |\n| `overrides` | \\`EmbeddingSettings | None\\`      | Settings that should override the base (typically per-call settings). |\n\nReturns:\n\n| Type                | Description |\n| ------------------- | ----------- |\n| \\`EmbeddingSettings | None\\`      |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/settings.py`\n\n```python\ndef merge_embedding_settings(\n    base: EmbeddingSettings | None, overrides: EmbeddingSettings | None\n) -> EmbeddingSettings | None:\n    \"\"\"Merge two sets of embedding settings, with overrides taking precedence.\n\n    Args:\n        base: Base settings (typically from the embedder or model).\n        overrides: Settings that should override the base (typically per-call settings).\n\n    Returns:\n        Merged settings, or `None` if both inputs are `None`.\n    \"\"\"\n    # Note: we may want merge recursively if/when we add non-primitive values\n    if base and overrides:\n        return base | overrides\n    else:\n        return base or overrides\n```\n\n### TestEmbeddingModel\n\nBases: `EmbeddingModel`\n\nA mock embedding model for testing.\n\nThis model returns deterministic embeddings (all 1.0 values) and tracks the settings used in the last call via the `last_settings` attribute.\n\nExample:\n\n```python\nfrom pydantic_ai import Embedder\nfrom pydantic_ai.embeddings import TestEmbeddingModel\n\ntest_model = TestEmbeddingModel()\nembedder = Embedder('openai:text-embedding-3-small')\n\n\nasync def main():\n    with embedder.override(model=test_model):\n        await embedder.embed_query('test')\n        assert test_model.last_settings is not None\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/test.py`\n\n````python\n@dataclass(init=False)\nclass TestEmbeddingModel(EmbeddingModel):\n    \"\"\"A mock embedding model for testing.\n\n    This model returns deterministic embeddings (all 1.0 values) and tracks\n    the settings used in the last call via the `last_settings` attribute.\n\n    Example:\n    ```python\n    from pydantic_ai import Embedder\n    from pydantic_ai.embeddings import TestEmbeddingModel\n\n    test_model = TestEmbeddingModel()\n    embedder = Embedder('openai:text-embedding-3-small')\n\n\n    async def main():\n        with embedder.override(model=test_model):\n            await embedder.embed_query('test')\n            assert test_model.last_settings is not None\n    ```\n    \"\"\"\n\n    # NOTE: Avoid test discovery by pytest.\n    __test__ = False\n\n    _model_name: str\n    \"\"\"The model name to report in results.\"\"\"\n\n    _provider_name: str\n    \"\"\"The provider name to report in results.\"\"\"\n\n    _dimensions: int\n    \"\"\"The number of dimensions for generated embeddings.\"\"\"\n\n    last_settings: EmbeddingSettings | None = None\n    \"\"\"The settings used in the most recent embed call.\"\"\"\n\n    def __init__(\n        self,\n        model_name: str = 'test',\n        *,\n        provider_name: str = 'test',\n        dimensions: int = 8,\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize the test embedding model.\n\n        Args:\n            model_name: The model name to report in results.\n            provider_name: The provider name to report in results.\n            dimensions: The number of dimensions for the generated embeddings.\n            settings: Optional default settings for the model.\n        \"\"\"\n        self._model_name = model_name\n        self._provider_name = provider_name\n        self._dimensions = dimensions\n        self.last_settings = None\n        super().__init__(settings=settings)\n\n    @property\n    def model_name(self) -> str:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider_name\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        self.last_settings = settings\n\n        dimensions = settings.get('dimensions') or self._dimensions\n\n        return EmbeddingResult(\n            embeddings=[[1.0] * dimensions] * len(inputs),\n            inputs=inputs,\n            input_type=input_type,\n            usage=RequestUsage(input_tokens=sum(_estimate_tokens(text) for text in inputs)),\n            model_name=self.model_name,\n            provider_name=self.system,\n            provider_response_id=str(uuid.uuid4()),\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        return 1024\n\n    async def count_tokens(self, text: str) -> int:\n        return _estimate_tokens(text)\n````\n\n#### last_settings\n\n```python\nlast_settings: EmbeddingSettings | None = None\n```\n\nThe settings used in the most recent embed call.\n\n#### __init__\n\n```python\n__init__(\n    model_name: str = \"test\",\n    *,\n    provider_name: str = \"test\",\n    dimensions: int = 8,\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize the test embedding model.\n\nParameters:\n\n| Name            | Type                | Description                                            | Default                                  |\n| --------------- | ------------------- | ------------------------------------------------------ | ---------------------------------------- |\n| `model_name`    | `str`               | The model name to report in results.                   | `'test'`                                 |\n| `provider_name` | `str`               | The provider name to report in results.                | `'test'`                                 |\n| `dimensions`    | `int`               | The number of dimensions for the generated embeddings. | `8`                                      |\n| `settings`      | \\`EmbeddingSettings | None\\`                                                 | Optional default settings for the model. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/test.py`\n\n```python\ndef __init__(\n    self,\n    model_name: str = 'test',\n    *,\n    provider_name: str = 'test',\n    dimensions: int = 8,\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize the test embedding model.\n\n    Args:\n        model_name: The model name to report in results.\n        provider_name: The provider name to report in results.\n        dimensions: The number of dimensions for the generated embeddings.\n        settings: Optional default settings for the model.\n    \"\"\"\n    self._model_name = model_name\n    self._provider_name = provider_name\n    self._dimensions = dimensions\n    self.last_settings = None\n    super().__init__(settings=settings)\n```\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n### WrapperEmbeddingModel\n\nBases: `EmbeddingModel`\n\nBase class for embedding models that wrap another model.\n\nUse this as a base class to create custom embedding model wrappers that modify behavior (e.g., caching, logging, rate limiting) while delegating to an underlying model.\n\nBy default, all methods are passed through to the wrapped model. Override specific methods to customize behavior.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/wrapper.py`\n\n```python\n@dataclass(init=False)\nclass WrapperEmbeddingModel(EmbeddingModel):\n    \"\"\"Base class for embedding models that wrap another model.\n\n    Use this as a base class to create custom embedding model wrappers\n    that modify behavior (e.g., caching, logging, rate limiting) while\n    delegating to an underlying model.\n\n    By default, all methods are passed through to the wrapped model.\n    Override specific methods to customize behavior.\n    \"\"\"\n\n    wrapped: EmbeddingModel\n    \"\"\"The underlying embedding model being wrapped.\"\"\"\n\n    def __init__(self, wrapped: EmbeddingModel | str):\n        \"\"\"Initialize the wrapper with an embedding model.\n\n        Args:\n            wrapped: The model to wrap. Can be an\n                [`EmbeddingModel`][pydantic_ai.embeddings.EmbeddingModel] instance\n                or a model name string (e.g., `'openai:text-embedding-3-small'`).\n        \"\"\"\n        from . import infer_embedding_model\n\n        super().__init__()\n        self.wrapped = infer_embedding_model(wrapped) if isinstance(wrapped, str) else wrapped\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        return await self.wrapped.embed(inputs, input_type=input_type, settings=settings)\n\n    async def max_input_tokens(self) -> int | None:\n        return await self.wrapped.max_input_tokens()\n\n    async def count_tokens(self, text: str) -> int:\n        return await self.wrapped.count_tokens(text)\n\n    @property\n    def model_name(self) -> str:\n        return self.wrapped.model_name\n\n    @property\n    def system(self) -> str:\n        return self.wrapped.system\n\n    @property\n    def settings(self) -> EmbeddingSettings | None:\n        \"\"\"Get the settings from the wrapped embedding model.\"\"\"\n        return self.wrapped.settings\n\n    @property\n    def base_url(self) -> str | None:\n        return self.wrapped.base_url\n\n    def __getattr__(self, item: str):\n        return getattr(self.wrapped, item)  # pragma: no cover\n```\n\n#### wrapped\n\n```python\nwrapped: EmbeddingModel = (\n    infer_embedding_model(wrapped)\n    if isinstance(wrapped, str)\n    else wrapped\n)\n```\n\nThe underlying embedding model being wrapped.\n\n#### __init__\n\n```python\n__init__(wrapped: EmbeddingModel | str)\n```\n\nInitialize the wrapper with an embedding model.\n\nParameters:\n\n| Name      | Type             | Description | Default                                                                                                              |\n| --------- | ---------------- | ----------- | -------------------------------------------------------------------------------------------------------------------- |\n| `wrapped` | \\`EmbeddingModel | str\\`       | The model to wrap. Can be an EmbeddingModel instance or a model name string (e.g., 'openai:text-embedding-3-small'). |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/wrapper.py`\n\n```python\ndef __init__(self, wrapped: EmbeddingModel | str):\n    \"\"\"Initialize the wrapper with an embedding model.\n\n    Args:\n        wrapped: The model to wrap. Can be an\n            [`EmbeddingModel`][pydantic_ai.embeddings.EmbeddingModel] instance\n            or a model name string (e.g., `'openai:text-embedding-3-small'`).\n    \"\"\"\n    from . import infer_embedding_model\n\n    super().__init__()\n    self.wrapped = infer_embedding_model(wrapped) if isinstance(wrapped, str) else wrapped\n```\n\n#### settings\n\n```python\nsettings: EmbeddingSettings | None\n```\n\nGet the settings from the wrapped embedding model.\n\n### KnownEmbeddingModelName\n\n```python\nKnownEmbeddingModelName = TypeAliasType(\n    \"KnownEmbeddingModelName\",\n    Literal[\n        \"google-gla:gemini-embedding-001\",\n        \"google-vertex:gemini-embedding-001\",\n        \"google-vertex:text-embedding-005\",\n        \"google-vertex:text-multilingual-embedding-002\",\n        \"openai:text-embedding-ada-002\",\n        \"openai:text-embedding-3-small\",\n        \"openai:text-embedding-3-large\",\n        \"cohere:embed-v4.0\",\n        \"cohere:embed-english-v3.0\",\n        \"cohere:embed-english-light-v3.0\",\n        \"cohere:embed-multilingual-v3.0\",\n        \"cohere:embed-multilingual-light-v3.0\",\n        \"voyageai:voyage-4-large\",\n        \"voyageai:voyage-4\",\n        \"voyageai:voyage-4-lite\",\n        \"voyageai:voyage-3-large\",\n        \"voyageai:voyage-3.5\",\n        \"voyageai:voyage-3.5-lite\",\n        \"voyageai:voyage-code-3\",\n        \"voyageai:voyage-finance-2\",\n        \"voyageai:voyage-law-2\",\n        \"voyageai:voyage-code-2\",\n        \"bedrock:amazon.titan-embed-text-v1\",\n        \"bedrock:amazon.titan-embed-text-v2:0\",\n        \"bedrock:cohere.embed-english-v3\",\n        \"bedrock:cohere.embed-multilingual-v3\",\n        \"bedrock:cohere.embed-v4:0\",\n        \"bedrock:amazon.nova-2-multimodal-embeddings-v1:0\",\n    ],\n)\n```\n\nKnown model names that can be used with the `model` parameter of Embedder.\n\n`KnownEmbeddingModelName` is provided as a concise way to specify an embedding model.\n\n### infer_embedding_model\n\n```python\ninfer_embedding_model(\n    model: EmbeddingModel | KnownEmbeddingModelName | str,\n    *,\n    provider_factory: Callable[\n        [str], Provider[Any]\n    ] = infer_provider\n) -> EmbeddingModel\n```\n\nInfer the model from the name.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef infer_embedding_model(\n    model: EmbeddingModel | KnownEmbeddingModelName | str,\n    *,\n    provider_factory: Callable[[str], Provider[Any]] = infer_provider,\n) -> EmbeddingModel:\n    \"\"\"Infer the model from the name.\"\"\"\n    if isinstance(model, EmbeddingModel):\n        return model\n\n    try:\n        provider_name, model_name = model.split(':', maxsplit=1)\n    except ValueError as e:\n        raise ValueError('You must provide a provider prefix when specifying an embedding model name') from e\n\n    provider = provider_factory(provider_name)\n\n    model_kind = provider_name\n    if model_kind.startswith('gateway/'):\n        from ..providers.gateway import normalize_gateway_provider\n\n        model_kind = normalize_gateway_provider(model_kind)\n\n    if model_kind in (\n        'openai',\n        # For now, we assume that every chat and completions-compatible provider also\n        # supports the embeddings endpoint, as at worst the user would get an `ModelHTTPError`.\n        *get_args(OpenAIChatCompatibleProvider.__value__),\n        *get_args(OpenAIResponsesCompatibleProvider.__value__),\n    ):\n        from .openai import OpenAIEmbeddingModel\n\n        return OpenAIEmbeddingModel(model_name, provider=provider)\n    elif model_kind == 'cohere':\n        from .cohere import CohereEmbeddingModel\n\n        return CohereEmbeddingModel(model_name, provider=provider)\n    elif model_kind == 'bedrock':\n        from .bedrock import BedrockEmbeddingModel\n\n        return BedrockEmbeddingModel(model_name, provider=provider)\n    elif model_kind in ('google-gla', 'google-vertex'):\n        from .google import GoogleEmbeddingModel\n\n        return GoogleEmbeddingModel(model_name, provider=provider)\n    elif model_kind == 'sentence-transformers':\n        from .sentence_transformers import SentenceTransformerEmbeddingModel\n\n        return SentenceTransformerEmbeddingModel(model_name)\n    elif model_kind == 'voyageai':\n        from .voyageai import VoyageAIEmbeddingModel\n\n        return VoyageAIEmbeddingModel(model_name, provider=provider)\n    else:\n        raise UserError(f'Unknown embeddings model: {model}')  # pragma: no cover\n```\n\n### Embedder\n\nHigh-level interface for generating text embeddings.\n\nThe `Embedder` class provides a convenient way to generate vector embeddings from text using various embedding model providers. It handles model inference, settings management, and optional OpenTelemetry instrumentation.\n\nExample:\n\n```python\nfrom pydantic_ai import Embedder\n\nembedder = Embedder('openai:text-embedding-3-small')\n\n\nasync def main():\n    result = await embedder.embed_query('What is machine learning?')\n    print(result.embeddings[0][:5])  # First 5 dimensions\n    #> [1.0, 1.0, 1.0, 1.0, 1.0]\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n````python\n@dataclass(init=False)\nclass Embedder:\n    \"\"\"High-level interface for generating text embeddings.\n\n    The `Embedder` class provides a convenient way to generate vector embeddings from text\n    using various embedding model providers. It handles model inference, settings management,\n    and optional OpenTelemetry instrumentation.\n\n    Example:\n    ```python\n    from pydantic_ai import Embedder\n\n    embedder = Embedder('openai:text-embedding-3-small')\n\n\n    async def main():\n        result = await embedder.embed_query('What is machine learning?')\n        print(result.embeddings[0][:5])  # First 5 dimensions\n        #> [1.0, 1.0, 1.0, 1.0, 1.0]\n    ```\n    \"\"\"\n\n    instrument: InstrumentationSettings | bool | None\n    \"\"\"Options to automatically instrument with OpenTelemetry.\n\n    Set to `True` to use default instrumentation settings, which will use Logfire if it's configured.\n    Set to an instance of [`InstrumentationSettings`][pydantic_ai.models.instrumented.InstrumentationSettings] to customize.\n    If this isn't set, then the last value set by\n    [`Embedder.instrument_all()`][pydantic_ai.embeddings.Embedder.instrument_all]\n    will be used, which defaults to False.\n    See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.\n    \"\"\"\n\n    _instrument_default: ClassVar[InstrumentationSettings | bool] = False\n\n    def __init__(\n        self,\n        model: EmbeddingModel | KnownEmbeddingModelName | str,\n        *,\n        settings: EmbeddingSettings | None = None,\n        defer_model_check: bool = True,\n        instrument: InstrumentationSettings | bool | None = None,\n    ) -> None:\n        \"\"\"Initialize an Embedder.\n\n        Args:\n            model: The embedding model to use. Can be specified as:\n\n                - A model name string in the format `'provider:model-name'`\n                  (e.g., `'openai:text-embedding-3-small'`)\n                - An [`EmbeddingModel`][pydantic_ai.embeddings.EmbeddingModel] instance\n            settings: Optional [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n                to use as defaults for all embed calls.\n            defer_model_check: Whether to defer model validation until first use.\n                Set to `False` to validate the model immediately on construction.\n            instrument: OpenTelemetry instrumentation settings. Set to `True` to enable with defaults,\n                or pass an [`InstrumentationSettings`][pydantic_ai.models.instrumented.InstrumentationSettings]\n                instance to customize. If `None`, uses the value from\n                [`Embedder.instrument_all()`][pydantic_ai.embeddings.Embedder.instrument_all].\n        \"\"\"\n        self._model = model if defer_model_check else infer_embedding_model(model)\n        self._settings = settings\n        self.instrument = instrument\n\n        self._override_model: ContextVar[EmbeddingModel | None] = ContextVar('_override_model', default=None)\n\n    @staticmethod\n    def instrument_all(instrument: InstrumentationSettings | bool = True) -> None:\n        \"\"\"Set the default instrumentation options for all embedders where `instrument` is not explicitly set.\n\n        This is useful for enabling instrumentation globally without modifying each embedder individually.\n\n        Args:\n            instrument: Instrumentation settings to use as the default. Set to `True` for default settings,\n                `False` to disable, or pass an\n                [`InstrumentationSettings`][pydantic_ai.models.instrumented.InstrumentationSettings]\n                instance to customize.\n        \"\"\"\n        Embedder._instrument_default = instrument\n\n    @property\n    def model(self) -> EmbeddingModel | KnownEmbeddingModelName | str:\n        \"\"\"The embedding model used by this embedder.\"\"\"\n        return self._model\n\n    @contextmanager\n    def override(\n        self,\n        *,\n        model: EmbeddingModel | KnownEmbeddingModelName | str | _utils.Unset = _utils.UNSET,\n    ) -> Iterator[None]:\n        \"\"\"Context manager to temporarily override the embedding model.\n\n        Useful for testing or dynamically switching models.\n\n        Args:\n            model: The embedding model to use within this context.\n\n        Example:\n        ```python\n        from pydantic_ai import Embedder\n\n        embedder = Embedder('openai:text-embedding-3-small')\n\n\n        async def main():\n            # Temporarily use a different model\n            with embedder.override(model='openai:text-embedding-3-large'):\n                result = await embedder.embed_query('test')\n                print(len(result.embeddings[0]))  # 3072 dimensions for large model\n                #> 3072\n        ```\n        \"\"\"\n        if _utils.is_set(model):\n            model_token = self._override_model.set(infer_embedding_model(model))\n        else:\n            model_token = None\n\n        try:\n            yield\n        finally:\n            if model_token is not None:\n                self._override_model.reset(model_token)\n\n    async def embed_query(\n        self, query: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Embed one or more query texts.\n\n        Use this method when embedding search queries that will be compared against document embeddings.\n        Some models optimize embeddings differently based on whether the input is a query or document.\n\n        Args:\n            query: A single query string or sequence of query strings to embed.\n            settings: Optional settings to override the embedder's default settings for this call.\n\n        Returns:\n            An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing the embeddings\n            and metadata about the operation.\n        \"\"\"\n        return await self.embed(query, input_type='query', settings=settings)\n\n    async def embed_documents(\n        self, documents: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Embed one or more document texts.\n\n        Use this method when embedding documents that will be stored and later searched against.\n        Some models optimize embeddings differently based on whether the input is a query or document.\n\n        Args:\n            documents: A single document string or sequence of document strings to embed.\n            settings: Optional settings to override the embedder's default settings for this call.\n\n        Returns:\n            An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing the embeddings\n            and metadata about the operation.\n        \"\"\"\n        return await self.embed(documents, input_type='document', settings=settings)\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Embed text inputs with explicit input type specification.\n\n        This is the low-level embedding method. For most use cases, prefer\n        [`embed_query()`][pydantic_ai.embeddings.Embedder.embed_query] or\n        [`embed_documents()`][pydantic_ai.embeddings.Embedder.embed_documents].\n\n        Args:\n            inputs: A single string or sequence of strings to embed.\n            input_type: The type of input, either `'query'` or `'document'`.\n            settings: Optional settings to override the embedder's default settings for this call.\n\n        Returns:\n            An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing the embeddings\n            and metadata about the operation.\n        \"\"\"\n        model = self._get_model()\n        settings = merge_embedding_settings(self._settings, settings)\n        return await model.embed(inputs, input_type=input_type, settings=settings)\n\n    async def max_input_tokens(self) -> int | None:\n        \"\"\"Get the maximum number of tokens the model can accept as input.\n\n        Returns:\n            The maximum token count, or `None` if the limit is unknown for this model.\n        \"\"\"\n        model = self._get_model()\n        return await model.max_input_tokens()\n\n    async def count_tokens(self, text: str) -> int:\n        \"\"\"Count the number of tokens in the given text.\n\n        Args:\n            text: The text to tokenize and count.\n\n        Returns:\n            The number of tokens in the text.\n\n        Raises:\n            NotImplementedError: If the model doesn't support token counting.\n            UserError: If the model or tokenizer is not supported.\n        \"\"\"\n        model = self._get_model()\n        return await model.count_tokens(text)\n\n    def embed_query_sync(\n        self, query: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Synchronous version of [`embed_query()`][pydantic_ai.embeddings.Embedder.embed_query].\"\"\"\n        return _utils.get_event_loop().run_until_complete(self.embed_query(query, settings=settings))\n\n    def embed_documents_sync(\n        self, documents: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Synchronous version of [`embed_documents()`][pydantic_ai.embeddings.Embedder.embed_documents].\"\"\"\n        return _utils.get_event_loop().run_until_complete(self.embed_documents(documents, settings=settings))\n\n    def embed_sync(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Synchronous version of [`embed()`][pydantic_ai.embeddings.Embedder.embed].\"\"\"\n        return _utils.get_event_loop().run_until_complete(self.embed(inputs, input_type=input_type, settings=settings))\n\n    def max_input_tokens_sync(self) -> int | None:\n        \"\"\"Synchronous version of [`max_input_tokens()`][pydantic_ai.embeddings.Embedder.max_input_tokens].\"\"\"\n        return _utils.get_event_loop().run_until_complete(self.max_input_tokens())\n\n    def count_tokens_sync(self, text: str) -> int:\n        \"\"\"Synchronous version of [`count_tokens()`][pydantic_ai.embeddings.Embedder.count_tokens].\"\"\"\n        return _utils.get_event_loop().run_until_complete(self.count_tokens(text))\n\n    def _get_model(self) -> EmbeddingModel:\n        \"\"\"Create a model configured for this embedder.\n\n        Returns:\n            The embedding model to use, with instrumentation applied if configured.\n        \"\"\"\n        model_: EmbeddingModel\n        if some_model := self._override_model.get():\n            model_ = some_model\n        else:\n            model_ = self._model = infer_embedding_model(self.model)\n\n        instrument = self.instrument\n        if instrument is None:\n            instrument = self._instrument_default\n\n        return instrument_embedding_model(model_, instrument)\n````\n\n#### __init__\n\n```python\n__init__(\n    model: EmbeddingModel | KnownEmbeddingModelName | str,\n    *,\n    settings: EmbeddingSettings | None = None,\n    defer_model_check: bool = True,\n    instrument: InstrumentationSettings | bool | None = None\n) -> None\n```\n\nInitialize an Embedder.\n\nParameters:\n\n| Name                | Type                      | Description                                                                                                        | Default                                                            |\n| ------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------ |\n| `model`             | \\`EmbeddingModel          | KnownEmbeddingModelName                                                                                            | str\\`                                                              |\n| `settings`          | \\`EmbeddingSettings       | None\\`                                                                                                             | Optional EmbeddingSettings to use as defaults for all embed calls. |\n| `defer_model_check` | `bool`                    | Whether to defer model validation until first use. Set to False to validate the model immediately on construction. | `True`                                                             |\n| `instrument`        | \\`InstrumentationSettings | bool                                                                                                               | None\\`                                                             |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef __init__(\n    self,\n    model: EmbeddingModel | KnownEmbeddingModelName | str,\n    *,\n    settings: EmbeddingSettings | None = None,\n    defer_model_check: bool = True,\n    instrument: InstrumentationSettings | bool | None = None,\n) -> None:\n    \"\"\"Initialize an Embedder.\n\n    Args:\n        model: The embedding model to use. Can be specified as:\n\n            - A model name string in the format `'provider:model-name'`\n              (e.g., `'openai:text-embedding-3-small'`)\n            - An [`EmbeddingModel`][pydantic_ai.embeddings.EmbeddingModel] instance\n        settings: Optional [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n            to use as defaults for all embed calls.\n        defer_model_check: Whether to defer model validation until first use.\n            Set to `False` to validate the model immediately on construction.\n        instrument: OpenTelemetry instrumentation settings. Set to `True` to enable with defaults,\n            or pass an [`InstrumentationSettings`][pydantic_ai.models.instrumented.InstrumentationSettings]\n            instance to customize. If `None`, uses the value from\n            [`Embedder.instrument_all()`][pydantic_ai.embeddings.Embedder.instrument_all].\n    \"\"\"\n    self._model = model if defer_model_check else infer_embedding_model(model)\n    self._settings = settings\n    self.instrument = instrument\n\n    self._override_model: ContextVar[EmbeddingModel | None] = ContextVar('_override_model', default=None)\n```\n\n#### instrument\n\n```python\ninstrument: InstrumentationSettings | bool | None = (\n    instrument\n)\n```\n\nOptions to automatically instrument with OpenTelemetry.\n\nSet to `True` to use default instrumentation settings, which will use Logfire if it's configured. Set to an instance of InstrumentationSettings to customize. If this isn't set, then the last value set by Embedder.instrument_all() will be used, which defaults to False. See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.\n\n#### instrument_all\n\n```python\ninstrument_all(\n    instrument: InstrumentationSettings | bool = True,\n) -> None\n```\n\nSet the default instrumentation options for all embedders where `instrument` is not explicitly set.\n\nThis is useful for enabling instrumentation globally without modifying each embedder individually.\n\nParameters:\n\n| Name         | Type                      | Description | Default                                                                                                                                                       |\n| ------------ | ------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `instrument` | \\`InstrumentationSettings | bool\\`      | Instrumentation settings to use as the default. Set to True for default settings, False to disable, or pass an InstrumentationSettings instance to customize. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\n@staticmethod\ndef instrument_all(instrument: InstrumentationSettings | bool = True) -> None:\n    \"\"\"Set the default instrumentation options for all embedders where `instrument` is not explicitly set.\n\n    This is useful for enabling instrumentation globally without modifying each embedder individually.\n\n    Args:\n        instrument: Instrumentation settings to use as the default. Set to `True` for default settings,\n            `False` to disable, or pass an\n            [`InstrumentationSettings`][pydantic_ai.models.instrumented.InstrumentationSettings]\n            instance to customize.\n    \"\"\"\n    Embedder._instrument_default = instrument\n```\n\n#### model\n\n```python\nmodel: EmbeddingModel | KnownEmbeddingModelName | str\n```\n\nThe embedding model used by this embedder.\n\n#### override\n\n```python\noverride(\n    *,\n    model: (\n        EmbeddingModel\n        | KnownEmbeddingModelName\n        | str\n        | Unset\n    ) = UNSET\n) -> Iterator[None]\n```\n\nContext manager to temporarily override the embedding model.\n\nUseful for testing or dynamically switching models.\n\nParameters:\n\n| Name    | Type             | Description             | Default |\n| ------- | ---------------- | ----------------------- | ------- |\n| `model` | \\`EmbeddingModel | KnownEmbeddingModelName | str     |\n\nExample:\n\n```python\nfrom pydantic_ai import Embedder\n\nembedder = Embedder('openai:text-embedding-3-small')\n\n\nasync def main():\n    # Temporarily use a different model\n    with embedder.override(model='openai:text-embedding-3-large'):\n        result = await embedder.embed_query('test')\n        print(len(result.embeddings[0]))  # 3072 dimensions for large model\n        #> 3072\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n````python\n@contextmanager\ndef override(\n    self,\n    *,\n    model: EmbeddingModel | KnownEmbeddingModelName | str | _utils.Unset = _utils.UNSET,\n) -> Iterator[None]:\n    \"\"\"Context manager to temporarily override the embedding model.\n\n    Useful for testing or dynamically switching models.\n\n    Args:\n        model: The embedding model to use within this context.\n\n    Example:\n    ```python\n    from pydantic_ai import Embedder\n\n    embedder = Embedder('openai:text-embedding-3-small')\n\n\n    async def main():\n        # Temporarily use a different model\n        with embedder.override(model='openai:text-embedding-3-large'):\n            result = await embedder.embed_query('test')\n            print(len(result.embeddings[0]))  # 3072 dimensions for large model\n            #> 3072\n    ```\n    \"\"\"\n    if _utils.is_set(model):\n        model_token = self._override_model.set(infer_embedding_model(model))\n    else:\n        model_token = None\n\n    try:\n        yield\n    finally:\n        if model_token is not None:\n            self._override_model.reset(model_token)\n````\n\n#### embed_query\n\n```python\nembed_query(\n    query: str | Sequence[str],\n    *,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nEmbed one or more query texts.\n\nUse this method when embedding search queries that will be compared against document embeddings. Some models optimize embeddings differently based on whether the input is a query or document.\n\nParameters:\n\n| Name       | Type                | Description     | Default                                                                      |\n| ---------- | ------------------- | --------------- | ---------------------------------------------------------------------------- |\n| `query`    | \\`str               | Sequence[str]\\` | A single query string or sequence of query strings to embed.                 |\n| `settings` | \\`EmbeddingSettings | None\\`          | Optional settings to override the embedder's default settings for this call. |\n\nReturns:\n\n| Type              | Description                                  |\n| ----------------- | -------------------------------------------- |\n| `EmbeddingResult` | An EmbeddingResult containing the embeddings |\n| `EmbeddingResult` | and metadata about the operation.            |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\nasync def embed_query(\n    self, query: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Embed one or more query texts.\n\n    Use this method when embedding search queries that will be compared against document embeddings.\n    Some models optimize embeddings differently based on whether the input is a query or document.\n\n    Args:\n        query: A single query string or sequence of query strings to embed.\n        settings: Optional settings to override the embedder's default settings for this call.\n\n    Returns:\n        An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing the embeddings\n        and metadata about the operation.\n    \"\"\"\n    return await self.embed(query, input_type='query', settings=settings)\n```\n\n#### embed_documents\n\n```python\nembed_documents(\n    documents: str | Sequence[str],\n    *,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nEmbed one or more document texts.\n\nUse this method when embedding documents that will be stored and later searched against. Some models optimize embeddings differently based on whether the input is a query or document.\n\nParameters:\n\n| Name        | Type                | Description     | Default                                                                      |\n| ----------- | ------------------- | --------------- | ---------------------------------------------------------------------------- |\n| `documents` | \\`str               | Sequence[str]\\` | A single document string or sequence of document strings to embed.           |\n| `settings`  | \\`EmbeddingSettings | None\\`          | Optional settings to override the embedder's default settings for this call. |\n\nReturns:\n\n| Type              | Description                                  |\n| ----------------- | -------------------------------------------- |\n| `EmbeddingResult` | An EmbeddingResult containing the embeddings |\n| `EmbeddingResult` | and metadata about the operation.            |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\nasync def embed_documents(\n    self, documents: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Embed one or more document texts.\n\n    Use this method when embedding documents that will be stored and later searched against.\n    Some models optimize embeddings differently based on whether the input is a query or document.\n\n    Args:\n        documents: A single document string or sequence of document strings to embed.\n        settings: Optional settings to override the embedder's default settings for this call.\n\n    Returns:\n        An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing the embeddings\n        and metadata about the operation.\n    \"\"\"\n    return await self.embed(documents, input_type='document', settings=settings)\n```\n\n#### embed\n\n```python\nembed(\n    inputs: str | Sequence[str],\n    *,\n    input_type: EmbedInputType,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nEmbed text inputs with explicit input type specification.\n\nThis is the low-level embedding method. For most use cases, prefer embed_query() or embed_documents().\n\nParameters:\n\n| Name         | Type                | Description                                      | Default                                                                      |\n| ------------ | ------------------- | ------------------------------------------------ | ---------------------------------------------------------------------------- |\n| `inputs`     | \\`str               | Sequence[str]\\`                                  | A single string or sequence of strings to embed.                             |\n| `input_type` | `EmbedInputType`    | The type of input, either 'query' or 'document'. | *required*                                                                   |\n| `settings`   | \\`EmbeddingSettings | None\\`                                           | Optional settings to override the embedder's default settings for this call. |\n\nReturns:\n\n| Type              | Description                                  |\n| ----------------- | -------------------------------------------- |\n| `EmbeddingResult` | An EmbeddingResult containing the embeddings |\n| `EmbeddingResult` | and metadata about the operation.            |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\nasync def embed(\n    self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Embed text inputs with explicit input type specification.\n\n    This is the low-level embedding method. For most use cases, prefer\n    [`embed_query()`][pydantic_ai.embeddings.Embedder.embed_query] or\n    [`embed_documents()`][pydantic_ai.embeddings.Embedder.embed_documents].\n\n    Args:\n        inputs: A single string or sequence of strings to embed.\n        input_type: The type of input, either `'query'` or `'document'`.\n        settings: Optional settings to override the embedder's default settings for this call.\n\n    Returns:\n        An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing the embeddings\n        and metadata about the operation.\n    \"\"\"\n    model = self._get_model()\n    settings = merge_embedding_settings(self._settings, settings)\n    return await model.embed(inputs, input_type=input_type, settings=settings)\n```\n\n#### max_input_tokens\n\n```python\nmax_input_tokens() -> int | None\n```\n\nGet the maximum number of tokens the model can accept as input.\n\nReturns:\n\n| Type  | Description |\n| ----- | ----------- |\n| \\`int | None\\`      |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\nasync def max_input_tokens(self) -> int | None:\n    \"\"\"Get the maximum number of tokens the model can accept as input.\n\n    Returns:\n        The maximum token count, or `None` if the limit is unknown for this model.\n    \"\"\"\n    model = self._get_model()\n    return await model.max_input_tokens()\n```\n\n#### count_tokens\n\n```python\ncount_tokens(text: str) -> int\n```\n\nCount the number of tokens in the given text.\n\nParameters:\n\n| Name   | Type  | Description                     | Default    |\n| ------ | ----- | ------------------------------- | ---------- |\n| `text` | `str` | The text to tokenize and count. | *required* |\n\nReturns:\n\n| Type  | Description                       |\n| ----- | --------------------------------- |\n| `int` | The number of tokens in the text. |\n\nRaises:\n\n| Type                  | Description                                  |\n| --------------------- | -------------------------------------------- |\n| `NotImplementedError` | If the model doesn't support token counting. |\n| `UserError`           | If the model or tokenizer is not supported.  |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\nasync def count_tokens(self, text: str) -> int:\n    \"\"\"Count the number of tokens in the given text.\n\n    Args:\n        text: The text to tokenize and count.\n\n    Returns:\n        The number of tokens in the text.\n\n    Raises:\n        NotImplementedError: If the model doesn't support token counting.\n        UserError: If the model or tokenizer is not supported.\n    \"\"\"\n    model = self._get_model()\n    return await model.count_tokens(text)\n```\n\n#### embed_query_sync\n\n```python\nembed_query_sync(\n    query: str | Sequence[str],\n    *,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nSynchronous version of embed_query().\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef embed_query_sync(\n    self, query: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Synchronous version of [`embed_query()`][pydantic_ai.embeddings.Embedder.embed_query].\"\"\"\n    return _utils.get_event_loop().run_until_complete(self.embed_query(query, settings=settings))\n```\n\n#### embed_documents_sync\n\n```python\nembed_documents_sync(\n    documents: str | Sequence[str],\n    *,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nSynchronous version of embed_documents().\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef embed_documents_sync(\n    self, documents: str | Sequence[str], *, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Synchronous version of [`embed_documents()`][pydantic_ai.embeddings.Embedder.embed_documents].\"\"\"\n    return _utils.get_event_loop().run_until_complete(self.embed_documents(documents, settings=settings))\n```\n\n#### embed_sync\n\n```python\nembed_sync(\n    inputs: str | Sequence[str],\n    *,\n    input_type: EmbedInputType,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nSynchronous version of embed().\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef embed_sync(\n    self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Synchronous version of [`embed()`][pydantic_ai.embeddings.Embedder.embed].\"\"\"\n    return _utils.get_event_loop().run_until_complete(self.embed(inputs, input_type=input_type, settings=settings))\n```\n\n#### max_input_tokens_sync\n\n```python\nmax_input_tokens_sync() -> int | None\n```\n\nSynchronous version of max_input_tokens().\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef max_input_tokens_sync(self) -> int | None:\n    \"\"\"Synchronous version of [`max_input_tokens()`][pydantic_ai.embeddings.Embedder.max_input_tokens].\"\"\"\n    return _utils.get_event_loop().run_until_complete(self.max_input_tokens())\n```\n\n#### count_tokens_sync\n\n```python\ncount_tokens_sync(text: str) -> int\n```\n\nSynchronous version of count_tokens().\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/__init__.py`\n\n```python\ndef count_tokens_sync(self, text: str) -> int:\n    \"\"\"Synchronous version of [`count_tokens()`][pydantic_ai.embeddings.Embedder.count_tokens].\"\"\"\n    return _utils.get_event_loop().run_until_complete(self.count_tokens(text))\n```\n\n### EmbeddingModel\n\nBases: `ABC`\n\nAbstract base class for embedding models.\n\nImplement this class to create a custom embedding model. For most use cases, use one of the built-in implementations:\n\n- OpenAIEmbeddingModel\n- CohereEmbeddingModel\n- GoogleEmbeddingModel\n- BedrockEmbeddingModel\n- SentenceTransformerEmbeddingModel\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\nclass EmbeddingModel(ABC):\n    \"\"\"Abstract base class for embedding models.\n\n    Implement this class to create a custom embedding model. For most use cases,\n    use one of the built-in implementations:\n\n    - [`OpenAIEmbeddingModel`][pydantic_ai.embeddings.openai.OpenAIEmbeddingModel]\n    - [`CohereEmbeddingModel`][pydantic_ai.embeddings.cohere.CohereEmbeddingModel]\n    - [`GoogleEmbeddingModel`][pydantic_ai.embeddings.google.GoogleEmbeddingModel]\n    - [`BedrockEmbeddingModel`][pydantic_ai.embeddings.bedrock.BedrockEmbeddingModel]\n    - [`SentenceTransformerEmbeddingModel`][pydantic_ai.embeddings.sentence_transformers.SentenceTransformerEmbeddingModel]\n    \"\"\"\n\n    _settings: EmbeddingSettings | None = None\n\n    def __init__(\n        self,\n        *,\n        settings: EmbeddingSettings | None = None,\n    ) -> None:\n        \"\"\"Initialize the model with optional settings.\n\n        Args:\n            settings: Model-specific settings that will be used as defaults for this model.\n        \"\"\"\n        self._settings = settings\n\n    @property\n    def settings(self) -> EmbeddingSettings | None:\n        \"\"\"Get the default settings for this model.\"\"\"\n        return self._settings\n\n    @property\n    def base_url(self) -> str | None:\n        \"\"\"The base URL for the provider API, if available.\"\"\"\n        return None\n\n    @property\n    @abstractmethod\n    def model_name(self) -> str:\n        \"\"\"The name of the embedding model.\"\"\"\n        raise NotImplementedError()\n\n    @property\n    @abstractmethod\n    def system(self) -> str:\n        \"\"\"The embedding model provider/system identifier (e.g., 'openai', 'cohere').\"\"\"\n        raise NotImplementedError()\n\n    @abstractmethod\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        \"\"\"Generate embeddings for the given inputs.\n\n        Args:\n            inputs: A single string or sequence of strings to embed.\n            input_type: Whether the inputs are queries or documents.\n            settings: Optional settings to override the model's defaults.\n\n        Returns:\n            An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing\n            the embeddings and metadata.\n        \"\"\"\n        raise NotImplementedError\n\n    def prepare_embed(\n        self, inputs: str | Sequence[str], settings: EmbeddingSettings | None = None\n    ) -> tuple[list[str], EmbeddingSettings]:\n        \"\"\"Prepare the inputs and settings for embedding.\n\n        This method normalizes inputs to a list and merges settings.\n        Subclasses should call this at the start of their `embed()` implementation.\n\n        Args:\n            inputs: A single string or sequence of strings.\n            settings: Optional settings to merge with defaults.\n\n        Returns:\n            A tuple of (normalized inputs list, merged settings).\n        \"\"\"\n        inputs = [inputs] if isinstance(inputs, str) else list(inputs)\n\n        settings = merge_embedding_settings(self._settings, settings) or {}\n\n        return inputs, settings\n\n    async def max_input_tokens(self) -> int | None:\n        \"\"\"Get the maximum number of tokens that can be input to the model.\n\n        Returns:\n            The maximum token count, or `None` if unknown.\n        \"\"\"\n        return None  # pragma: no cover\n\n    async def count_tokens(self, text: str) -> int:\n        \"\"\"Count the number of tokens in the given text.\n\n        Args:\n            text: The text to tokenize and count.\n\n        Returns:\n            The number of tokens.\n\n        Raises:\n            NotImplementedError: If the model doesn't support token counting.\n            UserError: If the model or tokenizer is not supported.\n        \"\"\"\n        raise NotImplementedError\n```\n\n#### __init__\n\n```python\n__init__(\n    *, settings: EmbeddingSettings | None = None\n) -> None\n```\n\nInitialize the model with optional settings.\n\nParameters:\n\n| Name       | Type                | Description | Default                                                               |\n| ---------- | ------------------- | ----------- | --------------------------------------------------------------------- |\n| `settings` | \\`EmbeddingSettings | None\\`      | Model-specific settings that will be used as defaults for this model. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\ndef __init__(\n    self,\n    *,\n    settings: EmbeddingSettings | None = None,\n) -> None:\n    \"\"\"Initialize the model with optional settings.\n\n    Args:\n        settings: Model-specific settings that will be used as defaults for this model.\n    \"\"\"\n    self._settings = settings\n```\n\n#### settings\n\n```python\nsettings: EmbeddingSettings | None\n```\n\nGet the default settings for this model.\n\n#### base_url\n\n```python\nbase_url: str | None\n```\n\nThe base URL for the provider API, if available.\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe name of the embedding model.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider/system identifier (e.g., 'openai', 'cohere').\n\n#### embed\n\n```python\nembed(\n    inputs: str | Sequence[str],\n    *,\n    input_type: EmbedInputType,\n    settings: EmbeddingSettings | None = None\n) -> EmbeddingResult\n```\n\nGenerate embeddings for the given inputs.\n\nParameters:\n\n| Name         | Type                | Description                                  | Default                                             |\n| ------------ | ------------------- | -------------------------------------------- | --------------------------------------------------- |\n| `inputs`     | \\`str               | Sequence[str]\\`                              | A single string or sequence of strings to embed.    |\n| `input_type` | `EmbedInputType`    | Whether the inputs are queries or documents. | *required*                                          |\n| `settings`   | \\`EmbeddingSettings | None\\`                                       | Optional settings to override the model's defaults. |\n\nReturns:\n\n| Type              | Description                   |\n| ----------------- | ----------------------------- |\n| `EmbeddingResult` | An EmbeddingResult containing |\n| `EmbeddingResult` | the embeddings and metadata.  |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\n@abstractmethod\nasync def embed(\n    self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n) -> EmbeddingResult:\n    \"\"\"Generate embeddings for the given inputs.\n\n    Args:\n        inputs: A single string or sequence of strings to embed.\n        input_type: Whether the inputs are queries or documents.\n        settings: Optional settings to override the model's defaults.\n\n    Returns:\n        An [`EmbeddingResult`][pydantic_ai.embeddings.EmbeddingResult] containing\n        the embeddings and metadata.\n    \"\"\"\n    raise NotImplementedError\n```\n\n#### prepare_embed\n\n```python\nprepare_embed(\n    inputs: str | Sequence[str],\n    settings: EmbeddingSettings | None = None,\n) -> tuple[list[str], EmbeddingSettings]\n```\n\nPrepare the inputs and settings for embedding.\n\nThis method normalizes inputs to a list and merges settings. Subclasses should call this at the start of their `embed()` implementation.\n\nParameters:\n\n| Name       | Type                | Description     | Default                                   |\n| ---------- | ------------------- | --------------- | ----------------------------------------- |\n| `inputs`   | \\`str               | Sequence[str]\\` | A single string or sequence of strings.   |\n| `settings` | \\`EmbeddingSettings | None\\`          | Optional settings to merge with defaults. |\n\nReturns:\n\n| Type                                  | Description                                           |\n| ------------------------------------- | ----------------------------------------------------- |\n| `tuple[list[str], EmbeddingSettings]` | A tuple of (normalized inputs list, merged settings). |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\ndef prepare_embed(\n    self, inputs: str | Sequence[str], settings: EmbeddingSettings | None = None\n) -> tuple[list[str], EmbeddingSettings]:\n    \"\"\"Prepare the inputs and settings for embedding.\n\n    This method normalizes inputs to a list and merges settings.\n    Subclasses should call this at the start of their `embed()` implementation.\n\n    Args:\n        inputs: A single string or sequence of strings.\n        settings: Optional settings to merge with defaults.\n\n    Returns:\n        A tuple of (normalized inputs list, merged settings).\n    \"\"\"\n    inputs = [inputs] if isinstance(inputs, str) else list(inputs)\n\n    settings = merge_embedding_settings(self._settings, settings) or {}\n\n    return inputs, settings\n```\n\n#### max_input_tokens\n\n```python\nmax_input_tokens() -> int | None\n```\n\nGet the maximum number of tokens that can be input to the model.\n\nReturns:\n\n| Type  | Description |\n| ----- | ----------- |\n| \\`int | None\\`      |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\nasync def max_input_tokens(self) -> int | None:\n    \"\"\"Get the maximum number of tokens that can be input to the model.\n\n    Returns:\n        The maximum token count, or `None` if unknown.\n    \"\"\"\n    return None  # pragma: no cover\n```\n\n#### count_tokens\n\n```python\ncount_tokens(text: str) -> int\n```\n\nCount the number of tokens in the given text.\n\nParameters:\n\n| Name   | Type  | Description                     | Default    |\n| ------ | ----- | ------------------------------- | ---------- |\n| `text` | `str` | The text to tokenize and count. | *required* |\n\nReturns:\n\n| Type  | Description           |\n| ----- | --------------------- |\n| `int` | The number of tokens. |\n\nRaises:\n\n| Type                  | Description                                  |\n| --------------------- | -------------------------------------------- |\n| `NotImplementedError` | If the model doesn't support token counting. |\n| `UserError`           | If the model or tokenizer is not supported.  |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/base.py`\n\n```python\nasync def count_tokens(self, text: str) -> int:\n    \"\"\"Count the number of tokens in the given text.\n\n    Args:\n        text: The text to tokenize and count.\n\n    Returns:\n        The number of tokens.\n\n    Raises:\n        NotImplementedError: If the model doesn't support token counting.\n        UserError: If the model or tokenizer is not supported.\n    \"\"\"\n    raise NotImplementedError\n```\n\n### EmbedInputType\n\n```python\nEmbedInputType = Literal['query', 'document']\n```\n\nThe type of input to the embedding model.\n\n- `'query'`: Text that will be used as a search query\n- `'document'`: Text that will be stored and searched against\n\nSome embedding models optimize differently for queries vs documents.\n\n### EmbeddingResult\n\nThe result of an embedding operation.\n\nThis class contains the generated embeddings along with metadata about the operation, including the original inputs, model information, usage statistics, and timing.\n\nExample:\n\n```python\nfrom pydantic_ai import Embedder\n\nembedder = Embedder('openai:text-embedding-3-small')\n\n\nasync def main():\n    result = await embedder.embed_query('What is AI?')\n\n    # Access embeddings by index\n    print(len(result.embeddings[0]))\n    #> 1536\n\n    # Access embeddings by original input text\n    print(result['What is AI?'] == result.embeddings[0])\n    #> True\n\n    # Check usage\n    print(f'Tokens used: {result.usage.input_tokens}')\n    #> Tokens used: 3\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/result.py`\n\n````python\n@dataclass\nclass EmbeddingResult:\n    \"\"\"The result of an embedding operation.\n\n    This class contains the generated embeddings along with metadata about\n    the operation, including the original inputs, model information, usage\n    statistics, and timing.\n\n    Example:\n    ```python\n    from pydantic_ai import Embedder\n\n    embedder = Embedder('openai:text-embedding-3-small')\n\n\n    async def main():\n        result = await embedder.embed_query('What is AI?')\n\n        # Access embeddings by index\n        print(len(result.embeddings[0]))\n        #> 1536\n\n        # Access embeddings by original input text\n        print(result['What is AI?'] == result.embeddings[0])\n        #> True\n\n        # Check usage\n        print(f'Tokens used: {result.usage.input_tokens}')\n        #> Tokens used: 3\n    ```\n    \"\"\"\n\n    embeddings: Sequence[Sequence[float]]\n    \"\"\"The computed embedding vectors, one per input text.\n\n    Each embedding is a sequence of floats representing the text in vector space.\n    \"\"\"\n\n    _: KW_ONLY\n\n    inputs: Sequence[str]\n    \"\"\"The original input texts that were embedded.\"\"\"\n\n    input_type: EmbedInputType\n    \"\"\"Whether the inputs were embedded as queries or documents.\"\"\"\n\n    model_name: str\n    \"\"\"The name of the model that generated these embeddings.\"\"\"\n\n    provider_name: str\n    \"\"\"The name of the provider (e.g., 'openai', 'cohere').\"\"\"\n\n    timestamp: datetime = field(default_factory=_now_utc)\n    \"\"\"When the embedding request was made.\"\"\"\n\n    usage: RequestUsage = field(default_factory=RequestUsage)\n    \"\"\"Token usage statistics for this request.\"\"\"\n\n    provider_details: dict[str, Any] | None = None\n    \"\"\"Provider-specific details from the response.\"\"\"\n\n    provider_response_id: str | None = None\n    \"\"\"Unique identifier for this response from the provider, if available.\"\"\"\n\n    def __getitem__(self, item: int | str) -> Sequence[float]:\n        \"\"\"Get the embedding for an input by index or by the original input text.\n\n        Args:\n            item: Either an integer index or the original input string.\n\n        Returns:\n            The embedding vector for the specified input.\n\n        Raises:\n            IndexError: If the index is out of range.\n            ValueError: If the string is not found in the inputs.\n        \"\"\"\n        if isinstance(item, str):\n            item = self.inputs.index(item)\n\n        return self.embeddings[item]\n\n    def cost(self) -> genai_types.PriceCalculation:\n        \"\"\"Calculate the cost of the embedding request.\n\n        Uses [`genai-prices`](https://github.com/pydantic/genai-prices) for pricing data.\n\n        Returns:\n            A price calculation object with `total_price`, `input_price`, and other cost details.\n\n        Raises:\n            LookupError: If pricing data is not available for this model/provider.\n        \"\"\"\n        assert self.model_name, 'Model name is required to calculate price'\n        return calc_price(\n            self.usage,\n            self.model_name,\n            provider_id=self.provider_name,\n            genai_request_timestamp=self.timestamp,\n        )\n````\n\n#### embeddings\n\n```python\nembeddings: Sequence[Sequence[float]]\n```\n\nThe computed embedding vectors, one per input text.\n\nEach embedding is a sequence of floats representing the text in vector space.\n\n#### inputs\n\n```python\ninputs: Sequence[str]\n```\n\nThe original input texts that were embedded.\n\n#### input_type\n\n```python\ninput_type: EmbedInputType\n```\n\nWhether the inputs were embedded as queries or documents.\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe name of the model that generated these embeddings.\n\n#### provider_name\n\n```python\nprovider_name: str\n```\n\nThe name of the provider (e.g., 'openai', 'cohere').\n\n#### timestamp\n\n```python\ntimestamp: datetime = field(default_factory=now_utc)\n```\n\nWhen the embedding request was made.\n\n#### usage\n\n```python\nusage: RequestUsage = field(default_factory=RequestUsage)\n```\n\nToken usage statistics for this request.\n\n#### provider_details\n\n```python\nprovider_details: dict[str, Any] | None = None\n```\n\nProvider-specific details from the response.\n\n#### provider_response_id\n\n```python\nprovider_response_id: str | None = None\n```\n\nUnique identifier for this response from the provider, if available.\n\n#### __getitem__\n\n```python\n__getitem__(item: int | str) -> Sequence[float]\n```\n\nGet the embedding for an input by index or by the original input text.\n\nParameters:\n\n| Name   | Type  | Description | Default                                               |\n| ------ | ----- | ----------- | ----------------------------------------------------- |\n| `item` | \\`int | str\\`       | Either an integer index or the original input string. |\n\nReturns:\n\n| Type              | Description                                   |\n| ----------------- | --------------------------------------------- |\n| `Sequence[float]` | The embedding vector for the specified input. |\n\nRaises:\n\n| Type         | Description                               |\n| ------------ | ----------------------------------------- |\n| `IndexError` | If the index is out of range.             |\n| `ValueError` | If the string is not found in the inputs. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/result.py`\n\n```python\ndef __getitem__(self, item: int | str) -> Sequence[float]:\n    \"\"\"Get the embedding for an input by index or by the original input text.\n\n    Args:\n        item: Either an integer index or the original input string.\n\n    Returns:\n        The embedding vector for the specified input.\n\n    Raises:\n        IndexError: If the index is out of range.\n        ValueError: If the string is not found in the inputs.\n    \"\"\"\n    if isinstance(item, str):\n        item = self.inputs.index(item)\n\n    return self.embeddings[item]\n```\n\n#### cost\n\n```python\ncost() -> PriceCalculation\n```\n\nCalculate the cost of the embedding request.\n\nUses [`genai-prices`](https://github.com/pydantic/genai-prices) for pricing data.\n\nReturns:\n\n| Type               | Description                                                                       |\n| ------------------ | --------------------------------------------------------------------------------- |\n| `PriceCalculation` | A price calculation object with total_price, input_price, and other cost details. |\n\nRaises:\n\n| Type          | Description                                               |\n| ------------- | --------------------------------------------------------- |\n| `LookupError` | If pricing data is not available for this model/provider. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/result.py`\n\n```python\ndef cost(self) -> genai_types.PriceCalculation:\n    \"\"\"Calculate the cost of the embedding request.\n\n    Uses [`genai-prices`](https://github.com/pydantic/genai-prices) for pricing data.\n\n    Returns:\n        A price calculation object with `total_price`, `input_price`, and other cost details.\n\n    Raises:\n        LookupError: If pricing data is not available for this model/provider.\n    \"\"\"\n    assert self.model_name, 'Model name is required to calculate price'\n    return calc_price(\n        self.usage,\n        self.model_name,\n        provider_id=self.provider_name,\n        genai_request_timestamp=self.timestamp,\n    )\n```\n\n### EmbeddingSettings\n\nBases: `TypedDict`\n\nCommon settings for configuring embedding models.\n\nThese settings apply across multiple embedding model providers. Not all settings are supported by all models - check the specific model's documentation for details.\n\nProvider-specific settings classes (e.g., OpenAIEmbeddingSettings, CohereEmbeddingSettings) extend this with additional provider-prefixed options.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/settings.py`\n\n```python\nclass EmbeddingSettings(TypedDict, total=False):\n    \"\"\"Common settings for configuring embedding models.\n\n    These settings apply across multiple embedding model providers.\n    Not all settings are supported by all models - check the specific\n    model's documentation for details.\n\n    Provider-specific settings classes (e.g.,\n    [`OpenAIEmbeddingSettings`][pydantic_ai.embeddings.openai.OpenAIEmbeddingSettings],\n    [`CohereEmbeddingSettings`][pydantic_ai.embeddings.cohere.CohereEmbeddingSettings])\n    extend this with additional provider-prefixed options.\n    \"\"\"\n\n    dimensions: int\n    \"\"\"The number of dimensions for the output embeddings.\n\n    Supported by:\n\n    * OpenAI\n    * Cohere\n    * Google\n    * Sentence Transformers\n    * Bedrock\n    * VoyageAI\n    \"\"\"\n\n    truncate: bool\n    \"\"\"Whether to truncate inputs that exceed the model's context length.\n\n    Defaults to `False`. If `True`, inputs that are too long will be truncated.\n    If `False`, an error will be raised for inputs that exceed the context length.\n\n    For more control over truncation, you can use\n    [`max_input_tokens()`][pydantic_ai.embeddings.Embedder.max_input_tokens] and\n    [`count_tokens()`][pydantic_ai.embeddings.Embedder.count_tokens] to implement\n    your own truncation logic.\n\n    Provider-specific truncation settings (e.g., `cohere_truncate`, `bedrock_cohere_truncate`)\n    take precedence if specified.\n\n    Supported by:\n\n    * Cohere\n    * Bedrock (Cohere and Nova models)\n    * VoyageAI\n    \"\"\"\n\n    extra_headers: dict[str, str]\n    \"\"\"Extra headers to send to the model.\n\n    Supported by:\n\n    * OpenAI\n    * Cohere\n    \"\"\"\n\n    extra_body: object\n    \"\"\"Extra body to send to the model.\n\n    Supported by:\n\n    * OpenAI\n    * Cohere\n    \"\"\"\n```\n\n#### dimensions\n\n```python\ndimensions: int\n```\n\nThe number of dimensions for the output embeddings.\n\nSupported by:\n\n- OpenAI\n- Cohere\n- Google\n- Sentence Transformers\n- Bedrock\n- VoyageAI\n\n#### truncate\n\n```python\ntruncate: bool\n```\n\nWhether to truncate inputs that exceed the model's context length.\n\nDefaults to `False`. If `True`, inputs that are too long will be truncated. If `False`, an error will be raised for inputs that exceed the context length.\n\nFor more control over truncation, you can use max_input_tokens() and count_tokens() to implement your own truncation logic.\n\nProvider-specific truncation settings (e.g., `cohere_truncate`, `bedrock_cohere_truncate`) take precedence if specified.\n\nSupported by:\n\n- Cohere\n- Bedrock (Cohere and Nova models)\n- VoyageAI\n\n#### extra_headers\n\n```python\nextra_headers: dict[str, str]\n```\n\nExtra headers to send to the model.\n\nSupported by:\n\n- OpenAI\n- Cohere\n\n#### extra_body\n\n```python\nextra_body: object\n```\n\nExtra body to send to the model.\n\nSupported by:\n\n- OpenAI\n- Cohere\n\n### merge_embedding_settings\n\n```python\nmerge_embedding_settings(\n    base: EmbeddingSettings | None,\n    overrides: EmbeddingSettings | None,\n) -> EmbeddingSettings | None\n```\n\nMerge two sets of embedding settings, with overrides taking precedence.\n\nParameters:\n\n| Name        | Type                | Description | Default                                                               |\n| ----------- | ------------------- | ----------- | --------------------------------------------------------------------- |\n| `base`      | \\`EmbeddingSettings | None\\`      | Base settings (typically from the embedder or model).                 |\n| `overrides` | \\`EmbeddingSettings | None\\`      | Settings that should override the base (typically per-call settings). |\n\nReturns:\n\n| Type                | Description |\n| ------------------- | ----------- |\n| \\`EmbeddingSettings | None\\`      |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/settings.py`\n\n```python\ndef merge_embedding_settings(\n    base: EmbeddingSettings | None, overrides: EmbeddingSettings | None\n) -> EmbeddingSettings | None:\n    \"\"\"Merge two sets of embedding settings, with overrides taking precedence.\n\n    Args:\n        base: Base settings (typically from the embedder or model).\n        overrides: Settings that should override the base (typically per-call settings).\n\n    Returns:\n        Merged settings, or `None` if both inputs are `None`.\n    \"\"\"\n    # Note: we may want merge recursively if/when we add non-primitive values\n    if base and overrides:\n        return base | overrides\n    else:\n        return base or overrides\n```\n\n### OpenAIEmbeddingModelName\n\n```python\nOpenAIEmbeddingModelName = str | EmbeddingModel\n```\n\nPossible OpenAI embeddings model names.\n\nSee the [OpenAI embeddings documentation](https://platform.openai.com/docs/guides/embeddings) for available models.\n\n### OpenAIEmbeddingSettings\n\nBases: `EmbeddingSettings`\n\nSettings used for an OpenAI embedding model request.\n\nAll fields from EmbeddingSettings are supported.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/openai.py`\n\n```python\nclass OpenAIEmbeddingSettings(EmbeddingSettings, total=False):\n    \"\"\"Settings used for an OpenAI embedding model request.\n\n    All fields from [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings] are supported.\n    \"\"\"\n```\n\n### OpenAIEmbeddingModel\n\nBases: `EmbeddingModel`\n\nOpenAI embedding model implementation.\n\nThis model works with OpenAI's embeddings API and any [OpenAI-compatible providers](https://ai.pydantic.dev/models/openai/#openai-compatible-models).\n\nExample:\n\n```python\nfrom pydantic_ai.embeddings.openai import OpenAIEmbeddingModel\nfrom pydantic_ai.providers.openai import OpenAIProvider\n\n# Using OpenAI directly\nmodel = OpenAIEmbeddingModel('text-embedding-3-small')\n\n# Using an OpenAI-compatible provider\nmodel = OpenAIEmbeddingModel(\n    'text-embedding-3-small',\n    provider=OpenAIProvider(base_url='https://my-provider.com/v1'),\n)\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/openai.py`\n\n````python\n@dataclass(init=False)\nclass OpenAIEmbeddingModel(EmbeddingModel):\n    \"\"\"OpenAI embedding model implementation.\n\n    This model works with OpenAI's embeddings API and any\n    [OpenAI-compatible providers](../models/openai.md#openai-compatible-models).\n\n    Example:\n    ```python\n    from pydantic_ai.embeddings.openai import OpenAIEmbeddingModel\n    from pydantic_ai.providers.openai import OpenAIProvider\n\n    # Using OpenAI directly\n    model = OpenAIEmbeddingModel('text-embedding-3-small')\n\n    # Using an OpenAI-compatible provider\n    model = OpenAIEmbeddingModel(\n        'text-embedding-3-small',\n        provider=OpenAIProvider(base_url='https://my-provider.com/v1'),\n    )\n    ```\n    \"\"\"\n\n    _model_name: OpenAIEmbeddingModelName = field(repr=False)\n    _provider: Provider[AsyncOpenAI] = field(repr=False)\n\n    def __init__(\n        self,\n        model_name: OpenAIEmbeddingModelName,\n        *,\n        provider: OpenAIEmbeddingsCompatibleProvider | Literal['openai'] | Provider[AsyncOpenAI] = 'openai',\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize an OpenAI embedding model.\n\n        Args:\n            model_name: The name of the OpenAI model to use.\n                See [OpenAI's embedding models](https://platform.openai.com/docs/guides/embeddings)\n                for available options.\n            provider: The provider to use for authentication and API access. Can be:\n\n                - `'openai'` (default): Uses the standard OpenAI API\n                - A provider name string (e.g., `'azure'`, `'deepseek'`)\n                - A [`Provider`][pydantic_ai.providers.Provider] instance for custom configuration\n\n                See [OpenAI-compatible providers](../models/openai.md#openai-compatible-models)\n                for a list of supported providers.\n            settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n                to use as defaults for this model.\n        \"\"\"\n        self._model_name = model_name\n\n        if isinstance(provider, str):\n            provider = infer_provider(provider)\n        self._provider = provider\n        self._client = provider.client\n\n        super().__init__(settings=settings)\n\n    @property\n    def base_url(self) -> str:\n        return str(self._client.base_url)\n\n    @property\n    def model_name(self) -> OpenAIEmbeddingModelName:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider.name\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        settings = cast(OpenAIEmbeddingSettings, settings)\n\n        try:\n            response = await self._client.embeddings.create(\n                input=inputs,\n                model=self.model_name,\n                dimensions=settings.get('dimensions') or OMIT,\n                extra_headers=settings.get('extra_headers'),\n                extra_body=settings.get('extra_body'),\n            )\n        except APIStatusError as e:\n            if (status_code := e.status_code) >= 400:\n                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e\n            raise  # pragma: lax no cover\n        except APIConnectionError as e:  # pragma: no cover\n            raise ModelAPIError(model_name=self.model_name, message=e.message) from e\n\n        embeddings = [item.embedding for item in response.data]\n\n        return EmbeddingResult(\n            embeddings=embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            usage=_map_usage(response.usage, self.system, self.base_url, response.model),\n            model_name=response.model,\n            provider_name=self.system,\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        if self.system != 'openai':\n            return None\n\n        # https://platform.openai.com/docs/guides/embeddings#embedding-models\n        return 8192\n\n    async def count_tokens(self, text: str) -> int:\n        if self.system != 'openai':\n            raise UserError(\n                'Counting tokens is not supported for non-OpenAI embedding models',\n            )\n        try:\n            encoding = await _utils.run_in_executor(tiktoken.encoding_for_model, self.model_name)\n        except KeyError as e:  # pragma: no cover\n            raise ValueError(\n                f'The embedding model {self.model_name!r} is not supported by tiktoken',\n            ) from e\n        return len(encoding.encode(text))\n````\n\n#### __init__\n\n```python\n__init__(\n    model_name: OpenAIEmbeddingModelName,\n    *,\n    provider: (\n        OpenAIEmbeddingsCompatibleProvider\n        | Literal[\"openai\"]\n        | Provider[AsyncOpenAI]\n    ) = \"openai\",\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize an OpenAI embedding model.\n\nParameters:\n\n| Name         | Type                                 | Description                                                                               | Default                                                             |\n| ------------ | ------------------------------------ | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |\n| `model_name` | `OpenAIEmbeddingModelName`           | The name of the OpenAI model to use. See OpenAI's embedding models for available options. | *required*                                                          |\n| `provider`   | \\`OpenAIEmbeddingsCompatibleProvider | Literal['openai']                                                                         | Provider[AsyncOpenAI]\\`                                             |\n| `settings`   | \\`EmbeddingSettings                  | None\\`                                                                                    | Model-specific EmbeddingSettings to use as defaults for this model. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/openai.py`\n\n```python\ndef __init__(\n    self,\n    model_name: OpenAIEmbeddingModelName,\n    *,\n    provider: OpenAIEmbeddingsCompatibleProvider | Literal['openai'] | Provider[AsyncOpenAI] = 'openai',\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize an OpenAI embedding model.\n\n    Args:\n        model_name: The name of the OpenAI model to use.\n            See [OpenAI's embedding models](https://platform.openai.com/docs/guides/embeddings)\n            for available options.\n        provider: The provider to use for authentication and API access. Can be:\n\n            - `'openai'` (default): Uses the standard OpenAI API\n            - A provider name string (e.g., `'azure'`, `'deepseek'`)\n            - A [`Provider`][pydantic_ai.providers.Provider] instance for custom configuration\n\n            See [OpenAI-compatible providers](../models/openai.md#openai-compatible-models)\n            for a list of supported providers.\n        settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n            to use as defaults for this model.\n    \"\"\"\n    self._model_name = model_name\n\n    if isinstance(provider, str):\n        provider = infer_provider(provider)\n    self._provider = provider\n    self._client = provider.client\n\n    super().__init__(settings=settings)\n```\n\n#### model_name\n\n```python\nmodel_name: OpenAIEmbeddingModelName\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n### LatestCohereEmbeddingModelNames\n\n```python\nLatestCohereEmbeddingModelNames = Literal[\n    \"embed-v4.0\",\n    \"embed-english-v3.0\",\n    \"embed-english-light-v3.0\",\n    \"embed-multilingual-v3.0\",\n    \"embed-multilingual-light-v3.0\",\n]\n```\n\nLatest Cohere embeddings models.\n\nSee the [Cohere Embed documentation](https://docs.cohere.com/docs/cohere-embed) for available models and their capabilities.\n\n### CohereEmbeddingModelName\n\n```python\nCohereEmbeddingModelName = (\n    str | LatestCohereEmbeddingModelNames\n)\n```\n\nPossible Cohere embeddings model names.\n\n### CohereEmbeddingSettings\n\nBases: `EmbeddingSettings`\n\nSettings used for a Cohere embedding model request.\n\nAll fields from EmbeddingSettings are supported, plus Cohere-specific settings prefixed with `cohere_`.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/cohere.py`\n\n```python\nclass CohereEmbeddingSettings(EmbeddingSettings, total=False):\n    \"\"\"Settings used for a Cohere embedding model request.\n\n    All fields from [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings] are supported,\n    plus Cohere-specific settings prefixed with `cohere_`.\n    \"\"\"\n\n    # ALL FIELDS MUST BE `cohere_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.\n\n    cohere_max_tokens: int\n    \"\"\"The maximum number of tokens to embed.\"\"\"\n\n    cohere_input_type: CohereEmbedInputType\n    \"\"\"The Cohere-specific input type for the embedding.\n\n    Overrides the standard `input_type` argument. Options include:\n    `'search_query'`, `'search_document'`, `'classification'`, `'clustering'`, and `'image'`.\n    \"\"\"\n\n    cohere_truncate: V2EmbedRequestTruncate\n    \"\"\"The truncation strategy to use:\n\n    - `'NONE'` (default): Raise an error if input exceeds max tokens.\n    - `'END'`: Truncate the end of the input text.\n    - `'START'`: Truncate the start of the input text.\n\n    Note: This setting overrides the standard `truncate` boolean setting when specified.\n    \"\"\"\n```\n\n#### cohere_max_tokens\n\n```python\ncohere_max_tokens: int\n```\n\nThe maximum number of tokens to embed.\n\n#### cohere_input_type\n\n```python\ncohere_input_type: EmbedInputType\n```\n\nThe Cohere-specific input type for the embedding.\n\nOverrides the standard `input_type` argument. Options include: `'search_query'`, `'search_document'`, `'classification'`, `'clustering'`, and `'image'`.\n\n#### cohere_truncate\n\n```python\ncohere_truncate: V2EmbedRequestTruncate\n```\n\nThe truncation strategy to use:\n\n- `'NONE'` (default): Raise an error if input exceeds max tokens.\n- `'END'`: Truncate the end of the input text.\n- `'START'`: Truncate the start of the input text.\n\nNote: This setting overrides the standard `truncate` boolean setting when specified.\n\n### CohereEmbeddingModel\n\nBases: `EmbeddingModel`\n\nCohere embedding model implementation.\n\nThis model works with Cohere's embeddings API, which offers multilingual support and various model sizes.\n\nExample:\n\n```python\nfrom pydantic_ai.embeddings.cohere import CohereEmbeddingModel\n\nmodel = CohereEmbeddingModel('embed-v4.0')\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/cohere.py`\n\n````python\n@dataclass(init=False)\nclass CohereEmbeddingModel(EmbeddingModel):\n    \"\"\"Cohere embedding model implementation.\n\n    This model works with Cohere's embeddings API, which offers\n    multilingual support and various model sizes.\n\n    Example:\n    ```python\n    from pydantic_ai.embeddings.cohere import CohereEmbeddingModel\n\n    model = CohereEmbeddingModel('embed-v4.0')\n    ```\n    \"\"\"\n\n    _model_name: CohereEmbeddingModelName = field(repr=False)\n    _provider: Provider[AsyncClientV2] = field(repr=False)\n\n    def __init__(\n        self,\n        model_name: CohereEmbeddingModelName,\n        *,\n        provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize a Cohere embedding model.\n\n        Args:\n            model_name: The name of the Cohere model to use.\n                See [Cohere Embed documentation](https://docs.cohere.com/docs/cohere-embed)\n                for available models.\n            provider: The provider to use for authentication and API access. Can be:\n\n                - `'cohere'` (default): Uses the standard Cohere API\n                - A [`CohereProvider`][pydantic_ai.providers.cohere.CohereProvider] instance\n                  for custom configuration\n            settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n                to use as defaults for this model.\n        \"\"\"\n        self._model_name = model_name\n\n        if isinstance(provider, str):\n            provider = infer_provider(provider)\n        self._provider = provider\n        self._client = provider.client\n        self._v1_client = provider.v1_client if isinstance(provider, CohereProvider) else None\n\n        super().__init__(settings=settings)\n\n    @property\n    def base_url(self) -> str:\n        \"\"\"The base URL for the provider API, if available.\"\"\"\n        return self._provider.base_url\n\n    @property\n    def model_name(self) -> CohereEmbeddingModelName:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider.name\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        settings = cast(CohereEmbeddingSettings, settings)\n\n        cohere_input_type = settings.get(\n            'cohere_input_type', 'search_document' if input_type == 'document' else 'search_query'\n        )\n\n        request_options: RequestOptions = {}\n        if extra_headers := settings.get('extra_headers'):  # pragma: no cover\n            request_options['additional_headers'] = extra_headers\n        if extra_body := settings.get('extra_body'):  # pragma: no cover\n            request_options['additional_body_parameters'] = cast(dict[str, Any], extra_body)\n\n        # Determine truncation strategy: cohere_truncate takes precedence over truncate\n        if 'cohere_truncate' in settings:\n            truncate = settings['cohere_truncate']\n        elif settings.get('truncate'):\n            truncate = 'END'\n        else:\n            truncate = 'NONE'\n\n        try:\n            response = await self._client.embed(\n                model=self.model_name,\n                texts=inputs,\n                output_dimension=settings.get('dimensions'),\n                input_type=cohere_input_type,\n                max_tokens=settings.get('cohere_max_tokens'),\n                truncate=truncate,\n                request_options=request_options,\n                embedding_types=['float'],  # Always request float embeddings to avoid Cohere SDK deserialization bug\n            )\n        except ApiError as e:\n            if (status_code := e.status_code) and status_code >= 400:\n                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e\n            raise ModelAPIError(model_name=self.model_name, message=str(e)) from e  # pragma: no cover\n\n        embeddings = response.embeddings.float_\n        if embeddings is None:\n            raise UnexpectedModelBehavior(  # pragma: no cover\n                'The Cohere embeddings response did not have an `embeddings` field holding a list of floats',\n                str(response),\n            )\n\n        return EmbeddingResult(\n            embeddings=embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            usage=_map_usage(response, self.system, self.base_url, self.model_name),\n            model_name=self.model_name,\n            provider_name=self.system,\n            provider_response_id=response.id,\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        return _MAX_INPUT_TOKENS.get(self.model_name)\n\n    async def count_tokens(self, text: str) -> int:\n        if self._v1_client is None:\n            raise NotImplementedError('Counting tokens requires the Cohere v1 client')\n        try:\n            result = await self._v1_client.tokenize(\n                model=self.model_name,\n                text=text,  # Has a max length of 65536 characters\n                offline=False,\n            )\n        except ApiError as e:  # pragma: no cover\n            if (status_code := e.status_code) and status_code >= 400:\n                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e\n            raise ModelAPIError(model_name=self.model_name, message=str(e)) from e\n\n        return len(result.tokens)\n````\n\n#### __init__\n\n```python\n__init__(\n    model_name: CohereEmbeddingModelName,\n    *,\n    provider: (\n        Literal[\"cohere\"] | Provider[AsyncClientV2]\n    ) = \"cohere\",\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize a Cohere embedding model.\n\nParameters:\n\n| Name         | Type                       | Description                                                                               | Default                                                                                                                                                            |\n| ------------ | -------------------------- | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `model_name` | `CohereEmbeddingModelName` | The name of the Cohere model to use. See Cohere Embed documentation for available models. | *required*                                                                                                                                                         |\n| `provider`   | \\`Literal['cohere']        | Provider[AsyncClientV2]\\`                                                                 | The provider to use for authentication and API access. Can be: 'cohere' (default): Uses the standard Cohere API A CohereProvider instance for custom configuration |\n| `settings`   | \\`EmbeddingSettings        | None\\`                                                                                    | Model-specific EmbeddingSettings to use as defaults for this model.                                                                                                |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/cohere.py`\n\n```python\ndef __init__(\n    self,\n    model_name: CohereEmbeddingModelName,\n    *,\n    provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize a Cohere embedding model.\n\n    Args:\n        model_name: The name of the Cohere model to use.\n            See [Cohere Embed documentation](https://docs.cohere.com/docs/cohere-embed)\n            for available models.\n        provider: The provider to use for authentication and API access. Can be:\n\n            - `'cohere'` (default): Uses the standard Cohere API\n            - A [`CohereProvider`][pydantic_ai.providers.cohere.CohereProvider] instance\n              for custom configuration\n        settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n            to use as defaults for this model.\n    \"\"\"\n    self._model_name = model_name\n\n    if isinstance(provider, str):\n        provider = infer_provider(provider)\n    self._provider = provider\n    self._client = provider.client\n    self._v1_client = provider.v1_client if isinstance(provider, CohereProvider) else None\n\n    super().__init__(settings=settings)\n```\n\n#### base_url\n\n```python\nbase_url: str\n```\n\nThe base URL for the provider API, if available.\n\n#### model_name\n\n```python\nmodel_name: CohereEmbeddingModelName\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n### LatestGoogleGLAEmbeddingModelNames\n\n```python\nLatestGoogleGLAEmbeddingModelNames = Literal[\n    \"gemini-embedding-001\"\n]\n```\n\nLatest Google Gemini API (GLA) embedding models.\n\nSee the [Google Embeddings documentation](https://ai.google.dev/gemini-api/docs/embeddings) for available models and their capabilities.\n\n### LatestGoogleVertexEmbeddingModelNames\n\n```python\nLatestGoogleVertexEmbeddingModelNames = Literal[\n    \"gemini-embedding-001\",\n    \"text-embedding-005\",\n    \"text-multilingual-embedding-002\",\n]\n```\n\nLatest Google Vertex AI embedding models.\n\nSee the [Vertex AI Embeddings documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/get-text-embeddings) for available models and their capabilities.\n\n### LatestGoogleEmbeddingModelNames\n\n```python\nLatestGoogleEmbeddingModelNames = (\n    LatestGoogleGLAEmbeddingModelNames\n    | LatestGoogleVertexEmbeddingModelNames\n)\n```\n\nAll latest Google embedding models (union of GLA and Vertex AI models).\n\n### GoogleEmbeddingModelName\n\n```python\nGoogleEmbeddingModelName = (\n    str | LatestGoogleEmbeddingModelNames\n)\n```\n\nPossible Google embeddings model names.\n\n### GoogleEmbeddingSettings\n\nBases: `EmbeddingSettings`\n\nSettings used for a Google embedding model request.\n\nAll fields from EmbeddingSettings are supported, plus Google-specific settings prefixed with `google_`.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/google.py`\n\n```python\nclass GoogleEmbeddingSettings(EmbeddingSettings, total=False):\n    \"\"\"Settings used for a Google embedding model request.\n\n    All fields from [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings] are supported,\n    plus Google-specific settings prefixed with `google_`.\n    \"\"\"\n\n    # ALL FIELDS MUST BE `google_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.\n\n    google_task_type: str\n    \"\"\"The task type for the embedding.\n\n    Overrides the automatic task type selection based on `input_type`.\n    See [Google's task type documentation](https://ai.google.dev/gemini-api/docs/embeddings#task-types)\n    for available options.\n    \"\"\"\n\n    google_title: str\n    \"\"\"Optional title for the content being embedded.\n\n    Only applicable when task_type is `RETRIEVAL_DOCUMENT`.\n    \"\"\"\n```\n\n#### google_task_type\n\n```python\ngoogle_task_type: str\n```\n\nThe task type for the embedding.\n\nOverrides the automatic task type selection based on `input_type`. See [Google's task type documentation](https://ai.google.dev/gemini-api/docs/embeddings#task-types) for available options.\n\n#### google_title\n\n```python\ngoogle_title: str\n```\n\nOptional title for the content being embedded.\n\nOnly applicable when task_type is `RETRIEVAL_DOCUMENT`.\n\n### GoogleEmbeddingModel\n\nBases: `EmbeddingModel`\n\nGoogle embedding model implementation.\n\nThis model works with Google's embeddings API via the `google-genai` SDK, supporting both the Gemini API (Google AI Studio) and Vertex AI.\n\nExample:\n\n```python\nfrom pydantic_ai.embeddings.google import GoogleEmbeddingModel\nfrom pydantic_ai.providers.google import GoogleProvider\n\n# Using Gemini API (requires GOOGLE_API_KEY env var)\nmodel = GoogleEmbeddingModel('gemini-embedding-001')\n\n# Using Vertex AI\nmodel = GoogleEmbeddingModel(\n    'gemini-embedding-001',\n    provider=GoogleProvider(vertexai=True, project='my-project', location='us-central1'),\n)\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/google.py`\n\n````python\n@dataclass(init=False)\nclass GoogleEmbeddingModel(EmbeddingModel):\n    \"\"\"Google embedding model implementation.\n\n    This model works with Google's embeddings API via the `google-genai` SDK,\n    supporting both the Gemini API (Google AI Studio) and Vertex AI.\n\n    Example:\n    ```python\n    from pydantic_ai.embeddings.google import GoogleEmbeddingModel\n    from pydantic_ai.providers.google import GoogleProvider\n\n    # Using Gemini API (requires GOOGLE_API_KEY env var)\n    model = GoogleEmbeddingModel('gemini-embedding-001')\n\n    # Using Vertex AI\n    model = GoogleEmbeddingModel(\n        'gemini-embedding-001',\n        provider=GoogleProvider(vertexai=True, project='my-project', location='us-central1'),\n    )\n    ```\n    \"\"\"\n\n    _model_name: GoogleEmbeddingModelName = field(repr=False)\n    _provider: Provider[Client] = field(repr=False)\n\n    def __init__(\n        self,\n        model_name: GoogleEmbeddingModelName,\n        *,\n        provider: Literal['google-gla', 'google-vertex'] | Provider[Client] = 'google-gla',\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize a Google embedding model.\n\n        Args:\n            model_name: The name of the Google model to use.\n                See [Google Embeddings documentation](https://ai.google.dev/gemini-api/docs/embeddings)\n                for available models.\n            provider: The provider to use for authentication and API access. Can be:\n\n                - `'google-gla'` (default): Uses the Gemini API (Google AI Studio)\n                - `'google-vertex'`: Uses Vertex AI\n                - A [`GoogleProvider`][pydantic_ai.providers.google.GoogleProvider] instance\n                  for custom configuration\n            settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n                to use as defaults for this model.\n        \"\"\"\n        self._model_name = model_name\n\n        if isinstance(provider, str):\n            provider = infer_provider(provider)\n        self._provider = provider\n        self._client = provider.client\n\n        super().__init__(settings=settings)\n\n    @property\n    def base_url(self) -> str:\n        return self._provider.base_url\n\n    @property\n    def model_name(self) -> GoogleEmbeddingModelName:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider.name\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        settings = cast(GoogleEmbeddingSettings, settings)\n\n        google_task_type = settings.get('google_task_type')\n        if google_task_type is None:\n            google_task_type = 'RETRIEVAL_DOCUMENT' if input_type == 'document' else 'RETRIEVAL_QUERY'\n\n        config = EmbedContentConfig(\n            task_type=google_task_type,\n            output_dimensionality=settings.get('dimensions'),\n            title=settings.get('google_title'),\n        )\n\n        try:\n            response = await self._client.aio.models.embed_content(\n                model=self._model_name,\n                contents=cast(ContentListUnion, inputs),\n                config=config,\n            )\n        except errors.APIError as e:\n            if (status_code := e.code) >= 400:\n                raise ModelHTTPError(\n                    status_code=status_code,\n                    model_name=self._model_name,\n                    body=cast(object, e.details),  # pyright: ignore[reportUnknownMemberType]\n                ) from e\n            raise  # pragma: no cover\n\n        embeddings: list[list[float]] = [emb.values for emb in (response.embeddings or []) if emb.values is not None]\n\n        return EmbeddingResult(\n            embeddings=embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            usage=_map_usage(response, self.system, self.base_url, self._model_name),\n            model_name=self._model_name,\n            provider_name=self.system,\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        return _MAX_INPUT_TOKENS.get(self._model_name)\n\n    async def count_tokens(self, text: str) -> int:\n        try:\n            response = await self._client.aio.models.count_tokens(\n                model=self._model_name,\n                contents=text,\n            )\n        except errors.APIError as e:\n            if (status_code := e.code) >= 400:\n                raise ModelHTTPError(\n                    status_code=status_code,\n                    model_name=self._model_name,\n                    body=cast(object, e.details),  # pyright: ignore[reportUnknownMemberType]\n                ) from e\n            raise  # pragma: no cover\n\n        if response.total_tokens is None:\n            raise UnexpectedModelBehavior('Token counting returned no result')  # pragma: no cover\n        return response.total_tokens\n````\n\n#### __init__\n\n```python\n__init__(\n    model_name: GoogleEmbeddingModelName,\n    *,\n    provider: (\n        Literal[\"google-gla\", \"google-vertex\"]\n        | Provider[Client]\n    ) = \"google-gla\",\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize a Google embedding model.\n\nParameters:\n\n| Name         | Type                                     | Description                                                                                    | Default                                                                                                                                                                                                          |\n| ------------ | ---------------------------------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `model_name` | `GoogleEmbeddingModelName`               | The name of the Google model to use. See Google Embeddings documentation for available models. | *required*                                                                                                                                                                                                       |\n| `provider`   | \\`Literal['google-gla', 'google-vertex'] | Provider[Client]\\`                                                                             | The provider to use for authentication and API access. Can be: 'google-gla' (default): Uses the Gemini API (Google AI Studio) 'google-vertex': Uses Vertex AI A GoogleProvider instance for custom configuration |\n| `settings`   | \\`EmbeddingSettings                      | None\\`                                                                                         | Model-specific EmbeddingSettings to use as defaults for this model.                                                                                                                                              |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/google.py`\n\n```python\ndef __init__(\n    self,\n    model_name: GoogleEmbeddingModelName,\n    *,\n    provider: Literal['google-gla', 'google-vertex'] | Provider[Client] = 'google-gla',\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize a Google embedding model.\n\n    Args:\n        model_name: The name of the Google model to use.\n            See [Google Embeddings documentation](https://ai.google.dev/gemini-api/docs/embeddings)\n            for available models.\n        provider: The provider to use for authentication and API access. Can be:\n\n            - `'google-gla'` (default): Uses the Gemini API (Google AI Studio)\n            - `'google-vertex'`: Uses Vertex AI\n            - A [`GoogleProvider`][pydantic_ai.providers.google.GoogleProvider] instance\n              for custom configuration\n        settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n            to use as defaults for this model.\n    \"\"\"\n    self._model_name = model_name\n\n    if isinstance(provider, str):\n        provider = infer_provider(provider)\n    self._provider = provider\n    self._client = provider.client\n\n    super().__init__(settings=settings)\n```\n\n#### model_name\n\n```python\nmodel_name: GoogleEmbeddingModelName\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n### LatestBedrockEmbeddingModelNames\n\n```python\nLatestBedrockEmbeddingModelNames = Literal[\n    \"amazon.titan-embed-text-v1\",\n    \"amazon.titan-embed-text-v2:0\",\n    \"cohere.embed-english-v3\",\n    \"cohere.embed-multilingual-v3\",\n    \"cohere.embed-v4:0\",\n    \"amazon.nova-2-multimodal-embeddings-v1:0\",\n]\n```\n\nLatest Bedrock embedding model names.\n\nSee [the Bedrock docs](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html) for available embedding models.\n\n### BedrockEmbeddingModelName\n\n```python\nBedrockEmbeddingModelName = (\n    str | LatestBedrockEmbeddingModelNames\n)\n```\n\nPossible Bedrock embedding model names.\n\n### BedrockEmbeddingSettings\n\nBases: `EmbeddingSettings`\n\nSettings used for a Bedrock embedding model request.\n\nAll fields from EmbeddingSettings are supported, plus Bedrock-specific settings prefixed with `bedrock_`.\n\nAll settings are optional - if not specified, model defaults are used.\n\n**Note on `dimensions` parameter support:**\n\n- **Titan v1** (`amazon.titan-embed-text-v1`): Not supported (fixed: 1536)\n- **Titan v2** (`amazon.titan-embed-text-v2:0`): Supported (default: 1024, accepts 256/384/1024)\n- **Cohere v3** (`cohere.embed-english-v3`, `cohere.embed-multilingual-v3`): Not supported (fixed: 1024)\n- **Cohere v4** (`cohere.embed-v4:0`): Supported (default: 1536, accepts 256/512/1024/1536)\n- **Nova** (`amazon.nova-2-multimodal-embeddings-v1:0`): Supported (default: 3072, accepts 256/384/1024/3072)\n\nUnsupported settings are silently ignored.\n\n**Note on `truncate` parameter support:**\n\n- **Titan models** (`amazon.titan-embed-text-v1`, `amazon.titan-embed-text-v2:0`): Not supported\n- **Cohere models** (all versions): Supported (default: `False`, maps to `'END'` when `True`)\n- **Nova** (`amazon.nova-2-multimodal-embeddings-v1:0`): Supported (default: `False`, maps to `'END'` when `True`)\n\nFor fine-grained truncation control, use model-specific settings: `bedrock_cohere_truncate` or `bedrock_nova_truncate`.\n\nExample\n\n```python\nfrom pydantic_ai.embeddings.bedrock import BedrockEmbeddingSettings\n\n# Use model defaults\nsettings = BedrockEmbeddingSettings()\n\n# Customize specific settings for Titan v2:0\nsettings = BedrockEmbeddingSettings(\n    dimensions=512,\n    bedrock_titan_normalize=True,\n)\n\n# Customize specific settings for Cohere v4\nsettings = BedrockEmbeddingSettings(\n    dimensions=512,\n    bedrock_cohere_max_tokens=1000,\n)\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/bedrock.py`\n\n````python\nclass BedrockEmbeddingSettings(EmbeddingSettings, total=False):\n    \"\"\"Settings used for a Bedrock embedding model request.\n\n    All fields from [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings] are supported,\n    plus Bedrock-specific settings prefixed with `bedrock_`.\n\n    All settings are optional - if not specified, model defaults are used.\n\n    **Note on `dimensions` parameter support:**\n\n    - **Titan v1** (`amazon.titan-embed-text-v1`): Not supported (fixed: 1536)\n    - **Titan v2** (`amazon.titan-embed-text-v2:0`): Supported (default: 1024, accepts 256/384/1024)\n    - **Cohere v3** (`cohere.embed-english-v3`, `cohere.embed-multilingual-v3`): Not supported (fixed: 1024)\n    - **Cohere v4** (`cohere.embed-v4:0`): Supported (default: 1536, accepts 256/512/1024/1536)\n    - **Nova** (`amazon.nova-2-multimodal-embeddings-v1:0`): Supported (default: 3072, accepts 256/384/1024/3072)\n\n    Unsupported settings are silently ignored.\n\n    **Note on `truncate` parameter support:**\n\n    - **Titan models** (`amazon.titan-embed-text-v1`, `amazon.titan-embed-text-v2:0`): Not supported\n    - **Cohere models** (all versions): Supported (default: `False`, maps to `'END'` when `True`)\n    - **Nova** (`amazon.nova-2-multimodal-embeddings-v1:0`): Supported (default: `False`, maps to `'END'` when `True`)\n\n    For fine-grained truncation control, use model-specific settings: `bedrock_cohere_truncate` or `bedrock_nova_truncate`.\n\n    Example:\n        ```python\n        from pydantic_ai.embeddings.bedrock import BedrockEmbeddingSettings\n\n        # Use model defaults\n        settings = BedrockEmbeddingSettings()\n\n        # Customize specific settings for Titan v2:0\n        settings = BedrockEmbeddingSettings(\n            dimensions=512,\n            bedrock_titan_normalize=True,\n        )\n\n        # Customize specific settings for Cohere v4\n        settings = BedrockEmbeddingSettings(\n            dimensions=512,\n            bedrock_cohere_max_tokens=1000,\n        )\n        ```\n    \"\"\"\n\n    # ALL FIELDS MUST BE `bedrock_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.\n\n    # ==================== Amazon Titan Settings ====================\n\n    bedrock_titan_normalize: bool\n    \"\"\"Whether to normalize embedding vectors for Titan models.\n\n    **Supported by:** `amazon.titan-embed-text-v2:0` (default: `True`)\n\n    **Not supported by:** `amazon.titan-embed-text-v1` (silently ignored)\n\n    When enabled, vectors are normalized for direct cosine similarity calculations.\n    \"\"\"\n\n    # ==================== Cohere Settings ====================\n\n    bedrock_cohere_max_tokens: int\n    \"\"\"The maximum number of tokens to embed for Cohere models.\n\n    **Supported by:** `cohere.embed-v4:0` (default: 128000)\n\n    **Not supported by:** `cohere.embed-english-v3`, `cohere.embed-multilingual-v3`\n    (silently ignored)\n    \"\"\"\n\n    bedrock_cohere_input_type: Literal['search_document', 'search_query', 'classification', 'clustering']\n    \"\"\"The input type for Cohere models.\n\n    **Supported by:** All Cohere models (`cohere.embed-english-v3`, `cohere.embed-multilingual-v3`, `cohere.embed-v4:0`)\n\n    By default, `embed_query()` uses `'search_query'` and `embed_documents()` uses `'search_document'`.\n    Also accepts `'classification'` or `'clustering'`.\n    \"\"\"\n\n    bedrock_cohere_truncate: Literal['NONE', 'START', 'END']\n    \"\"\"The truncation strategy for Cohere models. Overrides base `truncate` setting.\n\n    **Supported by:** All Cohere models (`cohere.embed-english-v3`, `cohere.embed-multilingual-v3`, `cohere.embed-v4:0`)\n\n    Default: `'NONE'`\n\n    - `'NONE'`: Raise an error if input exceeds max tokens.\n    - `'START'`: Truncate the start of the input.\n    - `'END'`: Truncate the end of the input.\n    \"\"\"\n\n    # ==================== Amazon Nova Settings ====================\n\n    bedrock_nova_truncate: Literal['NONE', 'START', 'END']\n    \"\"\"The truncation strategy for Nova models. Overrides base `truncate` setting.\n\n    **Supported by:** `amazon.nova-2-multimodal-embeddings-v1:0`\n\n    Default: `'NONE'`\n\n    - `'NONE'`: Raise an error if input exceeds max tokens.\n    - `'START'`: Truncate the start of the input.\n    - `'END'`: Truncate the end of the input.\n    \"\"\"\n\n    bedrock_nova_embedding_purpose: Literal[\n        'GENERIC_INDEX',\n        'GENERIC_RETRIEVAL',\n        'TEXT_RETRIEVAL',\n        'CLASSIFICATION',\n        'CLUSTERING',\n    ]\n    \"\"\"The embedding purpose for Nova models.\n\n    **Supported by:** `amazon.nova-2-multimodal-embeddings-v1:0`\n\n    By default, `embed_query()` uses `'GENERIC_RETRIEVAL'` and `embed_documents()` uses `'GENERIC_INDEX'`.\n    Also accepts `'TEXT_RETRIEVAL'`, `'CLASSIFICATION'`, or `'CLUSTERING'`.\n\n    Note: Multimodal-specific purposes (`'IMAGE_RETRIEVAL'`, `'VIDEO_RETRIEVAL'`,\n    `'DOCUMENT_RETRIEVAL'`, `'AUDIO_RETRIEVAL'`) are not supported as this\n    embedding client only accepts text input.\n    \"\"\"\n\n    bedrock_inference_profile: str\n    \"\"\"An [inference profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles.html) ARN to use as the `modelId` in API requests.\n\n    When set, this value is used as the `modelId` in `invoke_model` API calls instead of the\n    base `model_name`. This allows you to pass the base model name (e.g. `'amazon.titan-embed-text-v2:0'`)\n    as `model_name` for detecting model capabilities, while routing requests through an inference profile\n    for cost tracking or cross-region inference.\n    \"\"\"\n\n    # ==================== Concurrency Settings ====================\n\n    bedrock_max_concurrency: int\n    \"\"\"Maximum number of concurrent requests for models that don't support batch embedding.\n\n    **Applies to:** `amazon.titan-embed-text-v1`, `amazon.titan-embed-text-v2:0`,\n    `amazon.nova-2-multimodal-embeddings-v1:0`\n\n    When embedding multiple texts with models that only support single-text requests,\n    this controls how many requests run in parallel. Defaults to 5.\n    \"\"\"\n````\n\n#### bedrock_titan_normalize\n\n```python\nbedrock_titan_normalize: bool\n```\n\nWhether to normalize embedding vectors for Titan models.\n\n**Supported by:** `amazon.titan-embed-text-v2:0` (default: `True`)\n\n**Not supported by:** `amazon.titan-embed-text-v1` (silently ignored)\n\nWhen enabled, vectors are normalized for direct cosine similarity calculations.\n\n#### bedrock_cohere_max_tokens\n\n```python\nbedrock_cohere_max_tokens: int\n```\n\nThe maximum number of tokens to embed for Cohere models.\n\n**Supported by:** `cohere.embed-v4:0` (default: 128000)\n\n**Not supported by:** `cohere.embed-english-v3`, `cohere.embed-multilingual-v3` (silently ignored)\n\n#### bedrock_cohere_input_type\n\n```python\nbedrock_cohere_input_type: Literal[\n    \"search_document\",\n    \"search_query\",\n    \"classification\",\n    \"clustering\",\n]\n```\n\nThe input type for Cohere models.\n\n**Supported by:** All Cohere models (`cohere.embed-english-v3`, `cohere.embed-multilingual-v3`, `cohere.embed-v4:0`)\n\nBy default, `embed_query()` uses `'search_query'` and `embed_documents()` uses `'search_document'`. Also accepts `'classification'` or `'clustering'`.\n\n#### bedrock_cohere_truncate\n\n```python\nbedrock_cohere_truncate: Literal['NONE', 'START', 'END']\n```\n\nThe truncation strategy for Cohere models. Overrides base `truncate` setting.\n\n**Supported by:** All Cohere models (`cohere.embed-english-v3`, `cohere.embed-multilingual-v3`, `cohere.embed-v4:0`)\n\nDefault: `'NONE'`\n\n- `'NONE'`: Raise an error if input exceeds max tokens.\n- `'START'`: Truncate the start of the input.\n- `'END'`: Truncate the end of the input.\n\n#### bedrock_nova_truncate\n\n```python\nbedrock_nova_truncate: Literal['NONE', 'START', 'END']\n```\n\nThe truncation strategy for Nova models. Overrides base `truncate` setting.\n\n**Supported by:** `amazon.nova-2-multimodal-embeddings-v1:0`\n\nDefault: `'NONE'`\n\n- `'NONE'`: Raise an error if input exceeds max tokens.\n- `'START'`: Truncate the start of the input.\n- `'END'`: Truncate the end of the input.\n\n#### bedrock_nova_embedding_purpose\n\n```python\nbedrock_nova_embedding_purpose: Literal[\n    \"GENERIC_INDEX\",\n    \"GENERIC_RETRIEVAL\",\n    \"TEXT_RETRIEVAL\",\n    \"CLASSIFICATION\",\n    \"CLUSTERING\",\n]\n```\n\nThe embedding purpose for Nova models.\n\n**Supported by:** `amazon.nova-2-multimodal-embeddings-v1:0`\n\nBy default, `embed_query()` uses `'GENERIC_RETRIEVAL'` and `embed_documents()` uses `'GENERIC_INDEX'`. Also accepts `'TEXT_RETRIEVAL'`, `'CLASSIFICATION'`, or `'CLUSTERING'`.\n\nNote: Multimodal-specific purposes (`'IMAGE_RETRIEVAL'`, `'VIDEO_RETRIEVAL'`, `'DOCUMENT_RETRIEVAL'`, `'AUDIO_RETRIEVAL'`) are not supported as this embedding client only accepts text input.\n\n#### bedrock_inference_profile\n\n```python\nbedrock_inference_profile: str\n```\n\nAn [inference profile](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles.html) ARN to use as the `modelId` in API requests.\n\nWhen set, this value is used as the `modelId` in `invoke_model` API calls instead of the base `model_name`. This allows you to pass the base model name (e.g. `'amazon.titan-embed-text-v2:0'`) as `model_name` for detecting model capabilities, while routing requests through an inference profile for cost tracking or cross-region inference.\n\n#### bedrock_max_concurrency\n\n```python\nbedrock_max_concurrency: int\n```\n\nMaximum number of concurrent requests for models that don't support batch embedding.\n\n**Applies to:** `amazon.titan-embed-text-v1`, `amazon.titan-embed-text-v2:0`, `amazon.nova-2-multimodal-embeddings-v1:0`\n\nWhen embedding multiple texts with models that only support single-text requests, this controls how many requests run in parallel. Defaults to 5.\n\n### BedrockEmbeddingModel\n\nBases: `EmbeddingModel`\n\nBedrock embedding model implementation.\n\nThis model works with AWS Bedrock's embedding models including Amazon Titan Embeddings and Cohere Embed models.\n\nExample:\n\n```python\nfrom pydantic_ai.embeddings.bedrock import BedrockEmbeddingModel\nfrom pydantic_ai.providers.bedrock import BedrockProvider\n\n# Using default AWS credentials\nmodel = BedrockEmbeddingModel('amazon.titan-embed-text-v2:0')\n\n# Using explicit credentials\nmodel = BedrockEmbeddingModel(\n    'cohere.embed-english-v3',\n    provider=BedrockProvider(\n        region_name='us-east-1',\n        aws_access_key_id='...',\n        aws_secret_access_key='...',\n    ),\n)\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/bedrock.py`\n\n````python\n@dataclass(init=False)\nclass BedrockEmbeddingModel(EmbeddingModel):\n    \"\"\"Bedrock embedding model implementation.\n\n    This model works with AWS Bedrock's embedding models including\n    Amazon Titan Embeddings and Cohere Embed models.\n\n    Example:\n    ```python\n    from pydantic_ai.embeddings.bedrock import BedrockEmbeddingModel\n    from pydantic_ai.providers.bedrock import BedrockProvider\n\n    # Using default AWS credentials\n    model = BedrockEmbeddingModel('amazon.titan-embed-text-v2:0')\n\n    # Using explicit credentials\n    model = BedrockEmbeddingModel(\n        'cohere.embed-english-v3',\n        provider=BedrockProvider(\n            region_name='us-east-1',\n            aws_access_key_id='...',\n            aws_secret_access_key='...',\n        ),\n    )\n    ```\n    \"\"\"\n\n    client: BedrockRuntimeClient\n\n    _model_name: BedrockEmbeddingModelName = field(repr=False)\n    _provider: Provider[BaseClient] = field(repr=False)\n    _handler: _BedrockEmbeddingHandler = field(repr=False)\n\n    def __init__(\n        self,\n        model_name: BedrockEmbeddingModelName,\n        *,\n        provider: Literal['bedrock'] | Provider[BaseClient] = 'bedrock',\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize a Bedrock embedding model.\n\n        Args:\n            model_name: The name of the Bedrock embedding model to use.\n                See [Bedrock embedding models](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html)\n                for available options.\n            provider: The provider to use for authentication and API access. Can be:\n\n                - `'bedrock'` (default): Uses default AWS credentials\n                - A [`BedrockProvider`][pydantic_ai.providers.bedrock.BedrockProvider] instance\n                  for custom configuration\n\n            settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n                to use as defaults for this model.\n        \"\"\"\n        self._model_name = model_name\n\n        if isinstance(provider, str):\n            provider = infer_provider(provider)\n        self._provider = provider\n        self.client = cast('BedrockRuntimeClient', provider.client)\n        self._handler = _get_handler_for_model(model_name)\n\n        super().__init__(settings=settings)\n\n    @property\n    def base_url(self) -> str:\n        \"\"\"The base URL for the provider API.\"\"\"\n        return str(self.client.meta.endpoint_url)\n\n    @property\n    def model_name(self) -> BedrockEmbeddingModelName:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider.name\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs_list, settings_dict = self.prepare_embed(inputs, settings)\n        settings_typed = cast(BedrockEmbeddingSettings, settings_dict)\n\n        if self._handler.supports_batch:\n            # Models like Cohere support batch requests\n            return await self._embed_batch(inputs_list, input_type, settings_typed)\n        else:\n            # Models like Titan require individual requests\n            return await self._embed_concurrent(inputs_list, input_type, settings_typed)\n\n    async def _embed_batch(\n        self,\n        inputs: list[str],\n        input_type: EmbedInputType,\n        settings: BedrockEmbeddingSettings,\n    ) -> EmbeddingResult:\n        \"\"\"Embed all inputs in a single batch request.\"\"\"\n        body = self._handler.prepare_request(inputs, input_type, settings)\n        response, input_tokens = await self._invoke_model(body, settings)\n        embeddings, response_id = self._handler.parse_response(response)\n\n        return EmbeddingResult(\n            embeddings=embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            usage=RequestUsage(input_tokens=input_tokens),\n            model_name=self.model_name,\n            provider_name=self.system,\n            provider_response_id=response_id,\n        )\n\n    async def _embed_concurrent(\n        self,\n        inputs: list[str],\n        input_type: EmbedInputType,\n        settings: BedrockEmbeddingSettings,\n    ) -> EmbeddingResult:\n        \"\"\"Embed inputs concurrently with controlled parallelism and combine results.\"\"\"\n        max_concurrency = settings.get('bedrock_max_concurrency', 5)\n        semaphore = anyio.Semaphore(max_concurrency)\n\n        results: list[tuple[Sequence[float], int]] = [None] * len(inputs)  # type: ignore[list-item]\n\n        async def embed_single(index: int, text: str) -> None:\n            async with semaphore:\n                body = self._handler.prepare_request([text], input_type, settings)\n                response, input_tokens = await self._invoke_model(body, settings)\n                embeddings, _ = self._handler.parse_response(response)\n                results[index] = (embeddings[0], input_tokens)\n\n        async with anyio.create_task_group() as tg:\n            for i, text in enumerate(inputs):\n                tg.start_soon(embed_single, i, text)\n\n        all_embeddings = [embedding for embedding, _ in results]\n        total_input_tokens = sum(tokens for _, tokens in results)\n\n        return EmbeddingResult(\n            embeddings=all_embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            usage=RequestUsage(input_tokens=total_input_tokens),\n            model_name=self.model_name,\n            provider_name=self.system,\n        )\n\n    async def _invoke_model(\n        self, body: dict[str, Any], settings: BedrockEmbeddingSettings\n    ) -> tuple[dict[str, Any], int]:\n        \"\"\"Invoke the Bedrock model and return parsed response with token count.\n\n        Returns:\n            A tuple of (response_body, input_token_count).\n        \"\"\"\n        model_id = settings.get('bedrock_inference_profile') or self._model_name\n        try:\n            response: InvokeModelResponseTypeDef = await anyio.to_thread.run_sync(\n                functools.partial(\n                    self.client.invoke_model,\n                    modelId=model_id,\n                    body=json.dumps(body),\n                    contentType='application/json',\n                    accept='application/json',\n                )\n            )\n        except ClientError as e:\n            status_code = e.response.get('ResponseMetadata', {}).get('HTTPStatusCode')\n            if isinstance(status_code, int):\n                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.response) from e\n            raise ModelAPIError(model_name=self.model_name, message=str(e)) from e\n\n        # Extract input token count from HTTP headers\n        input_tokens = int(\n            response.get('ResponseMetadata', {}).get('HTTPHeaders', {}).get('x-amzn-bedrock-input-token-count', '0')\n        )\n\n        response_body = json.loads(response['body'].read())\n        return response_body, input_tokens\n\n    async def max_input_tokens(self) -> int | None:\n        \"\"\"Get the maximum number of tokens that can be input to the model.\"\"\"\n        return _MAX_INPUT_TOKENS.get(self._handler.model_name, None)\n````\n\n#### __init__\n\n```python\n__init__(\n    model_name: BedrockEmbeddingModelName,\n    *,\n    provider: (\n        Literal[\"bedrock\"] | Provider[BaseClient]\n    ) = \"bedrock\",\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize a Bedrock embedding model.\n\nParameters:\n\n| Name         | Type                        | Description                                                                                         | Default                                                                                                                                                              |\n| ------------ | --------------------------- | --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `model_name` | `BedrockEmbeddingModelName` | The name of the Bedrock embedding model to use. See Bedrock embedding models for available options. | *required*                                                                                                                                                           |\n| `provider`   | \\`Literal['bedrock']        | Provider[BaseClient]\\`                                                                              | The provider to use for authentication and API access. Can be: 'bedrock' (default): Uses default AWS credentials A BedrockProvider instance for custom configuration |\n| `settings`   | \\`EmbeddingSettings         | None\\`                                                                                              | Model-specific EmbeddingSettings to use as defaults for this model.                                                                                                  |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/bedrock.py`\n\n```python\ndef __init__(\n    self,\n    model_name: BedrockEmbeddingModelName,\n    *,\n    provider: Literal['bedrock'] | Provider[BaseClient] = 'bedrock',\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize a Bedrock embedding model.\n\n    Args:\n        model_name: The name of the Bedrock embedding model to use.\n            See [Bedrock embedding models](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html)\n            for available options.\n        provider: The provider to use for authentication and API access. Can be:\n\n            - `'bedrock'` (default): Uses default AWS credentials\n            - A [`BedrockProvider`][pydantic_ai.providers.bedrock.BedrockProvider] instance\n              for custom configuration\n\n        settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n            to use as defaults for this model.\n    \"\"\"\n    self._model_name = model_name\n\n    if isinstance(provider, str):\n        provider = infer_provider(provider)\n    self._provider = provider\n    self.client = cast('BedrockRuntimeClient', provider.client)\n    self._handler = _get_handler_for_model(model_name)\n\n    super().__init__(settings=settings)\n```\n\n#### base_url\n\n```python\nbase_url: str\n```\n\nThe base URL for the provider API.\n\n#### model_name\n\n```python\nmodel_name: BedrockEmbeddingModelName\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n#### max_input_tokens\n\n```python\nmax_input_tokens() -> int | None\n```\n\nGet the maximum number of tokens that can be input to the model.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/bedrock.py`\n\n```python\nasync def max_input_tokens(self) -> int | None:\n    \"\"\"Get the maximum number of tokens that can be input to the model.\"\"\"\n    return _MAX_INPUT_TOKENS.get(self._handler.model_name, None)\n```\n\n### LatestVoyageAIEmbeddingModelNames\n\n```python\nLatestVoyageAIEmbeddingModelNames = Literal[\n    \"voyage-4-large\",\n    \"voyage-4\",\n    \"voyage-4-lite\",\n    \"voyage-3-large\",\n    \"voyage-3.5\",\n    \"voyage-3.5-lite\",\n    \"voyage-code-3\",\n    \"voyage-finance-2\",\n    \"voyage-law-2\",\n    \"voyage-code-2\",\n]\n```\n\nLatest VoyageAI embedding models.\n\nSee [VoyageAI Embeddings](https://docs.voyageai.com/docs/embeddings) for available models and their capabilities.\n\n### VoyageAIEmbeddingModelName\n\n```python\nVoyageAIEmbeddingModelName = (\n    str | LatestVoyageAIEmbeddingModelNames\n)\n```\n\nPossible VoyageAI embedding model names.\n\n### VoyageAIEmbedInputType\n\n```python\nVoyageAIEmbedInputType = Literal[\n    \"query\", \"document\", \"none\"\n]\n```\n\nVoyageAI embedding input types.\n\n- `'query'`: For search queries; prepends retrieval-optimized prefix.\n- `'document'`: For documents; prepends document retrieval prefix.\n- `'none'`: Direct embedding without any prefix.\n\n### VoyageAIEmbeddingSettings\n\nBases: `EmbeddingSettings`\n\nSettings used for a VoyageAI embedding model request.\n\nAll fields from EmbeddingSettings are supported, plus VoyageAI-specific settings prefixed with `voyageai_`.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/voyageai.py`\n\n```python\nclass VoyageAIEmbeddingSettings(EmbeddingSettings, total=False):\n    \"\"\"Settings used for a VoyageAI embedding model request.\n\n    All fields from [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings] are supported,\n    plus VoyageAI-specific settings prefixed with `voyageai_`.\n    \"\"\"\n\n    # ALL FIELDS MUST BE `voyageai_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.\n\n    voyageai_input_type: VoyageAIEmbedInputType\n    \"\"\"The VoyageAI-specific input type for the embedding.\n\n    Overrides the standard `input_type` argument. Options include:\n    `'query'`, `'document'`, or `'none'` for direct embedding without prefix.\n    \"\"\"\n```\n\n#### voyageai_input_type\n\n```python\nvoyageai_input_type: VoyageAIEmbedInputType\n```\n\nThe VoyageAI-specific input type for the embedding.\n\nOverrides the standard `input_type` argument. Options include: `'query'`, `'document'`, or `'none'` for direct embedding without prefix.\n\n### VoyageAIEmbeddingModel\n\nBases: `EmbeddingModel`\n\nVoyageAI embedding model implementation.\n\nVoyageAI provides state-of-the-art embedding models optimized for retrieval, with specialized models for code, finance, and legal domains.\n\nExample:\n\n```python\nfrom pydantic_ai.embeddings.voyageai import VoyageAIEmbeddingModel\n\nmodel = VoyageAIEmbeddingModel('voyage-3.5')\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/voyageai.py`\n\n````python\n@dataclass(init=False)\nclass VoyageAIEmbeddingModel(EmbeddingModel):\n    \"\"\"VoyageAI embedding model implementation.\n\n    VoyageAI provides state-of-the-art embedding models optimized for\n    retrieval, with specialized models for code, finance, and legal domains.\n\n    Example:\n    ```python {max_py=\"3.13\"}\n    from pydantic_ai.embeddings.voyageai import VoyageAIEmbeddingModel\n\n    model = VoyageAIEmbeddingModel('voyage-3.5')\n    ```\n    \"\"\"\n\n    _model_name: VoyageAIEmbeddingModelName = field(repr=False)\n    _provider: Provider[AsyncClient] = field(repr=False)\n\n    def __init__(\n        self,\n        model_name: VoyageAIEmbeddingModelName,\n        *,\n        provider: Literal['voyageai'] | Provider[AsyncClient] = 'voyageai',\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize a VoyageAI embedding model.\n\n        Args:\n            model_name: The name of the VoyageAI model to use.\n                See [VoyageAI models](https://docs.voyageai.com/docs/embeddings)\n                for available options.\n            provider: The provider to use for authentication and API access. Can be:\n\n                - `'voyageai'` (default): Uses the standard VoyageAI API\n                - A [`VoyageAIProvider`][pydantic_ai.providers.voyageai.VoyageAIProvider] instance\n                  for custom configuration\n            settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n                to use as defaults for this model.\n        \"\"\"\n        self._model_name = model_name\n\n        if isinstance(provider, str):\n            provider = infer_provider(provider)\n        self._provider = provider\n\n        super().__init__(settings=settings)\n\n    @property\n    def base_url(self) -> str:\n        \"\"\"The base URL for the provider API.\"\"\"\n        return self._provider.base_url\n\n    @property\n    def model_name(self) -> VoyageAIEmbeddingModelName:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider.name\n\n    async def embed(\n        self,\n        inputs: str | Sequence[str],\n        *,\n        input_type: EmbedInputType,\n        settings: EmbeddingSettings | None = None,\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        settings = cast(VoyageAIEmbeddingSettings, settings)\n\n        voyageai_input_type: VoyageAIEmbedInputType = settings.get(\n            'voyageai_input_type', 'document' if input_type == 'document' else 'query'\n        )\n        # Convert 'none' string to None for the API\n        api_input_type = None if voyageai_input_type == 'none' else voyageai_input_type\n\n        try:\n            response = await self._provider.client.embed(\n                texts=list(inputs),\n                model=self.model_name,\n                input_type=api_input_type,\n                truncation=settings.get('truncate', False),\n                output_dimension=settings.get('dimensions'),\n            )\n        except VoyageError as e:\n            raise ModelAPIError(model_name=self.model_name, message=str(e)) from e\n\n        return EmbeddingResult(\n            embeddings=response.embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            usage=_map_usage(response.total_tokens),\n            model_name=self.model_name,\n            provider_name=self.system,\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        return _MAX_INPUT_TOKENS.get(self.model_name)\n````\n\n#### __init__\n\n```python\n__init__(\n    model_name: VoyageAIEmbeddingModelName,\n    *,\n    provider: (\n        Literal[\"voyageai\"] | Provider[AsyncClient]\n    ) = \"voyageai\",\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize a VoyageAI embedding model.\n\nParameters:\n\n| Name         | Type                         | Description                                                                       | Default                                                                                                                                                                  |\n| ------------ | ---------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `model_name` | `VoyageAIEmbeddingModelName` | The name of the VoyageAI model to use. See VoyageAI models for available options. | *required*                                                                                                                                                               |\n| `provider`   | \\`Literal['voyageai']        | Provider[AsyncClient]\\`                                                           | The provider to use for authentication and API access. Can be: 'voyageai' (default): Uses the standard VoyageAI API A VoyageAIProvider instance for custom configuration |\n| `settings`   | \\`EmbeddingSettings          | None\\`                                                                            | Model-specific EmbeddingSettings to use as defaults for this model.                                                                                                      |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/voyageai.py`\n\n```python\ndef __init__(\n    self,\n    model_name: VoyageAIEmbeddingModelName,\n    *,\n    provider: Literal['voyageai'] | Provider[AsyncClient] = 'voyageai',\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize a VoyageAI embedding model.\n\n    Args:\n        model_name: The name of the VoyageAI model to use.\n            See [VoyageAI models](https://docs.voyageai.com/docs/embeddings)\n            for available options.\n        provider: The provider to use for authentication and API access. Can be:\n\n            - `'voyageai'` (default): Uses the standard VoyageAI API\n            - A [`VoyageAIProvider`][pydantic_ai.providers.voyageai.VoyageAIProvider] instance\n              for custom configuration\n        settings: Model-specific [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings]\n            to use as defaults for this model.\n    \"\"\"\n    self._model_name = model_name\n\n    if isinstance(provider, str):\n        provider = infer_provider(provider)\n    self._provider = provider\n\n    super().__init__(settings=settings)\n```\n\n#### base_url\n\n```python\nbase_url: str\n```\n\nThe base URL for the provider API.\n\n#### model_name\n\n```python\nmodel_name: VoyageAIEmbeddingModelName\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n### SentenceTransformersEmbeddingSettings\n\nBases: `EmbeddingSettings`\n\nSettings used for a Sentence-Transformers embedding model request.\n\nAll fields from EmbeddingSettings are supported, plus Sentence-Transformers-specific settings prefixed with `sentence_transformers_`.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/sentence_transformers.py`\n\n```python\nclass SentenceTransformersEmbeddingSettings(EmbeddingSettings, total=False):\n    \"\"\"Settings used for a Sentence-Transformers embedding model request.\n\n    All fields from [`EmbeddingSettings`][pydantic_ai.embeddings.EmbeddingSettings] are supported,\n    plus Sentence-Transformers-specific settings prefixed with `sentence_transformers_`.\n    \"\"\"\n\n    sentence_transformers_device: str\n    \"\"\"Device to run inference on.\n\n    Examples: `'cpu'`, `'cuda'`, `'cuda:0'`, `'mps'` (Apple Silicon).\n    \"\"\"\n\n    sentence_transformers_normalize_embeddings: bool\n    \"\"\"Whether to L2-normalize embeddings.\n\n    When `True`, all embeddings will have unit length, which is useful for\n    cosine similarity calculations.\n    \"\"\"\n\n    sentence_transformers_batch_size: int\n    \"\"\"Batch size to use during encoding.\n\n    Larger batches may be faster but require more memory.\n    \"\"\"\n```\n\n#### sentence_transformers_device\n\n```python\nsentence_transformers_device: str\n```\n\nDevice to run inference on.\n\nExamples: `'cpu'`, `'cuda'`, `'cuda:0'`, `'mps'` (Apple Silicon).\n\n#### sentence_transformers_normalize_embeddings\n\n```python\nsentence_transformers_normalize_embeddings: bool\n```\n\nWhether to L2-normalize embeddings.\n\nWhen `True`, all embeddings will have unit length, which is useful for cosine similarity calculations.\n\n#### sentence_transformers_batch_size\n\n```python\nsentence_transformers_batch_size: int\n```\n\nBatch size to use during encoding.\n\nLarger batches may be faster but require more memory.\n\n### SentenceTransformerEmbeddingModel\n\nBases: `EmbeddingModel`\n\nLocal embedding model using the `sentence-transformers` library.\n\nThis model runs embeddings locally on your machine, which is useful for:\n\n- Privacy-sensitive applications where data shouldn't leave your infrastructure\n- Reducing API costs for high-volume embedding workloads\n- Offline or air-gapped environments\n\nModels are downloaded from Hugging Face on first use. See the [Sentence-Transformers documentation](https://www.sbert.net/docs/sentence_transformer/pretrained_models.html) for available models.\n\nExample:\n\n```python\nfrom sentence_transformers import SentenceTransformer\n\nfrom pydantic_ai.embeddings.sentence_transformers import (\n    SentenceTransformerEmbeddingModel,\n)\n\n# Using a model name (downloads from Hugging Face)\nmodel = SentenceTransformerEmbeddingModel('all-MiniLM-L6-v2')\n\n# Using an existing SentenceTransformer instance\nst_model = SentenceTransformer('all-MiniLM-L6-v2')\nmodel = SentenceTransformerEmbeddingModel(st_model)\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/sentence_transformers.py`\n\n````python\n@dataclass(init=False)\nclass SentenceTransformerEmbeddingModel(EmbeddingModel):\n    \"\"\"Local embedding model using the `sentence-transformers` library.\n\n    This model runs embeddings locally on your machine, which is useful for:\n\n    - Privacy-sensitive applications where data shouldn't leave your infrastructure\n    - Reducing API costs for high-volume embedding workloads\n    - Offline or air-gapped environments\n\n    Models are downloaded from Hugging Face on first use.\n    See the [Sentence-Transformers documentation](https://www.sbert.net/docs/sentence_transformer/pretrained_models.html)\n    for available models.\n\n    Example:\n    ```python {max_py=\"3.13\"}\n    from sentence_transformers import SentenceTransformer\n\n    from pydantic_ai.embeddings.sentence_transformers import (\n        SentenceTransformerEmbeddingModel,\n    )\n\n    # Using a model name (downloads from Hugging Face)\n    model = SentenceTransformerEmbeddingModel('all-MiniLM-L6-v2')\n\n    # Using an existing SentenceTransformer instance\n    st_model = SentenceTransformer('all-MiniLM-L6-v2')\n    model = SentenceTransformerEmbeddingModel(st_model)\n    ```\n    \"\"\"\n\n    _model_name: str = field(repr=False)\n    _model: SentenceTransformer | None = field(repr=False, default=None)\n\n    def __init__(self, model: SentenceTransformer | str, *, settings: EmbeddingSettings | None = None) -> None:\n        \"\"\"Initialize a Sentence-Transformers embedding model.\n\n        Args:\n            model: The model to use. Can be:\n\n                - A model name from Hugging Face (e.g., `'all-MiniLM-L6-v2'`)\n                - A local path to a saved model\n                - An existing `SentenceTransformer` instance\n            settings: Model-specific\n                [`SentenceTransformersEmbeddingSettings`][pydantic_ai.embeddings.sentence_transformers.SentenceTransformersEmbeddingSettings]\n                to use as defaults for this model.\n        \"\"\"\n        if isinstance(model, str):\n            self._model_name = model\n        else:\n            self._model = deepcopy(model)\n            self._model_name = model.model_card_data.model_id or model.model_card_data.base_model or 'unknown'\n\n        super().__init__(settings=settings)\n\n    @property\n    def base_url(self) -> str | None:\n        \"\"\"No base URL — runs locally.\"\"\"\n        return None\n\n    @property\n    def model_name(self) -> str:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider/system identifier.\"\"\"\n        return 'sentence-transformers'\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        settings = cast(SentenceTransformersEmbeddingSettings, settings)\n\n        device = settings.get('sentence_transformers_device', None)\n        normalize = settings.get('sentence_transformers_normalize_embeddings', False)\n        batch_size = settings.get('sentence_transformers_batch_size', None)\n        dimensions = settings.get('dimensions', None)\n\n        model = await self._get_model()\n        encode_func = model.encode_query if input_type == 'query' else model.encode_document  # type: ignore[reportUnknownReturnType]\n\n        np_embeddings: np.ndarray[Any, float] = await _utils.run_in_executor(  # type: ignore[reportAssignmentType]\n            encode_func,  # type: ignore[reportArgumentType]\n            inputs,\n            show_progress_bar=False,\n            convert_to_numpy=True,\n            convert_to_tensor=False,\n            device=device,\n            normalize_embeddings=normalize,\n            truncate_dim=dimensions,\n            **{'batch_size': batch_size} if batch_size is not None else {},  # type: ignore[reportArgumentType]\n        )\n        embeddings = np_embeddings.tolist()\n\n        return EmbeddingResult(\n            embeddings=embeddings,\n            inputs=inputs,\n            input_type=input_type,\n            model_name=self.model_name,\n            provider_name=self.system,\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        model = await self._get_model()\n        return model.get_max_seq_length()\n\n    async def count_tokens(self, text: str) -> int:\n        model = await self._get_model()\n        result: dict[str, torch.Tensor] = await _utils.run_in_executor(\n            model.tokenize,  # type: ignore[reportArgumentType]\n            [text],\n        )\n        if 'input_ids' not in result or not isinstance(result['input_ids'], torch.Tensor):  # pragma: no cover\n            raise UnexpectedModelBehavior(\n                'The SentenceTransformers tokenizer output did not have an `input_ids` field holding a tensor',\n                str(result),\n            )\n        return len(result['input_ids'][0])\n\n    async def _get_model(self) -> SentenceTransformer:\n        if self._model is None:\n            # This may download the model from Hugging Face, so we do it in a thread\n            self._model = await _utils.run_in_executor(SentenceTransformer, self.model_name)  # pragma: no cover\n        return self._model\n````\n\n#### __init__\n\n```python\n__init__(\n    model: SentenceTransformer | str,\n    *,\n    settings: EmbeddingSettings | None = None\n) -> None\n```\n\nInitialize a Sentence-Transformers embedding model.\n\nParameters:\n\n| Name       | Type                  | Description | Default                                                                                                                                                    |\n| ---------- | --------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `model`    | \\`SentenceTransformer | str\\`       | The model to use. Can be: A model name from Hugging Face (e.g., 'all-MiniLM-L6-v2') A local path to a saved model An existing SentenceTransformer instance |\n| `settings` | \\`EmbeddingSettings   | None\\`      | Model-specific SentenceTransformersEmbeddingSettings to use as defaults for this model.                                                                    |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/sentence_transformers.py`\n\n```python\ndef __init__(self, model: SentenceTransformer | str, *, settings: EmbeddingSettings | None = None) -> None:\n    \"\"\"Initialize a Sentence-Transformers embedding model.\n\n    Args:\n        model: The model to use. Can be:\n\n            - A model name from Hugging Face (e.g., `'all-MiniLM-L6-v2'`)\n            - A local path to a saved model\n            - An existing `SentenceTransformer` instance\n        settings: Model-specific\n            [`SentenceTransformersEmbeddingSettings`][pydantic_ai.embeddings.sentence_transformers.SentenceTransformersEmbeddingSettings]\n            to use as defaults for this model.\n    \"\"\"\n    if isinstance(model, str):\n        self._model_name = model\n    else:\n        self._model = deepcopy(model)\n        self._model_name = model.model_card_data.model_id or model.model_card_data.base_model or 'unknown'\n\n    super().__init__(settings=settings)\n```\n\n#### base_url\n\n```python\nbase_url: str | None\n```\n\nNo base URL — runs locally.\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider/system identifier.\n\n### TestEmbeddingModel\n\nBases: `EmbeddingModel`\n\nA mock embedding model for testing.\n\nThis model returns deterministic embeddings (all 1.0 values) and tracks the settings used in the last call via the `last_settings` attribute.\n\nExample:\n\n```python\nfrom pydantic_ai import Embedder\nfrom pydantic_ai.embeddings import TestEmbeddingModel\n\ntest_model = TestEmbeddingModel()\nembedder = Embedder('openai:text-embedding-3-small')\n\n\nasync def main():\n    with embedder.override(model=test_model):\n        await embedder.embed_query('test')\n        assert test_model.last_settings is not None\n```\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/test.py`\n\n````python\n@dataclass(init=False)\nclass TestEmbeddingModel(EmbeddingModel):\n    \"\"\"A mock embedding model for testing.\n\n    This model returns deterministic embeddings (all 1.0 values) and tracks\n    the settings used in the last call via the `last_settings` attribute.\n\n    Example:\n    ```python\n    from pydantic_ai import Embedder\n    from pydantic_ai.embeddings import TestEmbeddingModel\n\n    test_model = TestEmbeddingModel()\n    embedder = Embedder('openai:text-embedding-3-small')\n\n\n    async def main():\n        with embedder.override(model=test_model):\n            await embedder.embed_query('test')\n            assert test_model.last_settings is not None\n    ```\n    \"\"\"\n\n    # NOTE: Avoid test discovery by pytest.\n    __test__ = False\n\n    _model_name: str\n    \"\"\"The model name to report in results.\"\"\"\n\n    _provider_name: str\n    \"\"\"The provider name to report in results.\"\"\"\n\n    _dimensions: int\n    \"\"\"The number of dimensions for generated embeddings.\"\"\"\n\n    last_settings: EmbeddingSettings | None = None\n    \"\"\"The settings used in the most recent embed call.\"\"\"\n\n    def __init__(\n        self,\n        model_name: str = 'test',\n        *,\n        provider_name: str = 'test',\n        dimensions: int = 8,\n        settings: EmbeddingSettings | None = None,\n    ):\n        \"\"\"Initialize the test embedding model.\n\n        Args:\n            model_name: The model name to report in results.\n            provider_name: The provider name to report in results.\n            dimensions: The number of dimensions for the generated embeddings.\n            settings: Optional default settings for the model.\n        \"\"\"\n        self._model_name = model_name\n        self._provider_name = provider_name\n        self._dimensions = dimensions\n        self.last_settings = None\n        super().__init__(settings=settings)\n\n    @property\n    def model_name(self) -> str:\n        \"\"\"The embedding model name.\"\"\"\n        return self._model_name\n\n    @property\n    def system(self) -> str:\n        \"\"\"The embedding model provider.\"\"\"\n        return self._provider_name\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        self.last_settings = settings\n\n        dimensions = settings.get('dimensions') or self._dimensions\n\n        return EmbeddingResult(\n            embeddings=[[1.0] * dimensions] * len(inputs),\n            inputs=inputs,\n            input_type=input_type,\n            usage=RequestUsage(input_tokens=sum(_estimate_tokens(text) for text in inputs)),\n            model_name=self.model_name,\n            provider_name=self.system,\n            provider_response_id=str(uuid.uuid4()),\n        )\n\n    async def max_input_tokens(self) -> int | None:\n        return 1024\n\n    async def count_tokens(self, text: str) -> int:\n        return _estimate_tokens(text)\n````\n\n#### __init__\n\n```python\n__init__(\n    model_name: str = \"test\",\n    *,\n    provider_name: str = \"test\",\n    dimensions: int = 8,\n    settings: EmbeddingSettings | None = None\n)\n```\n\nInitialize the test embedding model.\n\nParameters:\n\n| Name            | Type                | Description                                            | Default                                  |\n| --------------- | ------------------- | ------------------------------------------------------ | ---------------------------------------- |\n| `model_name`    | `str`               | The model name to report in results.                   | `'test'`                                 |\n| `provider_name` | `str`               | The provider name to report in results.                | `'test'`                                 |\n| `dimensions`    | `int`               | The number of dimensions for the generated embeddings. | `8`                                      |\n| `settings`      | \\`EmbeddingSettings | None\\`                                                 | Optional default settings for the model. |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/test.py`\n\n```python\ndef __init__(\n    self,\n    model_name: str = 'test',\n    *,\n    provider_name: str = 'test',\n    dimensions: int = 8,\n    settings: EmbeddingSettings | None = None,\n):\n    \"\"\"Initialize the test embedding model.\n\n    Args:\n        model_name: The model name to report in results.\n        provider_name: The provider name to report in results.\n        dimensions: The number of dimensions for the generated embeddings.\n        settings: Optional default settings for the model.\n    \"\"\"\n    self._model_name = model_name\n    self._provider_name = provider_name\n    self._dimensions = dimensions\n    self.last_settings = None\n    super().__init__(settings=settings)\n```\n\n#### last_settings\n\n```python\nlast_settings: EmbeddingSettings | None = None\n```\n\nThe settings used in the most recent embed call.\n\n#### model_name\n\n```python\nmodel_name: str\n```\n\nThe embedding model name.\n\n#### system\n\n```python\nsystem: str\n```\n\nThe embedding model provider.\n\n### WrapperEmbeddingModel\n\nBases: `EmbeddingModel`\n\nBase class for embedding models that wrap another model.\n\nUse this as a base class to create custom embedding model wrappers that modify behavior (e.g., caching, logging, rate limiting) while delegating to an underlying model.\n\nBy default, all methods are passed through to the wrapped model. Override specific methods to customize behavior.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/wrapper.py`\n\n```python\n@dataclass(init=False)\nclass WrapperEmbeddingModel(EmbeddingModel):\n    \"\"\"Base class for embedding models that wrap another model.\n\n    Use this as a base class to create custom embedding model wrappers\n    that modify behavior (e.g., caching, logging, rate limiting) while\n    delegating to an underlying model.\n\n    By default, all methods are passed through to the wrapped model.\n    Override specific methods to customize behavior.\n    \"\"\"\n\n    wrapped: EmbeddingModel\n    \"\"\"The underlying embedding model being wrapped.\"\"\"\n\n    def __init__(self, wrapped: EmbeddingModel | str):\n        \"\"\"Initialize the wrapper with an embedding model.\n\n        Args:\n            wrapped: The model to wrap. Can be an\n                [`EmbeddingModel`][pydantic_ai.embeddings.EmbeddingModel] instance\n                or a model name string (e.g., `'openai:text-embedding-3-small'`).\n        \"\"\"\n        from . import infer_embedding_model\n\n        super().__init__()\n        self.wrapped = infer_embedding_model(wrapped) if isinstance(wrapped, str) else wrapped\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        return await self.wrapped.embed(inputs, input_type=input_type, settings=settings)\n\n    async def max_input_tokens(self) -> int | None:\n        return await self.wrapped.max_input_tokens()\n\n    async def count_tokens(self, text: str) -> int:\n        return await self.wrapped.count_tokens(text)\n\n    @property\n    def model_name(self) -> str:\n        return self.wrapped.model_name\n\n    @property\n    def system(self) -> str:\n        return self.wrapped.system\n\n    @property\n    def settings(self) -> EmbeddingSettings | None:\n        \"\"\"Get the settings from the wrapped embedding model.\"\"\"\n        return self.wrapped.settings\n\n    @property\n    def base_url(self) -> str | None:\n        return self.wrapped.base_url\n\n    def __getattr__(self, item: str):\n        return getattr(self.wrapped, item)  # pragma: no cover\n```\n\n#### __init__\n\n```python\n__init__(wrapped: EmbeddingModel | str)\n```\n\nInitialize the wrapper with an embedding model.\n\nParameters:\n\n| Name      | Type             | Description | Default                                                                                                              |\n| --------- | ---------------- | ----------- | -------------------------------------------------------------------------------------------------------------------- |\n| `wrapped` | \\`EmbeddingModel | str\\`       | The model to wrap. Can be an EmbeddingModel instance or a model name string (e.g., 'openai:text-embedding-3-small'). |\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/wrapper.py`\n\n```python\ndef __init__(self, wrapped: EmbeddingModel | str):\n    \"\"\"Initialize the wrapper with an embedding model.\n\n    Args:\n        wrapped: The model to wrap. Can be an\n            [`EmbeddingModel`][pydantic_ai.embeddings.EmbeddingModel] instance\n            or a model name string (e.g., `'openai:text-embedding-3-small'`).\n    \"\"\"\n    from . import infer_embedding_model\n\n    super().__init__()\n    self.wrapped = infer_embedding_model(wrapped) if isinstance(wrapped, str) else wrapped\n```\n\n#### wrapped\n\n```python\nwrapped: EmbeddingModel = (\n    infer_embedding_model(wrapped)\n    if isinstance(wrapped, str)\n    else wrapped\n)\n```\n\nThe underlying embedding model being wrapped.\n\n#### settings\n\n```python\nsettings: EmbeddingSettings | None\n```\n\nGet the settings from the wrapped embedding model.\n\n### instrument_embedding_model\n\n```python\ninstrument_embedding_model(\n    model: EmbeddingModel,\n    instrument: InstrumentationSettings | bool,\n) -> EmbeddingModel\n```\n\nInstrument an embedding model with OpenTelemetry/logfire.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/instrumented.py`\n\n```python\ndef instrument_embedding_model(model: EmbeddingModel, instrument: InstrumentationSettings | bool) -> EmbeddingModel:\n    \"\"\"Instrument an embedding model with OpenTelemetry/logfire.\"\"\"\n    if instrument and not isinstance(model, InstrumentedEmbeddingModel):\n        if instrument is True:\n            instrument = InstrumentationSettings()\n\n        model = InstrumentedEmbeddingModel(model, instrument)\n\n    return model\n```\n\n### InstrumentedEmbeddingModel\n\nBases: `WrapperEmbeddingModel`\n\nEmbedding model which wraps another model so that requests are instrumented with OpenTelemetry.\n\nSee the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.\n\nSource code in `pydantic_ai_slim/pydantic_ai/embeddings/instrumented.py`\n\n```python\n@dataclass(init=False)\nclass InstrumentedEmbeddingModel(WrapperEmbeddingModel):\n    \"\"\"Embedding model which wraps another model so that requests are instrumented with OpenTelemetry.\n\n    See the [Debugging and Monitoring guide](https://ai.pydantic.dev/logfire/) for more info.\n    \"\"\"\n\n    instrumentation_settings: InstrumentationSettings\n    \"\"\"Instrumentation settings for this model.\"\"\"\n\n    def __init__(\n        self,\n        wrapped: EmbeddingModel | str,\n        options: InstrumentationSettings | None = None,\n    ) -> None:\n        super().__init__(wrapped)\n        self.instrumentation_settings = options or InstrumentationSettings()\n\n    async def embed(\n        self, inputs: str | Sequence[str], *, input_type: EmbedInputType, settings: EmbeddingSettings | None = None\n    ) -> EmbeddingResult:\n        inputs, settings = self.prepare_embed(inputs, settings)\n        with self._instrument(inputs, input_type, settings) as finish:\n            result = await super().embed(inputs, input_type=input_type, settings=settings)\n            finish(result)\n            return result\n\n    @contextmanager\n    def _instrument(\n        self,\n        inputs: list[str],\n        input_type: EmbedInputType,\n        settings: EmbeddingSettings | None,\n    ) -> Iterator[Callable[[EmbeddingResult], None]]:\n        operation = 'embeddings'\n        span_name = f'{operation} {self.model_name}'\n\n        inputs_count = len(inputs)\n\n        attributes: dict[str, AttributeValue] = {\n            'gen_ai.operation.name': operation,\n            **self.model_attributes(self.wrapped),\n            'input_type': input_type,\n            'inputs_count': inputs_count,\n        }\n\n        if settings:\n            attributes['embedding_settings'] = json.dumps(self.serialize_any(settings))\n\n        if self.instrumentation_settings.include_content:\n            attributes['inputs'] = json.dumps(inputs)\n\n        attributes['logfire.json_schema'] = json.dumps(\n            {\n                'type': 'object',\n                'properties': {\n                    'input_type': {'type': 'string'},\n                    'inputs_count': {'type': 'integer'},\n                    'embedding_settings': {'type': 'object'},\n                    **(\n                        {'inputs': {'type': ['array']}, 'embeddings': {'type': 'array'}}\n                        if self.instrumentation_settings.include_content\n                        else {}\n                    ),\n                },\n            }\n        )\n\n        record_metrics: Callable[[], None] | None = None\n        try:\n            with self.instrumentation_settings.tracer.start_as_current_span(span_name, attributes=attributes) as span:\n\n                def finish(result: EmbeddingResult):\n                    # Prepare metric recording closure first so metrics are recorded\n                    # even if the span is not recording.\n                    provider_name = attributes[GEN_AI_PROVIDER_NAME_ATTRIBUTE]\n                    request_model = attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE]\n                    response_model = result.model_name or request_model\n                    price_calculation = None\n\n                    def _record_metrics():\n                        token_attributes = {\n                            GEN_AI_PROVIDER_NAME_ATTRIBUTE: provider_name,\n                            'gen_ai.operation.name': operation,\n                            GEN_AI_REQUEST_MODEL_ATTRIBUTE: request_model,\n                            'gen_ai.response.model': response_model,\n                            'gen_ai.token.type': 'input',\n                        }\n                        tokens = result.usage.input_tokens or 0\n                        if tokens:  # pragma: no branch\n                            self.instrumentation_settings.tokens_histogram.record(tokens, token_attributes)\n                            if price_calculation is not None:\n                                self.instrumentation_settings.cost_histogram.record(\n                                    float(getattr(price_calculation, 'input_price', 0.0)),\n                                    token_attributes,\n                                )\n\n                    nonlocal record_metrics\n                    record_metrics = _record_metrics\n\n                    if not span.is_recording():\n                        return  # pragma: lax no cover\n\n                    attributes_to_set: dict[str, AttributeValue] = {\n                        **result.usage.opentelemetry_attributes(),\n                        'gen_ai.response.model': response_model,\n                    }\n\n                    try:\n                        price_calculation = result.cost()\n                    except LookupError:\n                        # The cost of this provider/model is unknown, which is common.\n                        pass\n                    except Exception as e:  # pragma: no cover\n                        warnings.warn(\n                            f'Failed to get cost from response: {type(e).__name__}: {e}', CostCalculationFailedWarning\n                        )\n                    else:\n                        attributes_to_set['operation.cost'] = float(price_calculation.total_price)\n\n                    embeddings = result.embeddings\n                    if embeddings:  # pragma: no branch\n                        attributes_to_set['gen_ai.embeddings.dimension.count'] = len(embeddings[0])\n                        if self.instrumentation_settings.include_content:\n                            attributes['embeddings'] = json.dumps(embeddings)\n\n                    if result.provider_response_id is not None:\n                        attributes_to_set['gen_ai.response.id'] = result.provider_response_id\n\n                    span.set_attributes(attributes_to_set)\n\n                yield finish\n        finally:\n            if record_metrics:  # pragma: no branch\n                # Record metrics after the span finishes to avoid duplication.\n                record_metrics()\n\n    @staticmethod\n    def model_attributes(model: EmbeddingModel) -> dict[str, AttributeValue]:\n        attributes: dict[str, AttributeValue] = {\n            GEN_AI_PROVIDER_NAME_ATTRIBUTE: model.system,\n            GEN_AI_REQUEST_MODEL_ATTRIBUTE: model.model_name,\n        }\n        if base_url := model.base_url:\n            try:\n                parsed = urlparse(base_url)\n            except Exception:  # pragma: no cover\n                pass\n            else:\n                if parsed.hostname:  # pragma: no branch\n                    attributes['server.address'] = parsed.hostname\n                if parsed.port:\n                    attributes['server.port'] = parsed.port  # pragma: no cover\n\n        return attributes\n\n    @staticmethod\n    def serialize_any(value: Any) -> str:\n        try:\n            return ANY_ADAPTER.dump_python(value, mode='json')\n        except Exception:  # pragma: no cover\n            try:\n                return str(value)\n            except Exception as e:\n                return f'Unable to serialize: {e}'\n```\n\n#### instrumentation_settings\n\n```python\ninstrumentation_settings: InstrumentationSettings = (\n    options or InstrumentationSettings()\n)\n```\n\nInstrumentation settings for this model.\n"}}}}