模块 azure_document_embedder

AzureOpenAIDocumentEmbedder

使用部署在 Azure 上的 OpenAI 模型计算文档嵌入。

使用示例

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, ...]

AzureOpenAIDocumentEmbedder.init

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

创建一个 AzureOpenAIDocumentEmbedder 组件。

参数:

azure_endpoint：部署在 Azure 上的模型的端点。
api_version：要使用的 API 版本。
azure_deployment：部署在 Azure 上的模型的名称。默认模型为 text-embedding-ada-002。
dimensions：生成的嵌入的维度数量。仅在 text-embedding-3 及更高版本模型中支持。
api_key：Azure OpenAI API 密钥。可以通过环境变量设置AZURE_OPENAI_API_KEY，或者在初始化期间通过此参数传入。
azure_ad_token：Microsoft Entra ID 令牌，有关更多信息，请参阅 Microsoft 的 Entra ID 文档。可以通过环境变量设置AZURE_OPENAI_AD_TOKEN，或者在初始化期间通过此参数传入。之前称为 Azure Active Directory。
organization：您的组织 ID。有关更多信息，请参阅 OpenAI 的设置您的组织。
prefix: 添加到每个文本开头的字符串。
suffix: 添加到每个文本末尾的字符串。
batch_size：一次嵌入的文档数量。
progress_bar: 如果True，则运行时显示进度条。
meta_fields_to_embed: 要与文档文本一起嵌入的元数据字段列表。
embedding_separator: 用于将元数据字段连接到文档文本的分隔符。
timeout：用于AzureOpenAI 客户端调用的超时时间，以秒为单位。如果未设置，则默认为OPENAI_TIMEOUT 环境变量，或 30 秒。
max_retries：内部错误后联系 AzureOpenAI 的最大重试次数。如果未设置，则默认为OPENAI_MAX_RETRIES 环境变量或 5 次重试。
default_headers：发送到 AzureOpenAI 客户端的默认请求头。
azure_ad_token_provider：一个返回 Azure Active Directory 令牌的函数，将在每个请求中调用。
http_client_kwargs：用于配置自定义的关键字参数字典httpx.Client或httpx.AsyncClient。有关更多信息，请参阅 HTTPX 文档。
raise_on_failure：如果嵌入请求失败是否抛出异常。如果为False，组件将记录错误并继续处理剩余的文档。如果为True，则会在失败时抛出异常。

AzureOpenAIDocumentEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

AzureOpenAIDocumentEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "AzureOpenAIDocumentEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

AzureOpenAIDocumentEmbedder.run

@component.output_types(documents=list[Document], meta=dict[str, Any])
def run(documents: list[Document])

嵌入一系列文档。

参数:

documents：要嵌入的文档列表。

返回值:

包含以下键的字典

documents：包含嵌入的文档列表。
meta：有关模型使用情况的信息。

AzureOpenAIDocumentEmbedder.run_async

@component.output_types(documents=list[Document], meta=dict[str, Any])
async def run_async(documents: list[Document])

异步嵌入文档列表。

参数:

documents：要嵌入的文档列表。

返回值:

包含以下键的字典

documents：包含嵌入的文档列表。
meta：有关模型使用情况的信息。

模块 azure_text_embedder

AzureOpenAITextEmbedder

使用部署在 Azure 上的 OpenAI 模型嵌入字符串。

使用示例

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}}}

AzureOpenAITextEmbedder.init

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

创建一个 AzureOpenAITextEmbedder 组件。

参数:

azure_endpoint：部署在 Azure 上的模型的端点。
api_version：要使用的 API 版本。
azure_deployment：部署在 Azure 上的模型的名称。默认模型为 text-embedding-ada-002。
dimensions：生成的输出嵌入的维度数量。仅在 text-embedding-3 及更高版本模型中支持。
api_key：Azure OpenAI API 密钥。可以通过环境变量设置AZURE_OPENAI_API_KEY，或者在初始化期间通过此参数传入。
azure_ad_token：Microsoft Entra ID 令牌，有关更多信息，请参阅 Microsoft 的 Entra ID 文档。可以通过环境变量设置AZURE_OPENAI_AD_TOKEN，或者在初始化期间通过此参数传入。之前称为 Azure Active Directory。
organization：您的组织 ID。有关更多信息，请参阅 OpenAI 的设置您的组织。
timeout：用于AzureOpenAI 客户端调用的超时时间，以秒为单位。如果未设置，则默认为OPENAI_TIMEOUT 环境变量，或 30 秒。
max_retries：内部错误后联系 AzureOpenAI 的最大重试次数。如果未设置，则默认为OPENAI_MAX_RETRIES 环境变量或 5 次重试。
prefix: 添加到每个文本开头的字符串。
suffix: 添加到每个文本末尾的字符串。
default_headers：发送到 AzureOpenAI 客户端的默认请求头。
azure_ad_token_provider：一个返回 Azure Active Directory 令牌的函数，将在每个请求中调用。
http_client_kwargs：用于配置自定义的关键字参数字典httpx.Client或httpx.AsyncClient。有关更多信息，请参阅 HTTPX 文档。

AzureOpenAITextEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

AzureOpenAITextEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "AzureOpenAITextEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

AzureOpenAITextEmbedder.run

@component.output_types(embedding=list[float], meta=dict[str, Any])
def run(text: str)

嵌入单个字符串。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。
meta：有关模型使用情况的信息。

AzureOpenAITextEmbedder.run_async

@component.output_types(embedding=list[float], meta=dict[str, Any])
async def run_async(text: str)

异步嵌入单个字符串。

这是run 方法。它具有相同的参数和返回值，但可以在异步代码中与await 一起使用。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。
meta：有关模型使用情况的信息。

模块 hugging_face_api_document_embedder

HuggingFaceAPIDocumentEmbedder

使用 Hugging Face API 嵌入文档。

可配合以下 Hugging Face API 使用

使用示例

使用免费的无服务器推理 API

from haystack.components.embedders import HuggingFaceAPIDocumentEmbedder
from haystack.utils import Secret
from haystack.dataclasses import Document

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

doc_embedder = HuggingFaceAPIDocumentEmbedder(api_type="serverless_inference_api",
                                              api_params={"model": "BAAI/bge-small-en-v1.5"},
                                              token=Secret.from_token("<your-api-key>"))

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

# [0.017020374536514282, -0.023255806416273117, ...]

使用付费推理端点

from haystack.components.embedders import HuggingFaceAPIDocumentEmbedder
from haystack.utils import Secret
from haystack.dataclasses import Document

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

doc_embedder = HuggingFaceAPIDocumentEmbedder(api_type="inference_endpoints",
                                              api_params={"url": "<your-inference-endpoint-url>"},
                                              token=Secret.from_token("<your-api-key>"))

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

# [0.017020374536514282, -0.023255806416273117, ...]

使用自托管文本嵌入推理

from haystack.components.embedders import HuggingFaceAPIDocumentEmbedder
from haystack.dataclasses import Document

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

doc_embedder = HuggingFaceAPIDocumentEmbedder(api_type="text_embeddings_inference",
                                              api_params={"url": "https://:8080"})

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

# [0.017020374536514282, -0.023255806416273117, ...]

HuggingFaceAPIDocumentEmbedder.init

def __init__(api_type: Union[HFEmbeddingAPIType, str],
             api_params: dict[str, str],
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             prefix: str = "",
             suffix: str = "",
             truncate: Optional[bool] = True,
             normalize: Optional[bool] = False,
             batch_size: int = 32,
             progress_bar: bool = True,
             meta_fields_to_embed: Optional[list[str]] = None,
             embedding_separator: str = "\n")

创建一个 HuggingFaceAPIDocumentEmbedder 组件。

参数:

api_type：要使用的 Hugging Face API 类型。
api_params：一个字典，包含以下键
model: Hugging Face 模型 ID。当api_type 是SERVERLESS_INFERENCE_API.
url: 推理终结点的 URL。当api_type 是INFERENCE_ENDPOINTS 或TEXT_EMBEDDINGS_INFERENCE 时必需。.
token: 用于作为 HTTP bearer 授权的 Hugging Face 令牌。请在您的账户设置中查看您的 HF 令牌。
prefix: 添加到每个文本开头的字符串。
suffix: 添加到每个文本末尾的字符串。
truncate：将输入文本截断到模型支持的最大长度。适用于api_type 是TEXT_EMBEDDINGS_INFERENCE，或INFERENCE_ENDPOINTS 如果后端使用文本嵌入推理。如果为api_type 是SERVERLESS_INFERENCE_API，则忽略此参数。
normalize：将嵌入归一化到单位长度。适用于api_type 是TEXT_EMBEDDINGS_INFERENCE，或INFERENCE_ENDPOINTS 如果后端使用文本嵌入推理。如果为api_type 是SERVERLESS_INFERENCE_API，则忽略此参数。
batch_size：一次处理的文档数量。
progress_bar: 如果True，则运行时显示进度条。
meta_fields_to_embed: 要与文档文本一起嵌入的元数据字段列表。
embedding_separator: 用于将元数据字段连接到文档文本的分隔符。

HuggingFaceAPIDocumentEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

HuggingFaceAPIDocumentEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "HuggingFaceAPIDocumentEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

HuggingFaceAPIDocumentEmbedder.run

@component.output_types(documents=list[Document])
def run(documents: list[Document])

嵌入一系列文档。

参数:

documents: 要嵌入的 Documents。

返回值:

包含以下键的字典

documents：包含嵌入的文档列表。

HuggingFaceAPIDocumentEmbedder.run_async

@component.output_types(documents=list[Document])
async def run_async(documents: list[Document])

异步嵌入文档列表。

参数:

documents: 要嵌入的 Documents。

返回值:

包含以下键的字典

documents：包含嵌入的文档列表。

模块 hugging_face_api_text_embedder

HuggingFaceAPITextEmbedder

使用 Hugging Face API 嵌入字符串。

可配合以下 Hugging Face API 使用

使用示例

使用免费的无服务器推理 API

from haystack.components.embedders import HuggingFaceAPITextEmbedder
from haystack.utils import Secret

text_embedder = HuggingFaceAPITextEmbedder(api_type="serverless_inference_api",
                                           api_params={"model": "BAAI/bge-small-en-v1.5"},
                                           token=Secret.from_token("<your-api-key>"))

print(text_embedder.run("I love pizza!"))

# {'embedding': [0.017020374536514282, -0.023255806416273117, ...],

使用付费推理端点

from haystack.components.embedders import HuggingFaceAPITextEmbedder
from haystack.utils import Secret
text_embedder = HuggingFaceAPITextEmbedder(api_type="inference_endpoints",
                                           api_params={"model": "BAAI/bge-small-en-v1.5"},
                                           token=Secret.from_token("<your-api-key>"))

print(text_embedder.run("I love pizza!"))

# {'embedding': [0.017020374536514282, -0.023255806416273117, ...],

使用自托管文本嵌入推理

from haystack.components.embedders import HuggingFaceAPITextEmbedder
from haystack.utils import Secret

text_embedder = HuggingFaceAPITextEmbedder(api_type="text_embeddings_inference",
                                           api_params={"url": "https://:8080"})

print(text_embedder.run("I love pizza!"))

# {'embedding': [0.017020374536514282, -0.023255806416273117, ...],

HuggingFaceAPITextEmbedder.init

def __init__(api_type: Union[HFEmbeddingAPIType, str],
             api_params: dict[str, str],
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             prefix: str = "",
             suffix: str = "",
             truncate: Optional[bool] = True,
             normalize: Optional[bool] = False)

创建一个 HuggingFaceAPITextEmbedder 组件。

参数:

api_type：要使用的 Hugging Face API 类型。
api_params：一个字典，包含以下键
model: Hugging Face 模型 ID。当api_type 是SERVERLESS_INFERENCE_API.
url: 推理终结点的 URL。当api_type 是INFERENCE_ENDPOINTS 或TEXT_EMBEDDINGS_INFERENCE 时必需。.
token: 用于作为 HTTP bearer 授权的 Hugging Face 令牌。请在您的账户设置中查看您的 HF 令牌。
prefix: 添加到每个文本开头的字符串。
suffix: 添加到每个文本末尾的字符串。
truncate：将输入文本截断到模型支持的最大长度。适用于api_type 是TEXT_EMBEDDINGS_INFERENCE，或INFERENCE_ENDPOINTS 如果后端使用文本嵌入推理。如果为api_type 是SERVERLESS_INFERENCE_API，则忽略此参数。
normalize：将嵌入归一化到单位长度。适用于api_type 是TEXT_EMBEDDINGS_INFERENCE，或INFERENCE_ENDPOINTS 如果后端使用文本嵌入推理。如果为api_type 是SERVERLESS_INFERENCE_API，则忽略此参数。

HuggingFaceAPITextEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

HuggingFaceAPITextEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "HuggingFaceAPITextEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

HuggingFaceAPITextEmbedder.run

@component.output_types(embedding=list[float])
def run(text: str)

嵌入单个字符串。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。

HuggingFaceAPITextEmbedder.run_async

@component.output_types(embedding=list[float])
async def run_async(text: str)

异步嵌入单个字符串。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。

模块 openai_document_embedder

OpenAIDocumentEmbedder

