deepset-ai--haystack/docs-website/reference/haystack-api/embedders_api.md

---
title: "Embedders"
id: embedders-api
description: "Transforms queries into vectors to look for similar or relevant Documents."
slug: "/embedders-api"
---


## azure_document_embedder

### AzureOpenAIDocumentEmbedder

Bases: <code>OpenAIDocumentEmbedder</code>

Calculates document embeddings using OpenAI models deployed on Azure.

### Usage example

<!-- test-ignore -->

```python
from haystack import Document
from haystack.components.embedders import AzureOpenAIDocumentEmbedder

doc = Document(content="I love pizza!")
document_embedder = AzureOpenAIDocumentEmbedder()

result = document_embedder.run([doc])
print(result['documents'][0].embedding)

# [0.017020374536514282, -0.023255806416273117, ...]
```

#### __init__

```python
__init__(
    azure_endpoint: str | None = None,
    api_version: str | None = "2023-05-15",
    azure_deployment: str = "text-embedding-ada-002",
    dimensions: int | None = None,
    api_key: Secret | None = Secret.from_env_var(
        "AZURE_OPENAI_API_KEY", strict=False
    ),
    azure_ad_token: Secret | None = Secret.from_env_var(
        "AZURE_OPENAI_AD_TOKEN", strict=False
    ),
    organization: str | None = None,
    prefix: str = "",
    suffix: str = "",
    batch_size: int = 32,
    progress_bar: bool = True,
    meta_fields_to_embed: list[str] | None = None,
    embedding_separator: str = "\n",
    timeout: float | None = None,
    max_retries: int | None = None,
    *,
    default_headers: dict[str, str] | None = None,
    azure_ad_token_provider: AzureADTokenProvider | None = None,
    http_client_kwargs: dict[str, Any] | None = None,
    raise_on_failure: bool = False
) -> None
```

Creates an AzureOpenAIDocumentEmbedder component.

**Parameters:**

- **azure_endpoint** (<code>str | None</code>) – The endpoint of the model deployed on Azure.
- **api_version** (<code>str | None</code>) – The version of the API to use.
- **azure_deployment** (<code>str</code>) – The name of the model deployed on Azure. The default model is text-embedding-ada-002.
- **dimensions** (<code>int | None</code>) – The number of dimensions of the resulting embeddings. Only supported in text-embedding-3
  and later models.
- **api_key** (<code>Secret | None</code>) – The Azure OpenAI API key.
  You can set it with an environment variable `AZURE_OPENAI_API_KEY`, or pass with this
  parameter during initialization.
- **azure_ad_token** (<code>Secret | None</code>) – Microsoft Entra ID token, see Microsoft's
  [Entra ID](https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id)
  documentation for more information. You can set it with an environment variable
  `AZURE_OPENAI_AD_TOKEN`, or pass with this parameter during initialization.
  Previously called Azure Active Directory.
- **organization** (<code>str | None</code>) – Your organization ID. See OpenAI's
  [Setting Up Your Organization](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization)
  for more information.
- **prefix** (<code>str</code>) – A string to add at the beginning of each text.
- **suffix** (<code>str</code>) – A string to add at the end of each text.
- **batch_size** (<code>int</code>) – Number of documents to embed at once.
- **progress_bar** (<code>bool</code>) – If `True`, shows a progress bar when running.
- **meta_fields_to_embed** (<code>list\[str\] | None</code>) – List of metadata fields to embed along with the document text.
- **embedding_separator** (<code>str</code>) – Separator used to concatenate the metadata fields to the document text.
- **timeout** (<code>float | None</code>) – The timeout for `AzureOpenAI` client calls, in seconds.
  If not set, defaults to either the
  `OPENAI_TIMEOUT` environment variable, or 30 seconds.
- **max_retries** (<code>int | None</code>) – Maximum number of retries to contact AzureOpenAI after an internal error.
  If not set, defaults to either the `OPENAI_MAX_RETRIES` environment variable or to 5 retries.
- **default_headers** (<code>dict\[str, str\] | None</code>) – Default headers to send to the AzureOpenAI client.
- **azure_ad_token_provider** (<code>AzureADTokenProvider | None</code>) – A function that returns an Azure Active Directory token, will be invoked on
  every request.
