从零搭建 RAG 完整指南（LangChain + 向量数据库 + LLM）

目录

什么是 RAG

RAG（Retrieval-Augmented Generation，检索增强生成） 是一种结合检索和生成的 AI 技术架构。

核心流程

用户提问 → 检索相关知识 → 组装上下文 → LLM 生成回答

通俗理解

RAG 就像是给大语言模型配备了一个"开卷考试"的能力：

  • 传统 LLM：闭卷考试，全靠训练时 memorized 的知识

  • RAG 增强的 LLM：开卷考试，可以查阅参考书后作答

为什么需要 RAG

大语言模型的三大痛点

问题

描述

案例

幻觉问题

模型会编造看似合理但错误的信息

"鲁迅在 2020 年获得诺贝尔奖"

知识过时

训练数据有截止时间，不知道最新信息

不知道 2024 年的新闻

私有数据

无法访问企业内部知识库

公司文档、产品手册无法利用

RAG 的优势

  1. ✅ 减少幻觉 - 基于真实资料回答，有据可查

  2. ✅ 支持最新数据 - 知识库可随时更新

  3. ✅ 利用私有数据 - 企业内部文档可用

  4. ✅ 回答可溯源 - 可以知道答案来自哪份文档

  5. ✅ 成本更低 - 无需频繁微调模型

RAG 核心架构

基本架构图

┌─────────────────────────────────────────────────────────┐
│                    用户提问                              │
│              "公司的年假政策是什么？"                      │
└────────────────────┬────────────────────────────────────┘
                     ↓
        ┌────────────────────────┐
        │   1. 问题向量化         │
        │   (Embedding)          │
        └────────────┬───────────┘
                     ↓
        ┌────────────────────────┐
        │   2. 向量数据库检索     │
        │   查找最相关的文档片段   │
        └────────────┬───────────┘
                     ↓
        ┌────────────────────────┐
        │   3. 组装上下文         │
        │   问题 + 检索到的资料    │
        └────────────┬───────────┘
                     ↓
        ┌────────────────────────┐
        │   4. LLM 生成回答       │
        │   基于上下文生成答案    │
        └───────────────────────┘
                     ↓
        ┌────────────────────────┐
        │   5. 返回答案           │
        │   "根据公司政策，..."    │
        └────────────────────────┘

核心组件

  1. 文档处理模块

    • 文档加载（PDF、Word、Markdown 等）

    • 文本分块（Chunking）

    • 数据清洗

  2. 向量化模块

    • Embedding 模型

    • 向量生成

  3. 存储模块

    • 向量数据库

    • 索引管理

  4. 检索模块

    • 相似度搜索

    • 排序过滤

  5. 生成模块

    • LLM 接入

    • Prompt 工程

技术栈选型

完整技术栈

组件

推荐方案

备选方案

编排框架

LangChain

LlamaIndex

向量数据库

Chroma

FAISS、Milvus、Qdrant、Weaviate

Embedding 模型

OpenAI text-embedding-3-small

BGE、M3E、text2vec

LLM

GPT-4、Claude

通义千问、文心一言、ChatGLM

本地 LLM

Ollama（Qwen2.5、Llama3）

LM Studio

新手推荐组合

快速入门（10 分钟跑通）：

LangChain + Chroma + OpenAI API

完全免费（本地运行）：

LangChain + Chroma + Ollama + BGE Embedding

企业级部署：

LangChain + Milvus + 商业 LLM API

环境准备

安装依赖

# 基础依赖
pip install langchain langchain-community langchain-openai

# 向量数据库
pip install chromadb faiss-cpu

# 文档处理
pip install pypdf python-docx markdown

# 本地模型（可选）
pip install sentence-transformers

完整 requirements.txt

langchain==0.1.0
langchain-community==0.0.10
langchain-openai==0.0.2
chromadb==0.4.22
faiss-cpu==1.7.4
pypdf==4.0.0
python-docx==1.1.0
markdown==3.5.2
sentence-transformers==2.3.1

环境变量配置

# OpenAI API（如果使用）
export OPENAI_API_KEY="your-api-key"

# 或者使用本地模型（无需 API Key）
# 安装 Ollama: https://ollama.ai

极简 RAG 实现（纯 Python）

不依赖任何库的 RAG 示例