使用 OpenAI 模型计算文档嵌入。

使用示例

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, ...]

OpenAIDocumentEmbedder.init

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

创建一个 OpenAIDocumentEmbedder 组件。

在初始化组件之前，您可以设置 'OPENAI_TIMEOUT' 和 'OPENAI_MAX_RETRIES' 环境变量以覆盖 OpenAI 客户端中的timeout 和max_retries 参数。

参数:

api_key：OpenAI API 密钥。可以通过环境变量设置OPENAI_API_KEY，或者在初始化时通过此参数传递。
model：用于计算嵌入的模型名称。默认模型是text-embedding-ada-002.
dimensions：生成的嵌入的维度数量。只有text-embedding-3 及更高版本模型支持此参数。
api_base_url：覆盖所有 HTTP 请求的默认基本 URL。
organization：您的 OpenAI 组织 ID。有关更多信息，请参阅 OpenAI 的设置您的组织。
prefix: 添加到每个文本开头的字符串。
suffix: 添加到每个文本末尾的字符串。
batch_size：一次嵌入的文档数量。
progress_bar: 如果True，则运行时显示进度条。
meta_fields_to_embed: 要与文档文本一起嵌入的元数据字段列表。
embedding_separator: 用于将元数据字段连接到文档文本的分隔符。
timeout：OpenAI 客户端调用的超时时间。如果未设置，则默认为OPENAI_TIMEOUT 环境变量，或 30 秒。
max_retries: 在发生内部错误后联系 OpenAI 的最大重试次数。如果未设置，则默认为OPENAI_MAX_RETRIES 环境变量或 5 次重试。
http_client_kwargs：用于配置自定义的关键字参数字典httpx.Client或httpx.AsyncClient。有关更多信息，请参阅 HTTPX 文档。
raise_on_failure：如果嵌入请求失败是否抛出异常。如果为False，组件将记录错误并继续处理剩余的文档。如果为True，则会在失败时抛出异常。

OpenAIDocumentEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

OpenAIDocumentEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "OpenAIDocumentEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

OpenAIDocumentEmbedder.run

@component.output_types(documents=list[Document], meta=dict[str, Any])
def run(documents: list[Document])

嵌入一系列文档。

参数:

documents：要嵌入的文档列表。

返回值:

包含以下键的字典

documents：包含嵌入的文档列表。
meta：有关模型使用情况的信息。

OpenAIDocumentEmbedder.run_async

@component.output_types(documents=list[Document], meta=dict[str, Any])
async def run_async(documents: list[Document])

异步嵌入文档列表。

参数:

documents：要嵌入的文档列表。

返回值:

包含以下键的字典

documents：包含嵌入的文档列表。
meta：有关模型使用情况的信息。

模块 openai_text_embedder

OpenAITextEmbedder

使用 OpenAI 模型嵌入字符串。

您可以使用它来嵌入用户查询并将查询发送到嵌入检索器。

使用示例

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}}}

OpenAITextEmbedder.init

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

创建一个 OpenAITextEmbedder 组件。

在初始化组件之前，您可以设置 'OPENAI_TIMEOUT' 和 'OPENAI_MAX_RETRIES' 环境变量以覆盖 OpenAI 客户端中的timeout 和max_retries 参数。

参数:

api_key：OpenAI API 密钥。可以通过环境变量设置OPENAI_API_KEY，或者在初始化时通过此参数传递。
model：用于计算嵌入的模型名称。默认模型是text-embedding-ada-002.
dimensions：生成的嵌入的维度数量。只有text-embedding-3 及更高版本模型支持此参数。
api_base_url：覆盖所有 HTTP 请求的默认基本 URL。
organization：您的组织 ID。有关更多信息，请参阅 OpenAI 的生产最佳实践。
prefix：添加到每个待嵌入文本开头的字符串。
suffix：添加到每个待嵌入文本末尾的字符串。
timeout：OpenAI 客户端调用的超时时间。如果未设置，则默认为OPENAI_TIMEOUT 环境变量，或 30 秒。
max_retries: 在发生内部错误后联系 OpenAI 的最大重试次数。如果未设置，则默认为OPENAI_MAX_RETRIES 环境变量，或设置为 5。
http_client_kwargs：用于配置自定义的关键字参数字典httpx.Client或httpx.AsyncClient。有关更多信息，请参阅 HTTPX 文档。

OpenAITextEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

OpenAITextEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "OpenAITextEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

OpenAITextEmbedder.run

