【LangChain】核心技术：嵌入模型与向量存储完全指南

🔥草莓熊Lotso： 个人主页
❄️个人专栏: 《C++知识分享》《Linux 入门到实践：零基础也能懂》
✨生活是默默的坚持，毅力是永久的享受！

🎬 博主简介：

文章目录

前言
[一. 什么是向量与嵌入](#一. 什么是向量与嵌入)
- [1.1 向量的基本概念](#1.1 向量的基本概念)
- [1.2 语义相似度计算](#1.2 语义相似度计算)
[二. 嵌入模型详解](#二. 嵌入模型详解)
- [2.1 嵌入模型 vs 生成式模型](#2.1 嵌入模型 vs 生成式模型)
- [2.2 LangChain 嵌入模型接口](#2.2 LangChain 嵌入模型接口)
- [2.3 嵌入模型的应用场景](#2.3 嵌入模型的应用场景)
[三. 向量数据库核心原理](#三. 向量数据库核心原理)
- [3.1 为什么需要向量数据库](#3.1 为什么需要向量数据库)
- [3.2 向量数据库的三大核心能力](#3.2 向量数据库的三大核心能力)
[四. LangChain 向量存储实战（这里可以先简单看看，后续还会有更加详细的讲解）](#四. LangChain 向量存储实战（这里可以先简单看看，后续还会有更加详细的讲解）)
- [4.1 内存存储 InMemoryVectorStore](#4.1 内存存储 InMemoryVectorStore)
- [4.2 Redis 向量存储（推荐生产环境）](#4.2 Redis 向量存储（推荐生产环境）)
- [4.3 Pinecone 云向量存储](#4.3 Pinecone 云向量存储)
结尾：

前言

在大语言模型（LLM）应用开发中，检索增强生成（RAG） 已经成为解决大模型 "知识截止" 和 "私有数据访问" 问题的标准方案。而 RAG 系统的核心基石，正是嵌入模型（Embedding Models） 和向量存储（Vector Stores）。很多开发者在入门时容易混淆这两个概念：嵌入模型负责将人类语言转换为计算机能理解的数值向量，而向量存储则负责高效管理和检索这些高维向量。本文将从底层原理到实战代码，全面拆解 LangChain 中这两个核心组件的使用方法，帮助你构建稳定高效的 RAG 系统。

一. 什么是向量与嵌入

1.1 向量的基本概念

计算机天生擅长处理数字，但无法直接理解文字、图片等人类符号。嵌入（Embedding） 的核心思想就是：将人类世界的符号（单词、句子、图片、用户等）转换为计算机能够理解的数值向量 （本质是一个数字列表），并且要求这种转换能够保留原始符号的语义和关系。

我们可以把它想象成一个 "翻译" 过程：

Plain 复制代码

"我喜欢猫" → 嵌入模型 → [0.023, 0.487, -0.129, ..., 0.325] (3072维向量)

向量有两个关键属性：

向量维度 ：向量列表的固定长度。例如 OpenAI 的 text-embedding-3-large 生成 3072 维向量，而早期的 text-embedding-ada-002 只有 1536 维。维度越高，能捕捉的语义信息越细微，但计算和存储成本也越高。
向量空间：可以想象成一个拥有无数维度的 "宇宙"，每个向量都是这个宇宙中的一个点。语义相近的内容，在向量空间中的距离也会更近。

1.2 语义相似度计算

有了向量表示，我们就可以用数学方法衡量两段文本的语义相似度，最常用的两种计算方式是：

计算方式	原理	适用场景
欧氏距离	两点之间的直线距离，距离越短相似度越高	数据规模小、维度低的场景
余弦相似度	忽略向量绝对长度，只关注方向差异。方向越一致，相似度越高	文本语义匹配（推荐），因为文本长度不影响语义

在文本处理中，余弦相似度几乎是标准选择，因为它只关心 "含义是否相同"，而不关心 "文本长短"。

二. 嵌入模型详解

2.1 嵌入模型 vs 生成式模型

很多人容易混淆这两种模型，它们的核心目标完全不同：

生成式模型（如 GPT-4o、DeepSeek）：理解输入并生成新的文本（回答问题、写文章），目标是 "创造"。
嵌入模型（如 text-embedding-3-large、Qwen3-Embedding）：为输入文本创建富含语义的数值表示，目标是 "表示"。

2.2 LangChain 嵌入模型接口

LangChain 提供了统一的 Embeddings 抽象接口，支持几乎所有主流嵌入模型提供商：

OpenAI：pip install -U langchain-openai
Ollama：pip install -U langchain-ollama
Google Gemini：pip install -U langchain-google-genai
通义千问：pip install -U langchain-community

嵌入模型有两个核心方法，这是很多初学者容易混淆的点：

python 复制代码

from langchain_openai import OpenAIEmbeddings

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

# 1. 嵌入单个查询（用于搜索）
query_vector = embeddings.embed_query("项目中遇到了哪些挑战？")
print(f"查询向量维度: {len(query_vector)}")  # 输出: 3072

# 2. 嵌入多个文档（用于构建知识库）
documents = [
    "狗是很好的伴侣，以忠诚和友好而闻名。",
    "猫是独立的宠物，经常享受自己的空间。"
]
docs_vectors = embeddings.embed_documents(documents)
print(f"生成了 {len(docs_vectors)} 个文档向量")  # 输出: 2

为什么要分两个方法？ 某些嵌入模型提供商（如 OpenAI、Cohere）会针对 "被搜索的文档" 和 "搜索查询本身" 采用不同的优化策略，即使底层是同一个模型，也可能添加不同的指令前缀，以获得更好的搜索效果。

2.3 嵌入模型的应用场景

语义搜索：不依赖关键词匹配，而是根据含义搜索。例如搜索 "一种红色的水果"，能找到关于 "苹果" 的文档。
检索增强生成（RAG）：这是当前最主流的应用，先从知识库中检索相关内容，再交给 LLM 生成答案。
推荐系统：将用户和物品都转换为向量，根据相似度进行推荐。
异常检测：正常数据的向量会聚集在一起，远离聚集区的向量就是异常点。

三. 向量数据库核心原理

3.1 为什么需要向量数据库

如果只有几个文档，我们可以手动计算余弦相似度进行搜索。但当文档数量达到百万、千万级时，暴力搜索的时间复杂度是 O (n)，完全无法接受。

向量数据库 就是专门为解决这个问题设计的，它的核心任务是：高效存储和检索高维向量，实现基于内容的相似性搜索。

3.2 向量数据库的三大核心能力

1. 专门的索引结构（灵魂）

向量数据库不会使用暴力搜索，而是采用近似最近邻（ANN）搜索：为了追求极致速度，愿意牺牲一点点精度，以极高的概率找到非常相似的向量。

主流的索引技术：

IVF（倒排文件）：基于聚类的方法，先将向量空间分成多个簇，搜索时只在最相关的几个簇中查找。
HNSW（分层导航小世界） ：基于图结构的方法，也是当前最主流的索引。可以用 "找城市" 的比喻理解：
- 第一层（顶层）：只有国家节点，先定位到中国
- 第二层：中国的省份节点，定位到湖北省
- 第三层：湖北省的城市节点，最终找到武汉市
- 优势：查询速度极快，支持高并发

2. 向量相似度计算优化

向量数据库底层使用高度优化的库（如 Facebook 的 FAISS），充分利用 CPU 的 SIMD 指令集（单指令多数据流）和 GPU 的并行计算能力，让大规模向量运算速度提升几个数量级。

3. 完整的数据管理功能

CRUD 操作：支持动态增删改查向量数据
元数据过滤：这是非常关键的功能！可以先根据元数据（如创建时间、作者、类别）过滤文档，再在缩小的范围内进行向量搜索
可扩展性与持久化：支持分布式部署，保证数据不丢失
集成方便：提供友好的 API，与 LangChain 等框架无缝集成

四. LangChain 向量存储实战（这里可以先简单看看，后续还会有更加详细的讲解）

LangChain 支持几乎所有主流向量数据库，本文将演示最常用的三种：内存存储（开发测试）、Redis（生产环境）和 Pinecone（云服务）。

4.1 内存存储 InMemoryVectorStore

适合开发和测试环境，数据存储在内存中，程序退出后丢失。

python 复制代码

from langchain_openai import OpenAIEmbeddings
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_community.document_loaders import UnstructuredMarkdownLoader
from langchain_text_splitters import CharacterTextSplitter

# 1. 初始化嵌入模型和向量存储
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
vector_store = InMemoryVectorStore(embedding=embeddings)

# 2. 加载并分割文档
loader = UnstructuredMarkdownLoader("../Docs/脚手架级微服务租房平台Q&A.md")
data = loader.load()

text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
    encoding_name="cl100k_base",
    chunk_size=200,
    chunk_overlap=50
)
documents = text_splitter.split_documents(data)

# 3. 添加文档到向量存储（自动生成向量）
ids = vector_store.add_documents(documents=documents)
print(f"共添加了 {len(ids)} 个文档")

# 4. 相似性搜索
search_docs = vector_store.similarity_search(
    query="数据库表怎么设计的?",
    k=2  # 返回最相似的2个文档
)

for i, doc in enumerate(search_docs):
    print(f"\n=== 相似文档 {i+1} ===")
    print(doc.page_content[:200])

4.2 Redis 向量存储（推荐生产环境）

大多数开发者都熟悉 Redis，从 Redis 7.2 开始，RediSearch 模块原生支持向量存储和搜索，无需额外部署其他组件。

前置准备：

启动 Redis 服务：docker run -d -p 6379:6379 redis/redis-stack:latest
安装依赖：pip install redis langchain-redis

python 复制代码

from langchain_openai import OpenAIEmbeddings
from langchain_redis import RedisConfig, RedisVectorStore
from redisvl.query.filter import Tag, Num

# 1. 配置 Redis 连接
redis_url = "redis://localhost:6379"
config = RedisConfig(
    index_name="qa",  # 索引名称
    redis_url=redis_url,
    # 定义元数据字段类型，用于后续过滤
    metadata_schema=[
        {"name": "category", "type": "tag"},
        {"name": "num", "type": "numeric"},
    ],
)

# 2. 初始化向量存储
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
vector_store = RedisVectorStore(embeddings, config=config)

# 3. 添加文档并设置元数据
for i, doc in enumerate(documents, start=1):
    doc.metadata["category"] = "QA"
    doc.metadata["num"] = i

vector_store.add_documents(documents=documents)

# 4. 带元数据过滤的相似性搜索
filter_condition = Tag("category") == "QA" & Num("num") < 50
scored_results = vector_store.similarity_search_with_score(
    query="数据库表怎么设计的?",
    k=2,
    filter=filter_condition
)

for doc, score in scored_results:
    print(f"\n=== 相似度得分: {score:.4f} ===")
    print(f"文档编号: {doc.metadata['num']}")
    print(doc.page_content[:200])

# 5. 最大边际相关性搜索（MMR）
# 既保证相关性，又保证结果多样性，避免信息重复
mmr_results = vector_store.max_marginal_relevance_search(
    query="数据库表怎么设计的?",
    k=2,
    fetch_k=10  # 先获取10个最相似的文档，再从中选2个最多样化的
)

4.3 Pinecone 云向量存储

Pinecone 是全托管的云向量数据库服务，无需自己运维，支持自动扩展，适合大规模生产环境。

python 复制代码

from langchain_openai import OpenAIEmbeddings
from langchain_pinecone import PineconeVectorStore
from pinecone import Pinecone, ServerlessSpec

# 1. 初始化 Pinecone 客户端（需要先设置 PINECONE_API_KEY 环境变量）
pc = Pinecone()
index_name = "qa"

# 2. 创建索引（如果不存在）
if not pc.has_index(index_name):
    pc.create_index(
        name=index_name,
        dimension=3072,  # 必须与嵌入模型维度一致
        metric="cosine",
        spec=ServerlessSpec(
            cloud="aws",
            region="us-east-1"
        ),
    )

# 3. 初始化向量存储
index = pc.Index(index_name)
vector_store = PineconeVectorStore(embedding=embeddings, index=index)

# 4. 添加文档和搜索（用法与 Redis 完全一致）
vector_store.add_documents(documents=documents)
search_docs = vector_store.similarity_search("数据库表怎么设计的?", k=2)

核心考点总结

嵌入模型的两个核心方法 ：
1. embed_query()：用于嵌入单个查询，返回一维向量
2. embed_documents()：用于嵌入多个文档，返回二维向量列表
3. 分开设计是为了针对不同场景进行优化，获得更好的搜索效果
向量数据库的核心优势 ：
1. 采用 ANN 近似最近邻搜索，用精度换速度，支持大规模数据检索
2. 支持元数据过滤，先过滤再搜索，提升准确性和效率
3. 提供完整的 CRUD 和分布式部署能力
常见向量数据库对比 ：
1. InMemoryVectorStore：开发测试用，数据不持久化
2. Redis：适合已有 Redis 基础设施的团队，部署简单
3. Pinecone：全托管云服务，无需运维，适合大规模应用
4. Chroma：轻量级本地向量数据库，适合个人项目
RAG 完整流程回顾 ：
1. 离线阶段：加载文档 → 分割文档 → 嵌入文档 → 存储到向量数据库
2. 在线阶段：嵌入用户查询 → 向量数据库搜索相似文档 → 将查询和文档一起交给 LLM → 生成答案

结尾：

html 复制代码

🍓 我是草莓熊 Lotso！若这篇技术干货帮你打通了学习中的卡点：
👀 【关注】跟我一起深耕技术领域，从基础到进阶，见证每一次成长
❤️ 【点赞】让优质内容被更多人看见，让知识传递更有力量
⭐ 【收藏】把核心知识点、实战技巧存好，需要时直接查、随时用
💬 【评论】分享你的经验或疑问（比如曾踩过的技术坑？），一起交流避坑
🗳️ 【投票】用你的选择助力社区内容方向，告诉大家哪个技术点最该重点拆解
技术之路难免有困惑，但同行的人会让前进更有方向～愿我们都能在自己专注的领域里，一步步靠近心中的技术目标！

结语：嵌入模型和向量存储是构建现代 AI 应用的基础技术，它们让大模型能够访问和利用私有数据、实时数据，极大地扩展了 LLM 的能力边界。本文从底层原理到实战代码，全面讲解了 LangChain 中这两个核心组件的使用方法。在下一篇文章中，我们将基于今天的内容，完整实现一个生产级的 RAG 问答系统，包括检索器的优化、提示词工程和流式输出等高级特性。如果本文对你有帮助，欢迎点赞、收藏、关注，我会持续分享更多 LangChain 和 AI 应用开发的实战内容。

✨把这些内容吃透超牛的！放松下吧✨ ʕ˘ᴥ˘ʔ づきらど