# 1. 构造知识库
knowledge_base = [
    "Python 是一种解释型、高级编程语言。",
    "RAG 是检索增强生成，用于让大模型引用外部知识。",
    "大模型容易产生幻觉，RAG 可以减少幻觉。",
    "向量数据库用于存储文本的向量表示，方便快速检索。"
]

# 2. 简单检索（关键词匹配）
def retrieve(query, docs):
    """检索与查询相关的文档"""
    results = []
    query_words = query.lower().split()
    for doc in docs:
        # 检查是否包含查询词
        if any(word in doc.lower() for word in query_words):
            results.append(doc)
    return results

# 3. 模拟生成
def generate_answer(query, context):
    """根据上下文生成答案"""
    if not context:
        return "抱歉，没有相关资料。"
    
    # 简单拼接（实际应调用 LLM）
    return f"根据资料：{context[0]}"

# 4. RAG 主流程
def rag(query):
    """完整的 RAG 流程"""
    # 检索
    context = retrieve(query, knowledge_base)
    # 生成
    return generate_answer(query, context)

# 5. 测试
if __name__ == "__main__":
    print("问题：什么是 RAG？")
    print("答案：", rag("什么是 RAG？"))
    
    print("\n问题：Python 是什么？")
    print("答案：", rag("Python 是什么？"))

运行结果

问题：什么是 RAG？
答案：根据资料：RAG 是检索增强生成，用于让大模型引用外部知识。

问题：Python 是什么？
答案：根据资料：Python 是一种解释型、高级编程语言。

使用 LangChain 实现完整 RAG

完整代码示例

from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import FakeEmbeddings
from langchain_text_splitters import CharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.llms import FakeListLLM

# ========== 1. 准备数据 ==========
documents = [
    "Python 是一种解释型、高级编程语言，由 Guido van Rossum 于 1991 年发明。",
    "RAG（Retrieval-Augmented Generation）是检索增强生成技术。",
    "大模型容易产生幻觉，RAG 可以通过检索外部知识减少幻觉。",
    "向量数据库专门用于存储和检索向量数据，支持相似度搜索。",
    "LangChain 是用于开发大语言模型应用的框架。"
]

# ========== 2. 文本分块 ==========
text_splitter = CharacterTextSplitter(
    chunk_size=100,      # 每块 100 字符
    chunk_overlap=20,    # 重叠 20 字符
    separator="。"       # 按句号分割
)

chunks = text_splitter.create_documents(documents)

# ========== 3. 创建向量数据库 ==========
# 使用模拟 Embedding（实际使用时替换为真实模型）
embedding = FakeEmbeddings(size=10)

# 创建 Chroma 向量库
db = Chroma.from_documents(
    documents=chunks,
    embedding=embedding,
    persist_directory="./chroma_db"  # 持久化存储
)

# ========== 4. 创建检索器 ==========
retriever = db.as_retriever(
    search_type="similarity",  # 相似度搜索
    search_kwargs={"k": 2}     # 返回最相关的 2 条
)

# ========== 5. 创建 LLM ==========
# 使用模拟 LLM（实际使用时替换为真实 API）
llm = FakeListLLM(
    responses=[
        "根据检索到的资料，Python 是一种高级编程语言。",
        "RAG 是检索增强生成技术，可以减少大模型幻觉。"
    ]
)

# ========== 6. 创建 RAG 链 ==========
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",        # 将所有文档拼接到一个 prompt
    retriever=retriever,
    return_source_documents=True  # 返回来源文档
)

# ========== 7. 提问测试 ==========
query = "什么是 RAG？"
result = qa_chain.invoke(query)

print(f"问题：{query}")
print(f"答案：{result['result']}")
print(f"参考文档：{result['source_documents']}")

使用真实的 OpenAI 模型

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# Embedding 模型
embedding = OpenAIEmbeddings(
    model="text-embedding-3-small",
    openai_api_key="your-api-key"
)

# LLM 模型
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0.7,
    openai_api_key="your-api-key"
)

# 其他代码保持不变...

使用本地 Ollama 模型（免费）

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings

# Embedding（需要 Ollama 安装 nomic-embed-text 模型）
embedding = OllamaEmbeddings(
    model="nomic-embed-text",
    base_url="http://localhost:11434"
)