@component.output_types(embedding=list[float], meta=dict[str, Any])
def run(text: str)

嵌入单个字符串。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。
meta：有关模型使用情况的信息。

OpenAITextEmbedder.run_async

@component.output_types(embedding=list[float], meta=dict[str, Any])
async def run_async(text: str)

异步嵌入单个字符串。

这是run 方法。它具有相同的参数和返回值，但可以在异步代码中与await 一起使用。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。
meta：有关模型使用情况的信息。

模块 sentence_transformers_document_embedder

SentenceTransformersDocumentEmbedder

使用 Sentence Transformers 模型计算文档嵌入。

它将嵌入存储在每个文档的embedding 元数据字段中。您还可以嵌入文档的元数据。在索引管道中使用此组件来嵌入输入文档并将其发送到 DocumentWriter 以写入文档存储。

使用示例

from haystack import Document
from haystack.components.embedders import SentenceTransformersDocumentEmbedder
doc = Document(content="I love pizza!")
doc_embedder = SentenceTransformersDocumentEmbedder()
doc_embedder.warm_up()

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

# [-0.07804739475250244, 0.1498992145061493, ...]

SentenceTransformersDocumentEmbedder.init

def __init__(model: str = "sentence-transformers/all-mpnet-base-v2",
             device: Optional[ComponentDevice] = None,
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             prefix: str = "",
             suffix: str = "",
             batch_size: int = 32,
             progress_bar: bool = True,
             normalize_embeddings: bool = False,
             meta_fields_to_embed: Optional[list[str]] = None,
             embedding_separator: str = "\n",
             trust_remote_code: bool = False,
             local_files_only: bool = False,
             truncate_dim: Optional[int] = None,
             model_kwargs: Optional[dict[str, Any]] = None,
             tokenizer_kwargs: Optional[dict[str, Any]] = None,
             config_kwargs: Optional[dict[str, Any]] = None,
             precision: Literal["float32", "int8", "uint8", "binary",
                                "ubinary"] = "float32",
             encode_kwargs: Optional[dict[str, Any]] = None,
             backend: Literal["torch", "onnx", "openvino"] = "torch")

创建一个 SentenceTransformersDocumentEmbedder 组件。

参数:

model：用于计算嵌入的模型。传入本地路径或 Hugging Face 上的模型 ID。
device：用于加载模型的设备。覆盖默认设备。
token: 用于从 Hugging Face 下载私有模型的 API 令牌。
prefix：一个字符串，添加到每个文档文本的开头。可用于在文本前加上指令，某些嵌入模型（如 E5 和 bge）需要这样做。
suffix：一个字符串，添加到每个文档文本的末尾。
batch_size：一次嵌入的文档数量。
progress_bar: 如果True，在嵌入文档时显示进度条。
normalize_embeddings：如果为True，则使用 L2 归一化对嵌入进行归一化，使每个嵌入的范数为 1。
meta_fields_to_embed: 要与文档文本一起嵌入的元数据字段列表。
embedding_separator: 用于将元数据字段连接到文档文本的分隔符。
trust_remote_code: 如果为False，则只允许 Hugging Face 经过验证的模型架构。如果为True，则允许自定义模型和脚本。
local_files_only: 如果为True，则不尝试从 Hugging Face Hub 下载模型，只查看本地文件。
truncate_dim：截断句子嵌入的维度。None 则不截断。如果模型未经过 Matryoshka 表示学习训练，截断嵌入可能会显著影响性能。
model_kwargs: 加载模型时传递给AutoModelForSequenceClassification.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
tokenizer_kwargs: 加载分词器时传递给AutoTokenizer.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
config_kwargs: 加载模型配置时传递给AutoConfig.from_pretrained 的额外关键字参数。
precision：用于嵌入的精度。所有非 float32 精度都是量化嵌入。量化嵌入更小，计算速度更快，但准确性可能较低。它们对于减小语料库嵌入的大小以进行语义搜索等任务很有用。
encode_kwargs：嵌入文档时用于SentenceTransformer.encode 的额外关键字参数。此参数用于精细自定义。请注意不要与已设置的参数冲突，并避免传入更改输出类型的参数。
backend: 用于 Sentence Transformers 模型的后端。选择 "torch"、"onnx" 或 "openvino"。有关加速和量化选项的更多信息，请参阅 Sentence Transformers 文档。

SentenceTransformersDocumentEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

SentenceTransformersDocumentEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str,
                              Any]) -> "SentenceTransformersDocumentEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

SentenceTransformersDocumentEmbedder.warm_up

