【LangChain】langchain_core.embeddings.Embeddings 类：定义文本嵌入模型的抽象基类

langchain_core.embeddings.Embeddings 是 LangChain 框架中的一个核心抽象基类，用于定义文本嵌入模型的标准化接口，支持将文本映射为高维向量以便进行语义搜索、文档检索等任务。本文详细介绍其功能、方法、参数、使用方法、实际应用及注意事项。

1. 概述

1.1 什么是 Embeddings？

Embeddings 是一个抽象基类，位于 langchain_core.embeddings 模块，继承自 Python 的 ABC（抽象基类）。它为各种文本嵌入模型（如 OpenAI、Hugging Face、Cohere 等）提供统一的接口，确保不同提供商的嵌入模型在 LangChain 生态系统中可以互换使用。嵌入（embeddings）是将文本映射到高维向量空间的表示，语义相似的文本在空间中更接近，便于语义比较和搜索。

该类在 langchain-core 0.2.14 版本中引入，广泛应用于向量存储、检索链和记忆模块，是 LangChain 中实现语义搜索和上下文增强的关键组件。相关信息可参考 LangChain 嵌入模型文档 和 Embeddings API 参考。

1.2 核心功能

• 标准化接口：为嵌入模型提供统一接口，支持不同提供商（如 OpenAI、Hugging Face）的模型。
• 文本向量化：将文本映射为高维向量，语义相似的文本在向量空间中靠近。
• 文档与查询分离：提供 embed_documents 和 embed_query 方法，分别嵌入文档和查询，允许不同嵌入策略。
• 同步与异步支持：支持同步（embed_documents、embed_query）和异步（aembed_documents、aembed_query）操作，满足性能需求。
• 生态集成：与 LangChain 的向量存储（如 FAISS、Pinecone）、检索链和记忆模块无缝集成。
• 版本要求：需 langchain-core>=0.2.14，推荐使用最新版本。

2. 定义与结构

2.1 类定义

Embeddings 是一个抽象基类，定义如下（简化表示）：

from abc import ABC
from typing import List

class Embeddings(ABC):
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        pass

    def embed_query(self, text: str) -> List[float]:
        pass

    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
        pass

    async def aembed_query(self, text: str) -> List[float]:
        pass

2.2 核心方法

以下是 Embeddings 类的核心方法，基于 API 参考：

方法	签名	描述
embed_documents	embed_documents(self, texts: List[str]) -> List[List[float]]	同步嵌入文档列表，返回每个文档的嵌入向量列表。
embed_query	embed_query(self, text: str) -> List[float]	同步嵌入单个查询文本，返回其嵌入向量。
aembed_documents	aembed_documents(self, texts: List[str]) -> List[List[float]]	异步嵌入文档列表，返回每个文档的嵌入向量列表。
aembed_query	aembed_query(self, text: str) -> List[float]	异步嵌入单个查询文本，返回其嵌入向量。

参数：

• texts：List[str]，要嵌入的文本列表（用于文档）。
• text：str，要嵌入的单个文本（用于查询）。

返回值：

• embed_documents 和 aembed_documents：List[List[float]]，每个文档的嵌入向量。
• embed_query 和 aembed_query：List[float]，查询的嵌入向量。

2.3 初始化

Embeddings 本身是抽象类，无初始化参数。具体子类（如 OpenAIEmbeddings）可能有额外参数，例如：

• model：模型名称（如 "text-embedding-3-large"）。
• api_key：API 密钥，用于认证。
• dimensions：嵌入向量维度（若模型支持）。

3. 使用方法

使用 Embeddings 类需通过实例化其具体子类（如 OpenAIEmbeddings、HuggingFaceEmbeddings）。以下是具体示例：

3.1 基本用法

使用 OpenAIEmbeddings 嵌入文档和查询：

from langchain_openai import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key="your-api-key")

# 嵌入文档列表
docs = ["你好，世界！", "你好吗？"]
doc_embeddings = embeddings.embed_documents(docs)
print(doc_embeddings)  # 输出: [[0.1, 0.2, ...], [0.3, 0.4, ...]]

# 嵌入查询
query = "你的名字是什么？"
query_embedding = embeddings.embed_query(query)
print(query_embedding)  # 输出: [0.5, 0.6, ...]

3.2 异步嵌入

使用异步方法嵌入文本：

import asyncio
from langchain_openai import OpenAIEmbeddings

async def embed_async():
    embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key="your-api-key")
    docs = ["你好，世界！", "你好吗？"]
    doc_embeddings = await embeddings.aembed_documents(docs)
    query = "你的名字是什么？"
    query_embedding = await embeddings.aembed_query(query)
    print(doc_embeddings, query_embedding)