# LLM（使用 Qwen2.5 或 Llama3）
llm = Ollama(
    model="qwen2.5:7b",
    base_url="http://localhost:11434"
)

更换向量数据库

LangChain 的优势：统一接口

更换向量数据库只需修改一行代码！

1. FAISS（Facebook AI 相似性搜索）

from langchain_community.vectorstores import FAISS

db = FAISS.from_documents(chunks, embedding)
# 保存
db.save_local("./faiss_index")
# 加载
# db = FAISS.load_local("./faiss_index", embedding)

特点：

  • ✅ 速度快

  • ✅ 轻量级

  • ❌ 不支持持久化（需手动保存）

  • ❌ 不支持分布式

2. Milvus（企业级向量数据库）

from langchain_community.vectorstores import Milvus

db = Milvus.from_documents(
    chunks,
    embedding,
    connection_args={
        "host": "localhost",
        "port": "19530"
    },
    index_params={
        "metric_type": "COSINE",
        "index_type": "HNSW"
    }
)

特点：

  • ✅ 企业级性能

  • ✅ 支持大规模数据

  • ✅ 支持分布式

  • ❌ 部署复杂

3. Qdrant（云原生向量数据库）

from langchain_community.vectorstores import Qdrant

db = Qdrant.from_documents(
    chunks,
    embedding,
    url="http://localhost:6333",
    api_key="your-api-key",  # 可选
    collection_name="my_rag"
)

特点：

  • ✅ 云原生设计

  • ✅ 支持 Docker 部署

  • ✅ RESTful API

  • ✅ 免费云托管

4. Chroma（新手友好）

from langchain_community.vectorstores import Chroma

db = Chroma.from_documents(
    documents=chunks,
    embedding=embedding,
    persist_directory="./chroma_db"
)

特点：

  • ✅ 简单易用

  • ✅ 内置持久化

  • ✅ 无需额外部署

  • ✅ 适合原型开发

向量数据库对比

数据库

易用性

性能

扩展性

适用场景

Chroma

⭐⭐⭐⭐⭐

⭐⭐⭐

⭐⭐

原型、小项目

FAISS

⭐⭐⭐⭐

⭐⭐⭐⭐⭐

⭐⭐

本地应用

Milvus

⭐⭐⭐

⭐⭐⭐⭐⭐

⭐⭐⭐⭐⭐

企业级

Qdrant

⭐⭐⭐⭐

⭐⭐⭐⭐

⭐⭐⭐⭐

云服务

接入真实 LLM

方案 1：OpenAI API

from langchain_openai import ChatOpenAI
import os

os.environ["OPENAI_API_KEY"] = "sk-..."

llm = ChatOpenAI(
    model="gpt-4o",           # 或 gpt-3.5-turbo
    temperature=0.7,          # 创造性 0-1
    max_tokens=1000           # 最大输出长度
)

价格：

  • GPT-4o: $2.5 / 1M tokens（输入）

  • GPT-3.5-turbo: $0.5 / 1M tokens（输入）

方案 2：Claude API（Anthropic）

from langchain_anthropic import ChatAnthropic
import os

os.environ["ANTHROPIC_API_KEY"] = "sk-ant-..."

llm = ChatAnthropic(
    model="claude-3-5-sonnet-20241022",
    temperature=0.7,
    max_tokens=1000
)

价格：

  • Claude 3.5 Sonnet: $3 / 1M tokens（输入）

方案 3：国产大模型

通义千问（阿里云）
from langchain_community.llms import Tongyi
import os

os.environ["DASHSCOPE_API_KEY"] = "sk-..."

llm = Tongyi(
    model="qwen-max",  # 或 qwen-plus
    temperature=0.7
)

价格：免费额度 + 按量付费

文心一言（百度）
from langchain_community.llms import QianfanLLMEndpoint
import os

os.environ["QIANFAN_AK"] = "your-access-key"
os.environ["QIANFAN_SK"] = "your-secret-key"

llm = QianfanLLMEndpoint(
    model="ERNIE-Bot-4",
    temperature=0.7
)

方案 4：本地部署（完全免费）

使用 Ollama
# 1. 安装 Ollama
# 访问 https://ollama.ai 下载安装

# 2. 下载模型
ollama pull qwen2.5:7b      # 通义千问 7B
ollama pull llama3:8b       # Llama 3 8B
ollama pull mistral:7b      # Mistral 7B