def warm_up()

Initializes the component.

SentenceTransformersDocumentEmbedder.run

@component.output_types(documents=list[Document])
def run(documents: list[Document])

嵌入文档列表。

参数:

documents: 要嵌入的 Documents。

返回值:

包含以下键的字典

documents: 带有嵌入的 Documents。

模块 sentence_transformers_text_embedder

SentenceTransformersTextEmbedder

使用 Sentence Transformers 模型嵌入字符串。

您可以使用它来嵌入用户查询并将其发送到嵌入检索器。

使用示例

from haystack.components.embedders import SentenceTransformersTextEmbedder

text_to_embed = "I love pizza!"

text_embedder = SentenceTransformersTextEmbedder()
text_embedder.warm_up()

print(text_embedder.run(text_to_embed))

# {'embedding': [-0.07804739475250244, 0.1498992145061493,, ...]}

SentenceTransformersTextEmbedder.init

def __init__(model: str = "sentence-transformers/all-mpnet-base-v2",
             device: Optional[ComponentDevice] = None,
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             prefix: str = "",
             suffix: str = "",
             batch_size: int = 32,
             progress_bar: bool = True,
             normalize_embeddings: bool = False,
             trust_remote_code: bool = False,
             local_files_only: bool = False,
             truncate_dim: Optional[int] = None,
             model_kwargs: Optional[dict[str, Any]] = None,
             tokenizer_kwargs: Optional[dict[str, Any]] = None,
             config_kwargs: Optional[dict[str, Any]] = None,
             precision: Literal["float32", "int8", "uint8", "binary",
                                "ubinary"] = "float32",
             encode_kwargs: Optional[dict[str, Any]] = None,
             backend: Literal["torch", "onnx", "openvino"] = "torch")

创建一个 SentenceTransformersTextEmbedder 组件。

参数:

model：用于计算嵌入的模型。指定本地模型的路径或 Hugging Face 上的模型 ID。
device：覆盖用于加载模型的默认设备。
token：用于从 Hugging Face 使用私有模型的 API 令牌。
prefix：一个字符串，添加到每个要嵌入的文本的开头。可用于在文本前加上指令，某些嵌入模型（如 E5 和 bge）需要这样做。
suffix：添加到每个待嵌入文本末尾的字符串。
batch_size：一次嵌入的文本数量。
progress_bar: 如果True，显示计算嵌入的进度条。如果为False，禁用进度条。
normalize_embeddings：如果为True，则使用 L2 归一化对嵌入进行归一化，使嵌入的范数为 1。
trust_remote_code: 如果为False，只允许 Hugging Face 验证的模型架构。如果为True，允许自定义模型和脚本。
local_files_only: 如果为True，则不尝试从 Hugging Face Hub 下载模型，只查看本地文件。
truncate_dim：截断句子嵌入的维度。None 则不截断。如果模型未经过 Matryoshka 表示学习训练，截断嵌入可能会显著影响性能。
model_kwargs: 加载模型时传递给AutoModelForSequenceClassification.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
tokenizer_kwargs: 加载分词器时传递给AutoTokenizer.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
config_kwargs: 加载模型配置时传递给AutoConfig.from_pretrained 的额外关键字参数。
precision：用于嵌入的精度。所有非 float32 精度都是量化嵌入。量化嵌入尺寸更小，计算速度更快，但准确性可能较低。它们对于减小语料库嵌入的大小以进行语义搜索等任务很有用。
encode_kwargs：嵌入文档时用于SentenceTransformer.encode 嵌入文本时的额外关键字参数。此参数用于精细自定义。请注意不要与已设置的参数冲突，并避免传入更改输出类型的参数。
backend: 用于 Sentence Transformers 模型的后端。选择 "torch"、"onnx" 或 "openvino"。有关加速和量化选项的更多信息，请参阅 Sentence Transformers 文档。

SentenceTransformersTextEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

SentenceTransformersTextEmbedder.from_dict

@classmethod
def from_dict(cls, data: dict[str, Any]) -> "SentenceTransformersTextEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

SentenceTransformersTextEmbedder.warm_up

def warm_up()

Initializes the component.

SentenceTransformersTextEmbedder.run

@component.output_types(embedding=list[float])
def run(text: str)

嵌入单个字符串。

参数:

text：要嵌入的文本。

返回值:

包含以下键的字典

embedding：输入文本的嵌入。

模块 image/sentence_transformers_doc_image_embedder

SentenceTransformersDocumentImageEmbedder