- **http_client_kwargs** (<code>dict\[str, Any\] | None</code>) – A dictionary of keyword arguments to configure a custom `httpx.Client`or `httpx.AsyncClient`.
  For more information, see the [HTTPX documentation](https://www.python-httpx.org/api/#client).
- **raise_on_failure** (<code>bool</code>) – Whether to raise an exception if the embedding request fails. If `False`, the component will log the error
  and continue processing the remaining documents. If `True`, it will raise an exception on failure.

#### warm_up

```python
warm_up() -> None
```

Initializes the synchronous AzureOpenAI client.

#### warm_up_async

```python
warm_up_async() -> None
```

Initializes the asynchronous AzureOpenAI client on the serving event loop.

#### close

```python
close() -> None
```

Releases the synchronous AzureOpenAI client.

#### close_async

```python
close_async() -> None
```

Releases the asynchronous AzureOpenAI client.

#### to_dict

```python
to_dict() -> dict[str, Any]
```

Serializes the component to a dictionary.

**Returns:**

- <code>dict\[str, Any\]</code> – Dictionary with serialized data.

#### from_dict

```python
from_dict(data: dict[str, Any]) -> AzureOpenAIDocumentEmbedder
```

Deserializes the component from a dictionary.

**Parameters:**

- **data** (<code>dict\[str, Any\]</code>) – Dictionary to deserialize from.

**Returns:**

- <code>AzureOpenAIDocumentEmbedder</code> – Deserialized component.

## azure_text_embedder

### AzureOpenAITextEmbedder

Bases: <code>OpenAITextEmbedder</code>

Embeds strings using OpenAI models deployed on Azure.

### Usage example

<!-- test-ignore -->

```python
from haystack.components.embedders import AzureOpenAITextEmbedder

text_to_embed = "I love pizza!"
text_embedder = AzureOpenAITextEmbedder()

print(text_embedder.run(text_to_embed))

# {'embedding': [0.017020374536514282, -0.023255806416273117, ...],
# 'meta': {'model': 'text-embedding-ada-002-v2',
#          'usage': {'prompt_tokens': 4, 'total_tokens': 4}}}
```

#### __init__

```python
__init__(
    azure_endpoint: str | None = None,
    api_version: str | None = "2023-05-15",
    azure_deployment: str = "text-embedding-ada-002",
    dimensions: int | None = None,
    api_key: Secret | None = Secret.from_env_var(
        "AZURE_OPENAI_API_KEY", strict=False
    ),
    azure_ad_token: Secret | None = Secret.from_env_var(
        "AZURE_OPENAI_AD_TOKEN", strict=False
    ),
    organization: str | None = None,
    timeout: float | None = None,
    max_retries: int | None = None,
    prefix: str = "",
    suffix: str = "",
    *,
    default_headers: dict[str, str] | None = None,
    azure_ad_token_provider: AzureADTokenProvider | None = None,
    http_client_kwargs: dict[str, Any] | None = None
) -> None
```

Creates an AzureOpenAITextEmbedder component.

**Parameters:**

- **azure_endpoint** (<code>str | None</code>) – The endpoint of the model deployed on Azure.
- **api_version** (<code>str | None</code>) – The version of the API to use.
- **azure_deployment** (<code>str</code>) – The name of the model deployed on Azure. The default model is text-embedding-ada-002.
- **dimensions** (<code>int | None</code>) – The number of dimensions the resulting output embeddings should have. Only supported in text-embedding-3
  and later models.
- **api_key** (<code>Secret | None</code>) – The Azure OpenAI API key.
  You can set it with an environment variable `AZURE_OPENAI_API_KEY`, or pass with this
  parameter during initialization.
- **azure_ad_token** (<code>Secret | None</code>) – Microsoft Entra ID token, see Microsoft's
  [Entra ID](https://www.microsoft.com/en-us/security/business/identity-access/microsoft-entra-id)
  documentation for more information. You can set it with an environment variable
  `AZURE_OPENAI_AD_TOKEN`, or pass with this parameter during initialization.
  Previously called Azure Active Directory.
- **organization** (<code>str | None</code>) – Your organization ID. See OpenAI's
  [Setting Up Your Organization](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization)
  for more information.
- **timeout** (<code>float | None</code>) – The timeout for `AzureOpenAI` client calls, in seconds.
  If not set, defaults to either the
  `OPENAI_TIMEOUT` environment variable, or 30 seconds.
- **max_retries** (<code>int | None</code>) – Maximum number of retries to contact AzureOpenAI after an internal error.
  If not set, defaults to either the `OPENAI_MAX_RETRIES` environment variable, or to 5 retries.
- **prefix** (<code>str</code>) – A string to add at the beginning of each text.
- **suffix** (<code>str</code>) – A string to add at the end of each text.
- **default_headers** (<code>dict\[str, str\] | None</code>) – Default headers to send to the AzureOpenAI client.
- **azure_ad_token_provider** (<code>AzureADTokenProvider | None</code>) – A function that returns an Azure Active Directory token, will be invoked on
  every request.
- **http_client_kwargs** (<code>dict\[str, Any\] | None</code>) – A dictionary of keyword arguments to configure a custom `httpx.Client`or `httpx.AsyncClient`.
  For more information, see the [HTTPX documentation](https://www.python-httpx.org/api/#client).

#### warm_up

```python
warm_up() -> None
```

Initializes the synchronous Azure OpenAI client.

#### warm_up_async

```python
warm_up_async() -> None
```

Initializes the asynchronous Azure OpenAI client on the serving event loop.

#### close

```python
close() -> None
```

Releases the synchronous Azure OpenAI client.

#### close_async

```python
close_async() -> None
```

Releases the asynchronous Azure OpenAI client.

#### to_dict

```python
to_dict() -> dict[str, Any]
```

Serializes the component to a dictionary.

**Returns:**

- <code>dict\[str, Any\]</code> – Dictionary with serialized data.

#### from_dict

```python
from_dict(data: dict[str, Any]) -> AzureOpenAITextEmbedder
```

Deserializes the component from a dictionary.

**Parameters:**

- **data** (<code>dict\[str, Any\]</code>) – Dictionary to deserialize from.

**Returns:**

- <code>AzureOpenAITextEmbedder</code> – Deserialized component.

## mock_document_embedder

### MockDocumentEmbedder

A Document Embedder that returns deterministic embeddings without calling any API.

It is a drop-in replacement for real Document Embedders (such as `OpenAIDocumentEmbedder`) in tests, smoke tests,
and quick prototypes. It implements the same interface (`run`, `run_async`, serialization) but never contacts an
external service, so it is fully deterministic and free to run.

The embedding is selected based on how the component is configured:

- **Deterministic (default)**: with no configuration, each document's embedding is derived from a hash of its
  (prepared) text. The same text always yields the same embedding, and different texts yield different
  embeddings, so the mock works in retrieval pipelines and is reproducible across runs and processes.
- **Fixed embedding**: pass an `embedding` vector. The same vector is assigned to every document.
- **Dynamic embedding**: pass an `embedding_fn` callable that receives the (prepared) text of a document and
  returns the embedding. This is useful when the embedding should depend on the input in a custom way.

Like real Document Embedders, the metadata fields listed in `meta_fields_to_embed` are concatenated with the
document content before embedding, so the deterministic embedding reflects the embedded metadata.

### Usage example

```python
from haystack import Document
from haystack.components.embedders import MockDocumentEmbedder

embedder = MockDocumentEmbedder(dimension=8)
result = embedder.run([Document(content="I love pizza!")])
print(result["documents"][0].embedding)  # a deterministic list of 8 floats
```

#### __init__

```python
__init__(
    embedding: list[float] | None = None,
    *,
    embedding_fn: EmbeddingFn | None = None,
    dimension: int = 768,
    model: str = "mock-model",
    meta: dict[str, Any] | None = None,
    prefix: str = "",
    suffix: str = "",
    meta_fields_to_embed: list[str] | None = None,
    embedding_separator: str = "\n",
    progress_bar: bool = False
) -> None
```

Creates an instance of MockDocumentEmbedder.

**Parameters:**

- **embedding** (<code>list\[float\] | None</code>) – An optional fixed embedding assigned to every document. Mutually exclusive with
  `embedding_fn`. If neither is provided, a deterministic embedding is derived from each document's text.
- **embedding_fn** (<code>EmbeddingFn | None</code>) – An optional callable that receives the prepared text of a document and returns the
  embedding as a list of floats. Mutually exclusive with `embedding`. To support serialization, pass a
  named function (lambdas and nested functions cannot be serialized).
- **dimension** (<code>int</code>) – The number of dimensions of the deterministic embedding. Ignored when `embedding` or
  `embedding_fn` is provided, since their length is determined by the value or callable.
- **model** (<code>str</code>) – The model name reported in the metadata. Purely cosmetic; no model is loaded.
- **meta** (<code>dict\[str, Any\] | None</code>) – Additional metadata merged into the output `meta`.
- **prefix** (<code>str</code>) – A string to add at the beginning of each text before embedding.
- **suffix** (<code>str</code>) – A string to add at the end of each text before embedding.
- **meta_fields_to_embed** (<code>list\[str\] | None</code>) – List of metadata fields to embed along with the document text.
- **embedding_separator** (<code>str</code>) – Separator used to concatenate the metadata fields to the document text.
- **progress_bar** (<code>bool</code>) – Accepted for interface compatibility with real Document Embedders and ignored.

**Raises:**

- <code>ValueError</code> – If both `embedding` and `embedding_fn` are provided, if `dimension` is not positive, or
  if `embedding` is an empty list.
- <code>TypeError</code> – If `embedding` is not a sequence of numbers.

#### to_dict

```python
to_dict() -> dict[str, Any]
```

Serialize the component to a dictionary.

#### from_dict

```python
from_dict(data: dict[str, Any]) -> MockDocumentEmbedder
```

Deserialize the component from a dictionary.

#### warm_up

```python
warm_up() -> None
```

No-op warm up, provided for interface compatibility with real Embedders.

#### run

```python
run(documents: list[Document]) -> dict[str, Any]
```

Return the input documents with deterministic embeddings added, without calling any API.

**Parameters:**

- **documents** (<code>list\[Document\]</code>) – A list of documents to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `documents`: A list of documents with embeddings.
- `meta`: Metadata about the (mock) model.

**Raises:**

- <code>TypeError</code> – If `documents` is not a list of `Document` objects.

#### run_async

```python
run_async(documents: list[Document]) -> dict[str, Any]
```

Asynchronously return the input documents with deterministic embeddings added, without calling any API.

**Parameters:**

- **documents** (<code>list\[Document\]</code>) – A list of documents to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `documents`: A list of documents with embeddings.
- `meta`: Metadata about the (mock) model.

**Raises:**

- <code>TypeError</code> – If `documents` is not a list of `Document` objects.

## mock_text_embedder

### MockTextEmbedder

A Text Embedder that returns deterministic embeddings without calling any API.

It is a drop-in replacement for real Text Embedders (such as `OpenAITextEmbedder`) in tests, smoke tests, and
quick prototypes. It implements the same interface (`run`, `run_async`, serialization) but never contacts an
external service, so it is fully deterministic and free to run.

The embedding is selected based on how the component is configured:

- **Deterministic (default)**: with no configuration, the embedding is derived from a hash of the input text.
  The same text always yields the same embedding, and different texts yield different embeddings, so the mock
  works in retrieval pipelines and is reproducible across runs and processes.
- **Fixed embedding**: pass an `embedding` vector. The same vector is returned for every input.
- **Dynamic embedding**: pass an `embedding_fn` callable that receives the (prepared) text and returns the
  embedding. This is useful when the embedding should depend on the input in a custom way.

### Usage example

```python
from haystack.components.embedders import MockTextEmbedder

embedder = MockTextEmbedder(dimension=8)
result = embedder.run("I love pizza!")
print(result["embedding"])  # a deterministic list of 8 floats
```

#### __init__

```python
__init__(
    embedding: list[float] | None = None,
    *,
    embedding_fn: EmbeddingFn | None = None,
    dimension: int = 768,
    model: str = "mock-model",
    meta: dict[str, Any] | None = None,
    prefix: str = "",
    suffix: str = ""
) -> None
```

Creates an instance of MockTextEmbedder.

**Parameters:**

- **embedding** (<code>list\[float\] | None</code>) – An optional fixed embedding returned for every input. Mutually exclusive with
  `embedding_fn`. If neither is provided, a deterministic embedding is derived from the input text.
- **embedding_fn** (<code>EmbeddingFn | None</code>) – An optional callable that receives the prepared text (after `prefix`/`suffix` are
  applied) and returns the embedding as a list of floats. Mutually exclusive with `embedding`. To support
  serialization, pass a named function (lambdas and nested functions cannot be serialized).
- **dimension** (<code>int</code>) – The number of dimensions of the deterministic embedding. Ignored when `embedding` or
  `embedding_fn` is provided, since their length is determined by the value or callable.
- **model** (<code>str</code>) – The model name reported in the metadata. Purely cosmetic; no model is loaded.
- **meta** (<code>dict\[str, Any\] | None</code>) – Additional metadata merged into the output `meta`.
- **prefix** (<code>str</code>) – A string to add at the beginning of the text before embedding.
- **suffix** (<code>str</code>) – A string to add at the end of the text before embedding.

**Raises:**

- <code>ValueError</code> – If both `embedding` and `embedding_fn` are provided, if `dimension` is not positive, or
  if `embedding` is an empty list.
- <code>TypeError</code> – If `embedding` is not a sequence of numbers.

#### to_dict

```python
to_dict() -> dict[str, Any]
```

Serialize the component to a dictionary.

#### from_dict

```python
from_dict(data: dict[str, Any]) -> MockTextEmbedder
```

Deserialize the component from a dictionary.

#### warm_up

```python
warm_up() -> None
```

No-op warm up, provided for interface compatibility with real Embedders.

#### run

```python
run(text: str) -> dict[str, Any]
```

Return a deterministic embedding for the input text without calling any API.

**Parameters:**

- **text** (<code>str</code>) – The text to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `embedding`: The embedding of the input text.
- `meta`: Metadata about the (mock) model.

**Raises:**

- <code>TypeError</code> – If `text` is not a string.

#### run_async

```python
run_async(text: str) -> dict[str, Any]
```

Asynchronously return a deterministic embedding for the input text without calling any API.

**Parameters:**

- **text** (<code>str</code>) – The text to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `embedding`: The embedding of the input text.
- `meta`: Metadata about the (mock) model.

**Raises:**

- <code>TypeError</code> – If `text` is not a string.

## openai_document_embedder

### OpenAIDocumentEmbedder

Computes document embeddings using OpenAI models.

### Usage example

<!-- test-ignore -->

```python
from haystack import Document
from haystack.components.embedders import OpenAIDocumentEmbedder

doc = Document(content="I love pizza!")
document_embedder = OpenAIDocumentEmbedder()
result = document_embedder.run([doc])

print(result['documents'][0].embedding)

# [0.017020374536514282, -0.023255806416273117, ...]
```

#### __init__

```python
__init__(
    api_key: Secret = Secret.from_env_var("OPENAI_API_KEY"),
    model: str = "text-embedding-ada-002",
    dimensions: int | None = None,
    api_base_url: str | None = None,
    organization: str | None = None,
    prefix: str = "",
    suffix: str = "",
    batch_size: int = 32,
    progress_bar: bool = True,
    meta_fields_to_embed: list[str] | None = None,
    embedding_separator: str = "\n",
    timeout: float | None = None,
    max_retries: int | None = None,
    http_client_kwargs: dict[str, Any] | None = None,
    *,
    raise_on_failure: bool = False
) -> None
```

Creates an OpenAIDocumentEmbedder component.

Before initializing the component, you can set the 'OPENAI_TIMEOUT' and 'OPENAI_MAX_RETRIES'
environment variables to override the `timeout` and `max_retries` parameters respectively
in the OpenAI client.

**Parameters:**

- **api_key** (<code>Secret</code>) – The OpenAI API key.
  You can set it with an environment variable `OPENAI_API_KEY`, or pass with this parameter
  during initialization.
- **model** (<code>str</code>) – The name of the model to use for calculating embeddings.
  The default model is `text-embedding-ada-002`.
- **dimensions** (<code>int | None</code>) – The number of dimensions of the resulting embeddings. Only `text-embedding-3` and
  later models support this parameter.
- **api_base_url** (<code>str | None</code>) – Overrides the default base URL for all HTTP requests.
- **organization** (<code>str | None</code>) – Your OpenAI organization ID. See OpenAI's
  [Setting Up Your Organization](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization)
  for more information.
- **prefix** (<code>str</code>) – A string to add at the beginning of each text.
- **suffix** (<code>str</code>) – A string to add at the end of each text.
- **batch_size** (<code>int</code>) – Number of documents to embed at once.
- **progress_bar** (<code>bool</code>) – If `True`, shows a progress bar when running.
- **meta_fields_to_embed** (<code>list\[str\] | None</code>) – List of metadata fields to embed along with the document text.
- **embedding_separator** (<code>str</code>) – Separator used to concatenate the metadata fields to the document text.
- **timeout** (<code>float | None</code>) – Timeout for OpenAI client calls. If not set, it defaults to either the
  `OPENAI_TIMEOUT` environment variable, or 30 seconds.
- **max_retries** (<code>int | None</code>) – Maximum number of retries to contact OpenAI after an internal error.
  If not set, it defaults to either the `OPENAI_MAX_RETRIES` environment variable, or 5 retries.
- **http_client_kwargs** (<code>dict\[str, Any\] | None</code>) – A dictionary of keyword arguments to configure a custom `httpx.Client`or `httpx.AsyncClient`.
  For more information, see the [HTTPX documentation](https://www.python-httpx.org/api/#client).
- **raise_on_failure** (<code>bool</code>) – Whether to raise an exception if the embedding request fails. If `False`, the component will log the error
  and continue processing the remaining documents. If `True`, it will raise an exception on failure.

#### warm_up

```python
warm_up() -> None
```

Initializes the synchronous OpenAI client.

#### warm_up_async

```python
warm_up_async() -> None
```

Initializes the asynchronous OpenAI client on the serving event loop.

#### close

```python
close() -> None
```

Releases the synchronous OpenAI client.

#### close_async

```python
close_async() -> None
```

Releases the asynchronous OpenAI client.

#### to_dict

```python
to_dict() -> dict[str, Any]
```

Serializes the component to a dictionary.

**Returns:**

- <code>dict\[str, Any\]</code> – Dictionary with serialized data.

#### from_dict

```python
from_dict(data: dict[str, Any]) -> OpenAIDocumentEmbedder
```

Deserializes the component from a dictionary.

**Parameters:**

- **data** (<code>dict\[str, Any\]</code>) – Dictionary to deserialize from.

**Returns:**

- <code>OpenAIDocumentEmbedder</code> – Deserialized component.

#### run

```python
run(documents: list[Document]) -> dict[str, Any]
```

Embeds a list of documents.

**Parameters:**

- **documents** (<code>list\[Document\]</code>) – A list of documents to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `documents`: A list of documents with embeddings.
- `meta`: Information about the usage of the model.

#### run_async

```python
run_async(documents: list[Document]) -> dict[str, Any]
```

Embeds a list of documents asynchronously.

**Parameters:**

- **documents** (<code>list\[Document\]</code>) – A list of documents to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `documents`: A list of documents with embeddings.
- `meta`: Information about the usage of the model.

## openai_text_embedder

### OpenAITextEmbedder

Embeds strings using OpenAI models.

You can use it to embed user query and send it to an embedding Retriever.

### Usage example

<!-- test-ignore -->

```python
from haystack.components.embedders import OpenAITextEmbedder

text_to_embed = "I love pizza!"
text_embedder = OpenAITextEmbedder()

print(text_embedder.run(text_to_embed))

# {'embedding': [0.017020374536514282, -0.023255806416273117, ...],
# 'meta': {'model': 'text-embedding-ada-002-v2',
#          'usage': {'prompt_tokens': 4, 'total_tokens': 4}}}
```

#### __init__

```python
__init__(
    api_key: Secret = Secret.from_env_var("OPENAI_API_KEY"),
    model: str = "text-embedding-ada-002",
    dimensions: int | None = None,
    api_base_url: str | None = None,
    organization: str | None = None,
    prefix: str = "",
    suffix: str = "",
    timeout: float | None = None,
    max_retries: int | None = None,
    http_client_kwargs: dict[str, Any] | None = None,
) -> None
```

Creates an OpenAITextEmbedder component.

Before initializing the component, you can set the 'OPENAI_TIMEOUT' and 'OPENAI_MAX_RETRIES'
environment variables to override the `timeout` and `max_retries` parameters respectively
in the OpenAI client.

**Parameters:**

- **api_key** (<code>Secret</code>) – The OpenAI API key.
  You can set it with an environment variable `OPENAI_API_KEY`, or pass with this parameter
  during initialization.
- **model** (<code>str</code>) – The name of the model to use for calculating embeddings.
  The default model is `text-embedding-ada-002`.
- **dimensions** (<code>int | None</code>) – The number of dimensions of the resulting embeddings. Only `text-embedding-3` and
  later models support this parameter.
- **api_base_url** (<code>str | None</code>) – Overrides default base URL for all HTTP requests.
- **organization** (<code>str | None</code>) – Your organization ID. See OpenAI's
  [production best practices](https://platform.openai.com/docs/guides/production-best-practices/setting-up-your-organization)
  for more information.
- **prefix** (<code>str</code>) – A string to add at the beginning of each text to embed.
- **suffix** (<code>str</code>) – A string to add at the end of each text to embed.
- **timeout** (<code>float | None</code>) – Timeout for OpenAI client calls. If not set, it defaults to either the
  `OPENAI_TIMEOUT` environment variable, or 30 seconds.
- **max_retries** (<code>int | None</code>) – Maximum number of retries to contact OpenAI after an internal error.
  If not set, it defaults to either the `OPENAI_MAX_RETRIES` environment variable, or set to 5.
- **http_client_kwargs** (<code>dict\[str, Any\] | None</code>) – A dictionary of keyword arguments to configure a custom `httpx.Client`or `httpx.AsyncClient`.
  For more information, see the [HTTPX documentation](https://www.python-httpx.org/api/#client).

#### warm_up

```python
warm_up() -> None
```

Initializes the synchronous OpenAI client.

#### warm_up_async

```python
warm_up_async() -> None
```

Initializes the asynchronous OpenAI client on the serving event loop.

#### close

```python
close() -> None
```

Releases the synchronous OpenAI client.

#### close_async

```python
close_async() -> None
```

Releases the asynchronous OpenAI client.

#### to_dict

```python
to_dict() -> dict[str, Any]
```

Serializes the component to a dictionary.

**Returns:**

- <code>dict\[str, Any\]</code> – Dictionary with serialized data.

#### from_dict

```python
from_dict(data: dict[str, Any]) -> OpenAITextEmbedder
```

Deserializes the component from a dictionary.

**Parameters:**

- **data** (<code>dict\[str, Any\]</code>) – Dictionary to deserialize from.

**Returns:**

- <code>OpenAITextEmbedder</code> – Deserialized component.

#### run

```python
run(text: str) -> dict[str, Any]
```

Embeds a single string.

**Parameters:**

- **text** (<code>str</code>) – Text to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `embedding`: The embedding of the input text.
- `meta`: Information about the usage of the model.

#### run_async

```python
run_async(text: str) -> dict[str, Any]
```

Asynchronously embed a single string.

This is the asynchronous version of the `run` method. It has the same parameters and return values
but can be used with `await` in async code.

**Parameters:**

- **text** (<code>str</code>) – Text to embed.

**Returns:**

- <code>dict\[str, Any\]</code> – A dictionary with the following keys:
- `embedding`: The embedding of the input text.
- `meta`: Information about the usage of the model.