# 3. 运行
ollama run qwen2.5:7b
from langchain_community.llms import Ollama

llm = Ollama(
    model="qwen2.5:7b",
    base_url="http://localhost:11434",
    temperature=0.7
)
模型推荐

模型

大小

显存需求

速度

质量

Qwen2.5:7b

7B

8GB

快

⭐⭐⭐⭐

Llama3:8b

8B

8GB

快

⭐⭐⭐⭐

Qwen2.5:14b

14B

16GB

中

⭐⭐⭐⭐⭐

Mistral:7b

7B

8GB

快

⭐⭐⭐⭐

文档加载与分块

加载各种格式文档

PDF 文档
from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("company_handbook.pdf")
documents = loader.load()

print(f"加载了 {len(documents)} 页文档")
Word 文档
from langchain_community.document_loaders import Docx2txtLoader

loader = Docx2txtLoader("product_manual.docx")
documents = loader.load()
Markdown 文件
from langchain_community.document_loaders import UnstructuredMarkdownLoader

loader = UnstructuredMarkdownLoader("README.md")
documents = loader.load()
批量加载文件夹
from langchain_community.document_loaders import DirectoryLoader

# 加载目录下所有 PDF
loader = DirectoryLoader(
    "./docs/",
    glob="**/*.pdf",
    loader_cls=PyPDFLoader
)
documents = loader.load()

文本分块策略

1. 固定长度分块
from langchain_text_splitters import CharacterTextSplitter

splitter = CharacterTextSplitter(
    chunk_size=500,      # 每块 500 字符
    chunk_overlap=50,    # 重叠 50 字符
    separator="\n"       # 分隔符
)

chunks = splitter.split_documents(documents)
2. 递归分块（推荐）
from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", "。", ".", " "]  # 优先级分隔符
)

chunks = splitter.split_documents(documents)
3. 按 Token 分块（更精确）
from langchain_text_splitters import TokenTextSplitter

splitter = TokenTextSplitter(
    chunk_size=500,      # 500 tokens
    chunk_overlap=50
)

chunks = splitter.split_documents(documents)

分块大小建议

场景

chunk_size

chunk_overlap

短文本（FAQ）

200-300

50

一般文档

500-800

100-200

长文档（书籍）

1000-2000

200-400

代码文件

300-500

50-100

高级优化技巧

1. 混合检索（关键词 + 向量）

from langchain.retrievers import EnsembleRetriever
from langchain_community.vectorstores import Chroma
from langchain_community.retrievers import BM25Retriever

# 向量检索
vector_retriever = db.as_retriever(search_kwargs={"k": 3})

# 关键词检索（BM25）
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 3

# 混合检索
ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.3, 0.7]  # 权重分配
)

2. 重排序（Re-ranking）

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# 使用 LLM 对检索结果重排序
compressor = LLMChainExtractor.from_llm(llm)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=db.as_retriever()
)

3. 多查询检索

from langchain.retrievers.multi_query import MultiQueryRetriever

# 让 LLM 生成多个角度的查询
retriever = MultiQueryRetriever.from_llm(
    retriever=db.as_retriever(),
    llm=llm
)

# 会自动生成 3-5 个不同问法，合并结果

4. 元数据过滤

# 添加元数据
for doc in chunks:
    doc.metadata["source"] = "handbook"
    doc.metadata["category"] = "policy"
    doc.metadata["year"] = 2024

# 检索时过滤
retriever = db.as_retriever(
    search_kwargs={
        "k": 3,
        "filter": {"category": "policy", "year": 2024}
    }
)

5. 父子文档检索

from langchain.retrievers import ParentDocumentRetriever

# 大文档用于检索上下文，小 chunk 用于向量匹配
retriever = ParentDocumentRetriever(
    vectorstore=db,
    docstore=InMemoryDocstore(),
    child_splitter=CharacterTextSplitter(chunk_size=200),
    parent_splitter=CharacterTextSplitter(chunk_size=1000)
)

6. 对话式 RAG（支持多轮对话）

from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory

# 添加对话记忆
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 创建对话式 RAG 链
conversational_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=db.as_retriever(),
    memory=memory,
    return_source_documents=True
)