一个用于使用 Sentence Transformers 模型计算基于图像的文档嵌入的组件。

每个 Document 的嵌入存储在Document 的 embedding 字段中。

使用示例

from haystack import Document
from haystack.components.embedders.image import SentenceTransformersDocumentImageEmbedder

embedder = SentenceTransformersDocumentImageEmbedder(model="sentence-transformers/clip-ViT-B-32")
embedder.warm_up()

documents = [
    Document(content="A photo of a cat", meta={"file_path": "cat.jpg"}),
    Document(content="A photo of a dog", meta={"file_path": "dog.jpg"}),
]

result = embedder.run(documents=documents)
documents_with_embeddings = result["documents"]
print(documents_with_embeddings)

# [Document(id=...,
#           content='A photo of a cat',
#           meta={'file_path': 'cat.jpg',
#                 'embedding_source': {'type': 'image', 'file_path_meta_field': 'file_path'}},
#           embedding=vector of size 512),
#  ...]

SentenceTransformersDocumentImageEmbedder.init

def __init__(*,
             file_path_meta_field: str = "file_path",
             root_path: Optional[str] = None,
             model: str = "sentence-transformers/clip-ViT-B-32",
             device: Optional[ComponentDevice] = None,
             token: Optional[Secret] = Secret.from_env_var(
                 ["HF_API_TOKEN", "HF_TOKEN"], strict=False),
             batch_size: int = 32,
             progress_bar: bool = True,
             normalize_embeddings: bool = False,
             trust_remote_code: bool = False,
             local_files_only: bool = False,
             model_kwargs: Optional[dict[str, Any]] = None,
             tokenizer_kwargs: Optional[dict[str, Any]] = None,
             config_kwargs: Optional[dict[str, Any]] = None,
             precision: Literal["float32", "int8", "uint8", "binary",
                                "ubinary"] = "float32",
             encode_kwargs: Optional[dict[str, Any]] = None,
             backend: Literal["torch", "onnx", "openvino"] = "torch") -> None

创建一个 SentenceTransformersDocumentEmbedder 组件。

参数:

file_path_meta_field: Document 中包含图像或 PDF 文件路径的元数据字段。
root_path: 存储文档文件的根目录路径。如果提供，文档元数据中的文件路径将相对于此路径解析。如果为 None，则文件路径被视为绝对路径。
model：用于计算嵌入的 Sentence Transformers 模型。传入本地路径或 Hugging Face 上的模型 ID。要与此组件一起使用，模型必须能够将图像和文本嵌入到相同的向量空间中。兼容的模型包括
"sentence-transformers/clip-ViT-B-32"
"sentence-transformers/clip-ViT-L-14"
"sentence-transformers/clip-ViT-B-16"
"sentence-transformers/clip-ViT-B-32-multilingual-v1"
"jinaai/jina-embeddings-v4"
"jinaai/jina-clip-v1"
"jinaai/jina-clip-v2"。
device：用于加载模型的设备。覆盖默认设备。
token: 用于从 Hugging Face 下载私有模型的 API 令牌。
batch_size：一次嵌入的文档数量。
progress_bar: 如果True，在嵌入文档时显示进度条。
normalize_embeddings：如果为True，则使用 L2 归一化对嵌入进行归一化，使每个嵌入的范数为 1。
trust_remote_code: 如果为False，则只允许 Hugging Face 经过验证的模型架构。如果为True，则允许自定义模型和脚本。
local_files_only: 如果为True，则不尝试从 Hugging Face Hub 下载模型，只查看本地文件。
model_kwargs: 加载模型时传递给AutoModelForSequenceClassification.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
tokenizer_kwargs: 加载分词器时传递给AutoTokenizer.from_pretrained 的额外关键字参数。有关可用 kwargs，请参阅特定模型的文档。
config_kwargs: 加载模型配置时传递给AutoConfig.from_pretrained 的额外关键字参数。
precision：用于嵌入的精度。所有非 float32 精度都是量化嵌入。量化嵌入更小，计算速度更快，但准确性可能较低。它们对于减小语料库嵌入的大小以进行语义搜索等任务很有用。
encode_kwargs：嵌入文档时用于SentenceTransformer.encode 的额外关键字参数。此参数用于精细自定义。请注意不要与已设置的参数冲突，并避免传入更改输出类型的参数。
backend: 用于 Sentence Transformers 模型的后端。选择 "torch"、"onnx" 或 "openvino"。有关加速和量化选项的更多信息，请参阅 Sentence Transformers 文档。