asyncio.run(embed_async())

3.3 结合向量存储

将嵌入与向量存储（如 FAISS）结合，用于语义搜索：

from langchain.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key="your-api-key")

# 创建向量存储
vectorstore = FAISS.from_texts(["你好，世界！", "你好吗？"], embeddings)

# 搜索相似文档
results = vectorstore.similarity_search("你好", k=1)
print(results)  # 输出: [Document(page_content="你好，世界！", ...)]

3.4 结合 RAG 应用

在检索增强生成（RAG）中嵌入查询和文档：

from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.vectorstores import FAISS

# 初始化嵌入模型和向量存储
embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key="your-api-key")
vectorstore = FAISS.from_texts(["LangChain 是一个 LLM 框架"], embeddings)

# 创建 RAG 链
prompt = ChatPromptTemplate.from_template("根据以下文档回答问题：\n{docs}\n问题：{question}")
chain = (
    {"docs": vectorstore.as_retriever() | (lambda docs: "\n".join(doc.page_content for doc in docs)), "question": RunnablePassthrough()}
    | prompt
    | ChatOpenAI()
)

# 调用链
result = chain.invoke("LangChain 是什么？")
print(result)

3.5 自定义嵌入模型

继承 Embeddings 实现自定义模型：

from langchain_core.embeddings import Embeddings
import numpy as np

class CustomEmbeddings(Embeddings):
    def embed_documents(self, texts: List[str]) -> List[List[float]]:
        # 假设的嵌入逻辑
        return [np.random.rand(128).tolist() for _ in texts]

    def embed_query(self, text: str) -> List[float]:
        # 假设的查询嵌入
        return np.random.rand(128).tolist()

custom_embeddings = CustomEmbeddings()
docs = ["你好，世界！"]
doc_embeddings = custom_embeddings.embed_documents(docs)
print(doc_embeddings)

4. 实际应用

Embeddings 类在以下场景中广泛应用：

• 语义搜索：嵌入文档和查询，计算余弦相似度，检索最相关文档。
• 向量存储：为向量存储（如 FAISS、Pinecone）生成嵌入向量，支持高效索引和搜索。
• RAG 应用：在检索增强生成中，嵌入查询检索上下文文档，增强模型生成。
• 记忆模块：存储嵌入表示的对话历史或上下文，便于后续召回。
• 文本分类与聚类：使用嵌入向量进行文本分类或聚类分析。
• 自定义嵌入：通过继承 Embeddings 支持本地或自定义嵌入模型。

5. 最佳实践

• 选择合适的嵌入模型：根据任务需求选择模型，如 OpenAI 的 text-embedding-3-large（高性能）或 Hugging Face 的 sentence-transformers（开源）。参考 LangChain 嵌入模型集成。
• 异步优化：在高并发场景下使用 aembed_documents 和 aembed_query，减少阻塞。
• 批量处理：优先使用 embed_documents 批量嵌入，降低 API 调用次数。
• API 密钥管理：通过环境变量（如 OPENAI_API_KEY）设置密钥，避免硬编码。
• 向量维度匹配：确保嵌入模型的维度与向量存储或下游任务兼容。
• 版本检查：通过 pip install -qU langchain 确保安装 langchain-core>=0.2.14。
• 调试工具：使用 LangSmith 跟踪嵌入操作，调试复杂链或检索问题。

6. 注意事项与限制

• 抽象基类：Embeddings 无法直接实例化，需使用具体子类（如 OpenAIEmbeddings）。
• API 依赖：子类可能需要 API 密钥（如 OpenAI 的），需配置环境变量或参数。
• 性能开销：嵌入大量文档可能导致高延迟或成本，需优化批量处理。
• 模型限制：不同模型支持的文本长度和语言范围不同，需测试适用性。
• 模块路径：确保正确导入 langchain_core.embeddings.Embeddings。
• 版本依赖：功能可能受版本限制，需确保兼容最新版本。

7. 结论

langchain_core.embeddings.Embeddings 是 LangChain 框架中用于定义文本嵌入模型标准接口的抽象基类，通过 embed_documents 和 embed_query 方法支持文本向量化，广泛应用于语义搜索、向量存储和 RAG 应用。其统一接口和异步支持确保了不同嵌入模型的互换性和高效性。结合具体子类（如 OpenAIEmbeddings）、向量存储和 LangChain 生态系统，开发者可以构建强大的语义处理系统。遵循最佳实践并注意版本要求，将有助于充分发挥其功能。

8. 参考资料

• LangChain 嵌入模型文档
• Embeddings API 参考
• LangChain 嵌入文本指南
• LangChain 解码：第二部分 - 嵌入
• Stack Overflow：如何在本地使用自定义嵌入模型