# 多轮对话
result1 = conversational_chain({"question": "什么是 RAG？"})
result2 = conversational_chain({"question": "它有什么好处？"})  # 能理解"它"指代 RAG

常见问题

Q1: RAG 和微调（Fine-tuning）有什么区别？

维度

RAG

微调

原理

检索外部知识

调整模型参数

成本

低

高

更新知识

容易（更新文档）

困难（重新训练）

可解释性

高（可溯源）

低

适用场景

知识库问答

风格适配、任务特化

建议：优先用 RAG，特殊需求再微调

Q2: 如何提高检索准确率？

  1. 优化分块 - 合理设置 chunk_size

  2. 增加重叠 - chunk_overlap 设为 10-20%

  3. 混合检索 - 关键词 + 向量

  4. 重排序 - 使用 LLM 重排结果

  5. 元数据过滤 - 添加分类、时间等标签

Q3: Embedding 模型选哪个？

英文：

  • OpenAI text-embedding-3-small（性价比高）

  • BGE-large-en（开源最佳）

中文：

  • BGE-large-zh

  • M3E-base

  • text2vec

多语言：

  • m3e-base

  • LaBSE

Q4: 向量数据库如何选择？

  • 快速原型 → Chroma

  • 本地应用 → FAISS

  • 中小项目 → Qdrant

  • 企业部署 → Milvus

Q5: 如何处理超长文档？

# 1. 分段加载
loader = PyPDFLoader("book.pdf")
pages = loader.load_and_split()

# 2. 使用 Map-Reduce
from langchain.chains import MapReduceDocumentsChain

# 3. 增加 chunk_size
splitter = RecursiveCharacterTextSplitter(
    chunk_size=2000,
    chunk_overlap=400
)

Q6: RAG 响应慢怎么办？

  1. 减少检索数量 - search_kwargs={"k": 3}

  2. 使用缓存 - 缓存常见问题答案

  3. 异步处理 - 先返回"正在检索"

  4. 优化模型 - 使用更小的 LLM

Q7: 如何评估 RAG 效果？

评估指标：

  1. 检索准确率 - 检索到的文档是否相关

  2. 回答质量 - LLM 回答是否准确

  3. 响应时间 - 端到端延迟

  4. 用户满意度 - 点赞/点踩

评估方法：

# 构建测试集
test_questions = [
    ("问题 1", "期望答案要点 1"),
    ("问题 2", "期望答案要点 2"),
]

# 人工评估或使用 LLM 评估

完整项目示例

项目结构

rag_project/
├── data/                    # 文档数据
│   ├── handbook.pdf
│   └── faq.md
├── src/
│   ├── __init__.py
│   ├── loader.py           # 文档加载
│   ├── embeddings.py       # 向量化
│   ├── retriever.py        # 检索
│   └── rag.py              # RAG 主流程
├── requirements.txt
└── main.py                 # 入口文件

loader.py - 文档加载

from langchain_community.document_loaders import (
    PyPDFLoader,
    UnstructuredMarkdownLoader,
    DirectoryLoader
)

def load_documents(data_dir: str):
    """加载指定目录下的所有文档"""
    documents = []
    
    # 加载 PDF
    pdf_loader = DirectoryLoader(
        data_dir,
        glob="**/*.pdf",
        loader_cls=PyPDFLoader
    )
    documents.extend(pdf_loader.load())
    
    # 加载 Markdown
    md_loader = DirectoryLoader(
        data_dir,
        glob="**/*.md",
        loader_cls=UnstructuredMarkdownLoader
    )
    documents.extend(md_loader.load())
    
    return documents

embeddings.py - 向量化

from langchain_community.embeddings import HuggingFaceEmbeddings

def get_embedding_model(model_name: str = "BAAI/bge-large-zh-v1.5"):
    """获取 Embedding 模型"""
    return HuggingFaceEmbeddings(
        model_name=model_name,
        model_kwargs={'device': 'cpu'},
        encode_kwargs={'normalize_embeddings': True}
    )

retriever.py - 检索器

from langchain_community.vectorstores import Chroma
from langchain_text_splitters import RecursiveCharacterTextSplitter