SentenceTransformersDocumentImageEmbedder.to_dict

def to_dict() -> dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

SentenceTransformersDocumentImageEmbedder.from_dict

@classmethod
def from_dict(
        cls, data: dict[str,
                        Any]) -> "SentenceTransformersDocumentImageEmbedder"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

SentenceTransformersDocumentImageEmbedder.warm_up

def warm_up() -> None

Initializes the component.

SentenceTransformersDocumentImageEmbedder.run

@component.output_types(documents=list[Document])
def run(documents: list[Document]) -> dict[str, list[Document]]

嵌入文档列表。

参数:

documents: 要嵌入的 Documents。

返回值:

包含以下键的字典

documents: 带有嵌入的 Documents。

模块 azure_document_embedder

AzureOpenAIDocumentEmbedder

使用示例

AzureOpenAIDocumentEmbedder.__init__

AzureOpenAIDocumentEmbedder.to_dict

AzureOpenAIDocumentEmbedder.from_dict

AzureOpenAIDocumentEmbedder.run

AzureOpenAIDocumentEmbedder.run_async

模块 azure_text_embedder

AzureOpenAITextEmbedder

使用示例

AzureOpenAITextEmbedder.__init__

AzureOpenAITextEmbedder.to_dict

AzureOpenAITextEmbedder.from_dict

AzureOpenAITextEmbedder.run

AzureOpenAITextEmbedder.run_async

模块 hugging_face_api_document_embedder

HuggingFaceAPIDocumentEmbedder

使用示例

使用免费的无服务器推理 API

使用付费推理端点

使用自托管文本嵌入推理

HuggingFaceAPIDocumentEmbedder.__init__

HuggingFaceAPIDocumentEmbedder.to_dict

HuggingFaceAPIDocumentEmbedder.from_dict

HuggingFaceAPIDocumentEmbedder.run

HuggingFaceAPIDocumentEmbedder.run_async

模块 hugging_face_api_text_embedder

HuggingFaceAPITextEmbedder

使用示例

使用免费的无服务器推理 API

使用付费推理端点

使用自托管文本嵌入推理

HuggingFaceAPITextEmbedder.__init__

HuggingFaceAPITextEmbedder.to_dict

HuggingFaceAPITextEmbedder.from_dict

HuggingFaceAPITextEmbedder.run

HuggingFaceAPITextEmbedder.run_async

模块 openai_document_embedder

OpenAIDocumentEmbedder

使用示例

OpenAIDocumentEmbedder.__init__

OpenAIDocumentEmbedder.to_dict

OpenAIDocumentEmbedder.from_dict

OpenAIDocumentEmbedder.run

OpenAIDocumentEmbedder.run_async

模块 openai_text_embedder

OpenAITextEmbedder

使用示例

OpenAITextEmbedder.__init__

OpenAITextEmbedder.to_dict

OpenAITextEmbedder.from_dict

OpenAITextEmbedder.run

OpenAITextEmbedder.run_async

模块 sentence_transformers_document_embedder

SentenceTransformersDocumentEmbedder

使用示例

SentenceTransformersDocumentEmbedder.__init__

SentenceTransformersDocumentEmbedder.to_dict

SentenceTransformersDocumentEmbedder.from_dict

SentenceTransformersDocumentEmbedder.warm_up

SentenceTransformersDocumentEmbedder.run

模块 sentence_transformers_text_embedder

SentenceTransformersTextEmbedder

SentenceTransformersTextEmbedder.__init__

SentenceTransformersTextEmbedder.to_dict

SentenceTransformersTextEmbedder.from_dict

SentenceTransformersTextEmbedder.warm_up

SentenceTransformersTextEmbedder.run

模块 image/sentence_transformers_doc_image_embedder

SentenceTransformersDocumentImageEmbedder

使用示例

SentenceTransformersDocumentImageEmbedder.__init__

SentenceTransformersDocumentImageEmbedder.to_dict

SentenceTransformersDocumentImageEmbedder.from_dict

SentenceTransformersDocumentImageEmbedder.warm_up

SentenceTransformersDocumentImageEmbedder.run

AzureOpenAIDocumentEmbedder.init

AzureOpenAITextEmbedder.init

HuggingFaceAPIDocumentEmbedder.init

HuggingFaceAPITextEmbedder.init

OpenAIDocumentEmbedder.init

OpenAITextEmbedder.init

SentenceTransformersDocumentEmbedder.init

SentenceTransformersTextEmbedder.init

SentenceTransformersDocumentImageEmbedder.init