def create_retriever(documents, embedding_model):
    """创建检索器"""
    # 文本分块
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=800,
        chunk_overlap=200,
        separators=["\n\n", "\n", "。", ".", " "]
    )
    
    chunks = splitter.split_documents(documents)
    
    # 创建向量库
    db = Chroma.from_documents(
        documents=chunks,
        embedding=embedding_model,
        persist_directory="./chroma_db"
    )
    
    # 创建检索器
    retriever = db.as_retriever(
        search_type="similarity",
        search_kwargs={"k": 3}
    )
    
    return retriever

rag.py - RAG 主流程

from langchain.chains import RetrievalQA
from langchain_community.llms import Ollama

def create_rag_chain(retriever, llm_model: str = "qwen2.5:7b"):
    """创建 RAG 问答链"""
    # 加载 LLM
    llm = Ollama(
        model=llm_model,
        base_url="http://localhost:11434",
        temperature=0.7
    )
    
    # 创建 RAG 链
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=retriever,
        return_source_documents=True
    )
    
    return qa_chain

main.py - 入口文件

from src.loader import load_documents
from src.embeddings import get_embedding_model
from src.retriever import create_retriever
from src.rag import create_rag_chain

def main():
    # 1. 加载文档
    print("正在加载文档...")
    documents = load_documents("./data")
    print(f"加载了 {len(documents)} 份文档")
    
    # 2. 初始化 Embedding
    print("正在初始化 Embedding 模型...")
    embedding = get_embedding_model()
    
    # 3. 创建检索器
    print("正在创建向量数据库...")
    retriever = create_retriever(documents, embedding)
    
    # 4. 创建 RAG 链
    print("正在初始化 LLM...")
    rag_chain = create_rag_chain(retriever)
    
    # 5. 开始问答
    print("\n🤖 RAG 助手已就绪！输入'quit'退出\n")
    
    while True:
        query = input("你：").strip()
        if query.lower() in ['quit', 'exit', '退出']:
            break
        
        result = rag_chain.invoke({"query": query})
        print(f"\n助手：{result['result']}\n")
        
        # 显示来源
        if result.get('source_documents'):
            print("参考文档:")
            for i, doc in enumerate(result['source_documents'], 1):
                print(f"  {i}. {doc.page_content[:100]}...")
            print()

if __name__ == "__main__":
    main()

运行项目

# 1. 安装依赖
pip install -r requirements.txt

# 2. 启动 Ollama（如果使用本地模型）
ollama serve

# 3. 运行项目
python main.py

总结

RAG 核心要点

  1. RAG = 检索 + 增强 + 生成

  2. 核心价值 - 减少幻觉、支持私有数据、回答可溯源

  3. 技术栈 - LangChain + 向量数据库 + LLM

  4. 关键步骤 - 文档加载 → 分块 → 向量化 → 检索 → 生成

新手学习路径

1. 理解 RAG 原理（1 小时）
   ↓
2. 跑通极简 Python 示例（30 分钟）
   ↓
3. 使用 LangChain + Chroma + OpenAI（2 小时）
   ↓
4. 切换到本地模型 Ollama（1 小时）
   ↓
5. 加载真实文档数据（2 小时）
   ↓
6. 优化检索效果（持续）

最佳实践

  • ✅ 从简单开始，先跑通再优化

  • ✅ 选择合适的 chunk_size（500-800）

  • ✅ 使用混合检索提高准确率

  • ✅ 添加元数据便于过滤

  • ✅ 评估检索效果再调优

下一步学习

  •  LangChain 官方文档

  • 向量数据库原理

  • Prompt 工程

  •  Embedding 模型原理

  • RAG 高级技巧（HyDE、FLARE 等）

# 人工智能
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

三条定律，三种出手姿势为什么 Profit Law 原生系统是前两代架构无法改造出来的

Scaling Law 系统的模型选择、上下文设计、输出格式——这些在没有 Token Cost 意识时做出，锁死了大量不可逆的成本。如果是后者——那你可能还在 Scaling Law 或 Efficiency Law 的世界里思考问题，而 Profit Law 原生系统的护城河，正在被那些从 Day 0 就做对了的团队悄悄筑起。拿一个已有的强模型，把它压缩、蒸馏、量化，让它更便宜、更快。Scal

avatar AtomGit开源社区
cover

大模型应用开发重心迁移：从Prompt到Harness，收藏这篇看懂演进路径！

avatar AtomGit开源社区
cover

B2B出海GEO：如何让你的B2B品牌被AI推荐？

avatar AtomGit开源社区