LangChain v1.0+ Retrieval模块完全指南:从文档加载到RAG实战

【课程总结】day29:大模型之深入了解Retrievers解析器 在上一章【课程总结】day28:大模型之深入探索RAG流程中,我们对RAG流程中文档读取(LOAD)->文档切分(SPLIT)->向量化(EMBED)->存储(STORE)进行了深入了解,本章将接着深入了解解析(Retrieval)的使用简介:在 RAG(Retrieval-Augmented Generation)流程中,Retrieval(检索)是关键环节,其主要目标是从大量文档或知识库中提取与用户查询相关的信息。目的。 阅读详情

在这里插入图片描述​

  【个人主页:玄同765】

大语言模型(LLM)开发工程师|中国传媒大学·数字媒体技术(智能交互与游戏设计)

深耕领域:大语言模型开发 / RAG知识库 / AI Agent落地 / 模型微调

技术栈:Python / LangChain/RAG(Dify+Redis+Milvus)| SQL/NumPy | FastAPI+Docker ️

工程能力:专注模型工程化部署、知识库构建与优化,擅长全流程解决方案 

     

「让AI交互更智能,让技术落地更高效」

欢迎技术探讨/项目合作! 关注我,解锁大模型与智能交互的无限可能!


版本要求:本文基于 LangChain v1.0+ 编写,所有代码示例在 Python 3.10+ 和 LangChain 最新版本中测试通过。

核心内容:本文将深入介绍 LangChain Retrieval 模块的核心概念、v1.0 重大更新、以及如何使用最新的 create_retrieval_chain API 构建生产级 RAG 应用。


一、LangChain v1.0 Retrieval 模块概述

1.1 什么是 Retrieval 模块

Retrieval(检索)模块是 LangChain 框架中负责从外部数据源检索相关信息的核心组件。它是构建 RAG(Retrieval-Augmented Generation,检索增强生成)应用的基础,让大语言模型能够基于私有数据或实时信息回答问题。

1.2 Retrieval 的核心工作流程

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Document  │ -> │   Splitting │ -> │   Storage   │ -> │  Retrieval  │ -> │   Output    │
│   Loading   │    │  (Chunks)   │    │ (Vector DB) │    │  (Search)   │    │  (Answer)   │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

五个核心阶段:

  1. Document Loading(文档加载):从各种数据源加载文档
  2. Splitting(文本分割):将长文档切分为合适的块
  3. Storage(存储):使用嵌入模型将文本转换为向量并存储
  4. Retrieval(检索):根据查询检索相关文档
  5. Output(输出):将检索结果与LLM结合生成答案

1.3 v1.0 版本重大更新

LangChain v1.0 对 Retrieval 模块进行了重大重构,主要变化包括:

特性v0.x 版本v1.0+ 版本
链式构建RetrievalQA, ConversationalRetrievalChaincreate_retrieval_chain
消息类型字符串处理为主BaseMessage 对象为核心
文本提取.text() 方法.text 属性
类型安全较弱强类型,更好的IDE支持
Python版本3.8+3.10+
API稳定性频繁变更稳定的企业级API

关键变化详解:

  1. 全新的 create_retrieval_chain API:统一的RAG链构建方式,替代了旧版的多个类
  2. 消息对象标准化:所有输入输出使用 BaseMessage 对象,.text() 方法变为 .text 属性
  3. 强类型支持:更好的类型提示和IDE自动补全
  4. Python 3.10+ 要求:利用新版Python的类型系统特性

二、核心组件详解

2.1 Document Loaders(文档加载器)

LangChain 支持从多种数据源加载文档:

from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    CSVLoader,
    UnstructuredHTMLLoader,
    DirectoryLoader
)

# 加载文本文件
loader = TextLoader("document.txt", encoding="utf-8")
docs = loader.load()

# 加载PDF文件
pdf_loader = PyPDFLoader("document.pdf")
pdf_docs = pdf_loader.load()

# 加载整个目录
 dir_loader = DirectoryLoader(
    "./data",
    glob="**/*.txt",
    loader_cls=TextLoader
)
all_docs = dir_loader.load()

常用加载器:

加载器用途安装依赖
TextLoader纯文本文件内置
PyPDFLoaderPDF文档pypdf
CSVLoaderCSV表格内置
UnstructuredHTMLLoaderHTML网页unstructured
WebBaseLoader网页URLbeautifulsoup4
JSONLoaderJSON数据内置

2.2 Text Splitters(文本分割器)

将长文档分割成适合检索的块是RAG的关键步骤。

from langchain_text_splitters import (
    RecursiveCharacterTextSplitter,
    CharacterTextSplitter,
    TokenTextSplitter
)

# 递归字符分割器(推荐)
recursive_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,        # 每个块的最大字符数
    chunk_overlap=200,      # 块之间的重叠字符数
    length_function=len,    # 长度计算函数
    separators=["\n\n", "\n", "。", " ", ""]  # 分割符优先级
)

chunks = recursive_splitter.split_documents(docs)

# 字符分割器
char_splitter = CharacterTextSplitter(
    separator="\n",
    chunk_size=1000,
    chunk_overlap=200
)

# Token分割器(基于模型token)
token_splitter = TokenTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    model_name="gpt-3.5-turbo"
)

分割器选择指南:

分割器适用场景特点
RecursiveCharacterTextSplitter通用场景智能递归分割,保持语义完整性
CharacterTextSplitter简单文本按固定字符分割
TokenTextSplitter精确控制token基于模型的token计算
MarkdownHeaderTextSplitterMarkdown文档按标题层级分割
CodeSplitter代码文件按代码结构分割

2.3 Embedding Models(嵌入模型)

嵌入模型将文本转换为向量表示,是语义检索的基础。

from langchain_openai import OpenAIEmbeddings
from langchain_ollama import OllamaEmbeddings
from langchain_community.embeddings import HuggingFaceEmbeddings

# OpenAI嵌入模型
openai_embeddings = OpenAIEmbeddings(
    model="text-embedding-3-large",
    api_key="your-api-key"
)

# Ollama本地嵌入模型
ollama_embeddings = OllamaEmbeddings(
    model="nomic-embed-text"
)

# HuggingFace开源嵌入模型
hf_embeddings = HuggingFaceEmbeddings(
    model_name="BAAI/bge-large-zh-v1.5"
)

# 嵌入文本
texts = ["Hello world", "LangChain is great"]
embeddings = openai_embeddings.embed_documents(texts)

# 嵌入查询
query_embedding = openai_embeddings.embed_query("What is LangChain?")

推荐嵌入模型:

模型维度适用场景语言支持
text-embedding-3-large3072高质量检索多语言
text-embedding-3-small1536平衡性能成本多语言
BAAI/bge-large-zh-v1.51024中文场景中文优化
nomic-embed-text768本地部署多语言

2.4 Vector Stores(向量数据库)

向量数据库负责存储和检索向量化的文档。

from langchain_chroma import Chroma
from langchain_community.vectorstores import FAISS
from langchain_community.vectorstores import Qdrant

# Chroma(推荐,轻量级本地数据库)
chroma_db = Chroma.from_documents(
    documents=chunks,
    embedding=openai_embeddings,
    persist_directory="./chroma_db"
)

# FAISS(Facebook开源,高性能)
faiss_db = FAISS.from_documents(
    documents=chunks,
    embedding=openai_embeddings
)
faiss_db.save_local("faiss_index")

# Qdrant(生产级,支持分布式)
qdrant_db = Qdrant.from_documents(
    documents=chunks,
    embedding=openai_embeddings,
    location=":memory:"  # 或 url="http://localhost:6333"
)

# Milvus (生产级向量数据库,支持海量数据)
from langchain_milvus import Milvus
milvus_db = Milvus.from_documents(
    documents=chunks,
    embedding=openai_embeddings,
    connection_args={"host": "localhost", "port": "19530"},
    collection_name="my_collection",
)

向量数据库对比:

数据库类型特点适用场景
Chroma嵌入式轻量、易用、本地优先开发测试、小型应用
FAISS嵌入式Facebook开源、高性能大规模本地检索
Milvus服务端生产级、云原生、支持海量数据大规模生产环境
Qdrant服务端生产级、分布式企业级应用
Pinecone云服务全托管、高可用生产环境
Weaviate混合支持向量+语义搜索复杂查询场景

2.5 Retrievers(检索器)

检索器负责从向量数据库中检索相关文档。

# 基础相似度检索
retriever = chroma_db.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4}  # 返回前4个结果
)

# MMR(最大边际相关性)检索
mmr_retriever = chroma_db.as_retriever(
    search_type="mmr",
    search_kwargs={
        "k": 4,
        "fetch_k": 20,      # 候选池大小
        "lambda_mult": 0.5   # 多样性权重
    }
)

# 相似度阈值检索
threshold_retriever = chroma_db.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={"score_threshold": 0.8}
)

# 执行检索
results = retriever.invoke("What is LangChain?")

检索策略对比:

策略特点适用场景
similarity纯向量相似度标准检索场景
mmr平衡相关性和多样性需要多样化结果
similarity_score_threshold质量过滤需要高置信度结果
ParentDocument小块检索,大块输出需要完整上下文的场景
SelfQuery自动元数据过滤结构化+非结构化混合查询

三、v1.0 新特性:create_retrieval_chain

3.1 旧版 API vs 新版 API

v0.x 旧方式(已废弃):

# 不推荐
from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever
)

v1.0+ 新方式(推荐):

from langchain_classic.chains.combine_documents import create_stuff_documents_chain
from langchain_classic.chains.retrieval import create_retrieval_chain

# 创建文档处理链
document_chain = create_stuff_documents_chain(llm, prompt)

# 创建检索链
retrieval_chain = create_retrieval_chain(retriever, document_chain)

# 执行
response = retrieval_chain.invoke({"input": "What is LangChain?"})

3.2 create_retrieval_chain 详解

create_retrieval_chain 是 v1.0 引入的统一RAG链构建API,它将检索和生成两个步骤解耦:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains.retrieval import create_retrieval_chain

# 1. 初始化LLM
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.7,
    api_key="your-api-key"
)

# 2. 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a helpful assistant. Use the following context to answer the question.
    If you don't know the answer, say you don't know.
  
    Context: {context}"""),
    ("human", "{input}")
])

# 3. 创建文档处理链
document_chain = create_stuff_documents_chain(
    llm=llm,
    prompt=prompt,
    document_separator="\n\n"  # 文档分隔符
)

# 4. 创建检索链
retrieval_chain = create_retrieval_chain(
    retriever=retriever,
    combine_docs_chain=document_chain
)

# 5. 执行查询
response = retrieval_chain.invoke({
    "input": "What is LangChain and what are its main features?"
})

# 6. 解析响应
print(f"Answer: {response['answer']}")
print(f"\nRetrieved documents: {len(response['context'])}")

响应结构:

{
    "input": "用户原始问题",
    "context": [Document(...), Document(...)],  # 检索到的文档
    "answer": "生成的答案"
}

3.3 关键变化:消息对象处理

v1.0 中,所有文本内容都通过 BaseMessage 对象处理:

from langchain_core.messages import HumanMessage, AIMessage

# v0.x 方式(已废弃)
# result = chain.run("question")

# v1.0+ 方式
result = chain.invoke({"input": "question"})

# 提取文本(注意:.text() 方法变为 .text 属性)
# v0.x: answer = result.text()
# v1.0+: 
answer = result["answer"]

# 如果是消息对象
if hasattr(answer, 'text'):
    text = answer.text  # 属性,不是方法

四、完整实战:构建生产级RAG应用

4.1 完整代码示例

#!/usr/bin/env python3
"""
LangChain v1.0+ Retrieval 完整实战示例
构建一个基于私有文档的问答系统
"""

import os
from typing import List

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_classic.chains.combine_documents import create_stuff_documents_chain
from langchain_classic.chains.retrieval import create_retrieval_chain


class RAGApplication:
    """RAG应用类"""
  
    def __init__(self, openai_api_key: str):
        self.openai_api_key = openai_api_key
        self.vectorstore = None
        self.retriever = None
        self.chain = None
      
        # 初始化组件
        self._init_embeddings()
        self._init_llm()
      
    def _init_embeddings(self):
        """初始化嵌入模型"""
        self.embeddings = OpenAIEmbeddings(
            model="text-embedding-3-large",
            api_key=self.openai_api_key
        )
      
    def _init_llm(self):
        """初始化LLM"""
        self.llm = ChatOpenAI(
            model="gpt-4o-mini",
            temperature=0.7,
            api_key=self.openai_api_key
        )
      
    def load_documents(self, file_path: str) -> List:
        """加载文档"""
        loader = TextLoader(file_path, encoding="utf-8")
        documents = loader.load()
        print(f"Loaded {len(documents)} documents")
        return documents
      
    def split_documents(self, documents: List) -> List:
        """分割文档"""
        splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            length_function=len,
            separators=["\n\n", "\n", "。", " ", ""]
        )
        chunks = splitter.split_documents(documents)
        print(f"Split into {len(chunks)} chunks")
        return chunks
      
    def create_vectorstore(self, chunks: List, persist_dir: str = "./chroma_db"):
        """创建向量数据库"""
        self.vectorstore = Chroma.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            persist_directory=persist_dir
        )
        print(f"Vectorstore created at {persist_dir}")
      
    def load_vectorstore(self, persist_dir: str = "./chroma_db"):
        """加载已有向量数据库"""
        self.vectorstore = Chroma(
            persist_directory=persist_dir,
            embedding_function=self.embeddings
        )
        print(f"Vectorstore loaded from {persist_dir}")
      
    def setup_retriever(self, k: int = 4):
        """设置检索器"""
        self.retriever = self.vectorstore.as_retriever(
            search_type="similarity",
            search_kwargs={"k": k}
        )
        print(f"Retriever setup with k={k}")
      
    def create_chain(self):
        """创建检索链"""
        # 创建提示模板
        prompt = ChatPromptTemplate.from_messages([
            ("system", """You are a helpful assistant specialized in answering questions based on provided context.
          
            Guidelines:
            - Answer based only on the provided context
            - If the answer is not in the context, say "I don't have enough information to answer this question"
            - Be concise but complete
            - Cite specific parts of the context when possible
          
            Context:
            {context}"""),
            ("human", "{input}")
        ])
      
        # 创建文档处理链
        document_chain = create_stuff_documents_chain(
            llm=self.llm,
            prompt=prompt,
            document_separator="\n\n---\n\n"
        )
      
        # 创建检索链
        self.chain = create_retrieval_chain(
            retriever=self.retriever,
            combine_docs_chain=document_chain
        )
        print("RAG chain created successfully")
      
    def query(self, question: str) -> dict:
        """执行查询"""
        if not self.chain:
            raise ValueError("Chain not initialized. Call create_chain() first.")
          
        response = self.chain.invoke({"input": question})
        return response
      
    def chat_loop(self):
        """交互式问答循环"""
        print("\n" + "="*50)
        print("RAG Application Ready! Type 'exit' to quit.")
        print("="*50 + "\n")
      
        while True:
            question = input("Question: ").strip()
          
            if question.lower() in ["exit", "quit", "q"]:
                print("Goodbye!")
                break
              
            if not question:
                continue
              
            try:
                response = self.query(question)
              
                print(f"\nAnswer: {response['answer']}")
                print(f"\nSources ({len(response['context'])} documents retrieved):")
                for i, doc in enumerate(response['context'], 1):
                    print(f"  {i}. {doc.page_content[:100]}...")
                print()
              
            except Exception as e:
                print(f"Error: {e}")


def main():
    """主函数"""
    # 设置API密钥
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        api_key = input("Enter your OpenAI API key: ")
  
    # 创建RAG应用
    rag = RAGApplication(api_key)
  
    # 检查是否已有向量数据库
    if os.path.exists("./chroma_db"):
        print("Loading existing vectorstore...")
        rag.load_vectorstore()
    else:
        print("Creating new vectorstore...")
        # 加载文档(请确保有sample.txt文件)
        docs = rag.load_documents("sample.txt")
        chunks = rag.split_documents(docs)
        rag.create_vectorstore(chunks)
  
    # 设置检索器和链
    rag.setup_retriever(k=4)
    rag.create_chain()
  
    # 启动交互式问答
    rag.chat_loop()


if __name__ == "__main__":
    main()

4.2 使用LCEL构建自定义链

LangChain Expression Language (LCEL) 提供了一种更灵活的方式来构建RAG链:

from langchain_core.runnables import RunnablePassthrough, RunnableParallel

# 格式化文档的辅助函数
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# 使用LCEL构建RAG链
rag_chain = (
    RunnableParallel(
        {
            "context": retriever | format_docs,
            "input": RunnablePassthrough()
        }
    )
    | prompt
    | llm
    | StrOutputParser()
)

# 执行
answer = rag_chain.invoke("What is LangChain?")

4.3 带历史记录的对话式RAG

from langchain_core.messages import HumanMessage, AIMessage
from langchain_classic.chains.history_aware_retriever import create_history_aware_retriever

# 历史感知检索器提示
history_prompt = ChatPromptTemplate.from_messages([
    ("system", "Given the chat history and the latest user question, formulate a standalone question that can be understood without the chat history."),
    ("human", "{input}")
])

# 创建历史感知检索器
history_aware_retriever = create_history_aware_retriever(
    llm=llm,
    retriever=retriever,
    prompt=history_prompt
)

# 创建对话链
conversation_chain = create_retrieval_chain(
    retriever=history_aware_retriever,
    combine_docs_chain=document_chain
)

# 带历史记录的查询
chat_history = []
response = conversation_chain.invoke({
    "input": "What are its main features?",  # 指代前文的LangChain
    "chat_history": chat_history
})

# 更新历史
chat_history.extend([
    HumanMessage(content="What is LangChain?"),
    AIMessage(content=response["answer"])
])

五、高级技巧与最佳实践

5.1 检索优化技巧

1. 混合检索(向量 + 关键词)

from langchain_community.retrievers import BM25Retriever, EnsembleRetriever

# 创建BM25检索器
bm25_retriever = BM25Retriever.from_documents(documents)
bm25_retriever.k = 2

# 创建向量检索器
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# 组合检索器
ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.5, 0.5]
)

2. 多查询检索

from langchain_community.retrievers.multi_query import MultiQueryRetriever

multi_query_retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(),
    llm=llm
)

3. 父文档检索(Parent Document Retriever)
解决“块太小丢失上下文”与“块太大检索不准”的矛盾。

from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore

# 定义存储层
store = InMemoryStore()
child_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000)

retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,
    docstore=store,
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)
retriever.add_documents(documents)

4. 自查询检索(Self-Querying Retriever)
利用LLM自动将自然语言转换为结构化查询(含元数据过滤)。

from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.chains.query_constructor.base import AttributeInfo

metadata_field_info = [
    AttributeInfo(name="genre", description="The genre of the movie", type="string"),
    AttributeInfo(name="year", description="The year the movie was released", type="integer"),
]
document_content_description = "Brief summary of a movie"

retriever = SelfQueryRetriever.from_llm(
    llm, vectorstore, document_content_description, metadata_field_info, verbose=True
)

5. 重排序(Reranking)

from langchain_community.retrievers import ContextualCompressionRetriever
from langchain_community.document_transformers import EmbeddingsRedundantFilter

# 创建压缩检索器
compressor = EmbeddingsRedundantFilter(embeddings=embeddings)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=retriever
)

5.2 性能优化

1. 缓存嵌入

from langchain.embeddings import CacheBackedEmbeddings
from langchain.storage import LocalFileStore

# 创建本地缓存
store = LocalFileStore("./cache/")

# 包装嵌入模型
cached_embeddings = CacheBackedEmbeddings.from_bytes_store(
    underlying_embeddings=embeddings,
    document_embedding_cache=store,
    namespace="openai_embeddings"
)

2. 批处理

# 批量嵌入
texts = ["text1", "text2", "text3"]
embeddings_list = embeddings.embed_documents(texts, chunk_size=100)

5.3 评估RAG系统

from langchain.evaluation import (
    QAEvalChain,
    ContextQAEvalChain
)

# 创建评估链
eval_chain = QAEvalChain.from_llm(llm)

# 评估预测
examples = [
    {"query": "What is LangChain?", "answer": "A framework for LLM applications"}
]
predictions = [{"result": "LangChain is a Python framework"}]

graded_outputs = eval_chain.evaluate(examples, predictions)

六、常见问题与解决方案

6.1 检索质量不佳

问题:检索到的文档与问题不相关

解决方案:

  1. 调整 chunk_size 和 chunk_overlap
  2. 尝试不同的 search_type(MMR vs Similarity)
  3. 使用混合检索(向量 + BM25)
  4. 添加查询重写步骤

6.2 上下文窗口超限

问题:检索到的文档太长,超出LLM上下文限制

解决方案:

  1. 减小 chunk_size
  2. 减少检索数量 k
  3. 使用Map-Reduce或Refine链
  4. 使用支持长上下文的模型(如GPT-4 Turbo)

6.3 重复信息

问题:多个检索结果包含重复信息

解决方案:

  1. 使用 EmbeddingsRedundantFilter
  2. 增加 chunk_overlap 的差异化
  3. 使用MMR检索策略

七、总结

7.1 核心要点回顾

  1. Retrieval模块五阶段:Loading → Splitting → Storage → Retrieval → Output
  2. v1.0重大变化:
    • 使用 create_retrieval_chain 替代旧版Chain类
    • 消息对象标准化,.text() 变为 .text 属性
    • Python 3.10+ 要求
  3. 最佳实践:
    • 使用 RecursiveCharacterTextSplitter 进行智能分割
    • 选择合适的嵌入模型和向量数据库
    • 使用MMR或混合检索优化检索质量

7.2 版本选择建议

  • 新项目:直接使用 LangChain v1.0+
  • 现有项目:参考迁移指南逐步升级
  • 生产环境:v1.0 提供更稳定的API和更好的性能

7.3 学习资源


附录:旧版 Retrieval 方法参考(已弃用)

⚠️ 重要提示:本节介绍的 RetrievalQA 和 ConversationalRetrievalChain 是 LangChain v0.x 版本的遗留 API,在 v1.0+ 版本中已被标记为 deprecated(已弃用)。这些内容仅供维护旧项目参考,强烈建议在新项目中使用 create_retrieval_chain。

A.1 为什么要了解旧版方法?

  1. 维护旧代码:许多现有的教程和企业代码库仍在使用这些 API。
  2. 理解演进:了解从“大而全的类”向“解耦的链”演进的过程。
  3. 迁移成本:在评估项目升级工作量时,需要识别这些旧接口。

A.2 核心旧版 Chain 类型

A.2.1 RetrievalQA(基础问答链)

最经典的 RAG 实现方式,将检索和问答封装在一个类中。

from langchain.chains import RetrievalQA

# 已弃用的创建方式
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

response = qa_chain({"query": "What is LangChain?"})

特点:

  • 封装程度极高,一行代码构建 RAG。
  • 难以自定义提示词(Prompt)和中间步骤。
  • 输入输出结构固定,灵活性差。
A.2.2 ConversationalRetrievalChain(对话检索链)

在 RetrievalQA 基础上增加了对话历史处理。

from langchain.chains import ConversationalRetrievalChain

# 已弃用的创建方式
qa_chain = ConversationalRetrievalChain.from_chain_type(
    llm=llm,
    retriever=retriever,
    memory=memory # 通常配合旧版 Memory 使用
)

chat_history = []
response = qa_chain({"question": "...", "chat_history": chat_history})

特点:

  • 自动处理问题重写(将追问转为独立问题)。
  • 与旧版 Memory 模块强耦合。
  • 内部逻辑复杂,调试和流式输出(Streaming)支持较差。

A.3 旧版 vs 新版 API 对照表

功能旧版 API (v0.x)新版 API (v1.0+)
基础 RAGRetrievalQAcreate_retrieval_chain
对话 RAGConversationalRetrievalChaincreate_history_aware_retriever + create_retrieval_chain
文档合并load_qa_chaincreate_stuff_documents_chain
提示词控制较难,需通过 chain_type_kwargs极易,直接传入 ChatPromptTemplate
流式支持较差原生支持 (LCEL)

A.4 迁移建议

  1. 解耦检索与生成:不要指望一个类解决所有问题,先创建 retriever,再创建 document_chain。
  2. 拥抱 LCEL:新版 API 本质上是 LCEL 的封装,可以更方便地添加日志、监控和自定义逻辑。
  3. 标准化消息:统一使用 BaseMessage 体系,放弃旧版的纯字符串处理。

提示:本文所有代码示例均基于 LangChain v1.0+ 和 Python 3.10+。在实际使用前,请确保已安装最新版本的LangChain和相关依赖。

安装依赖:

pip install langchain langchain-openai langchain-chroma langchain-community langchain-milvus
pip install chromadb pypdf unstructured
【LangChain】Retrieval QA 您可以传入自定义prompt来进行问答。这些提示与您可以传递到基本问答链的提示相同。{context}Answer in Italian:""" PROMPT = PromptTemplate(template = prompt_template , input_variables = [ "context" , "question" ]) # 自定义 chain prompt chain_type_kwargs = { 阅读详情

相关推荐

Dify与LangChain v1.0构建企业级RAG应用指南

检索增强生成(RAG)技术通过结合大型语言模型(LLM)与外部知识库,有效解决了传统语言模型在专业领域知识不足的问题。其核心原理是利用向量检索从知识库中获取相关信息,再通过LLM生成精准回答。这种技术在降低幻觉风险的同时,显著提升了回答的专业性和准确性。在企业级应用中,RAG技术特别适合知识密集型场景,如智能客服、技术文档问答等。Dify作为开源LLM应用开发平台,提供了可视化工具链和知识库管理能力;而LangChain v1.0作为主流开发框架,则带来了统一的Agent抽象和中间件机制。两者的组合既能满足

weixin_33834628的博客 474

LangChain create_retrieval_chain的使用

LangChain create_retrieval_chain的使用

我的博客 1266

Langchain 1.3实战:本地部署Agent与RAG项目完整指南

大模型应用开发框架通过模块化设计,将复杂任务分解为可管理的组件,如文档加载、向量检索和智能体决策。其核心原理在于链式调用和工具集成,使开发者能够灵活构建基于外部数据的AI系统。这种技术价值体现在降低开发门槛,支持CPU推理和国产模型,适合企业知识库和智能问答等应用场景。以Langchain为例,它通过Agent实现多步任务处理,结合RAG技术增强生成准确性,为本地部署和大模型应用提供了实用解决方案。

congjukun0600的博客 449

LLM学习(4)——构建 RAG 应用

我遇到的最大的问题是参数的传递,submit的返回值是(message,chat_history)的形式但是模型的输入却不知这些,而且再使用radio和gr.Textbox输入模式选择和api的时候,我遇到了一个现在也没有弄明白的问题,按道理来说radio参数我没有传给其他函数应该是不能使用这个参数的,但是他却正常使用了,而且还是值传递???

pythonhy的博客 1335

LangChain实战:从RAG知识库到智能Agent的完整开发指南

大语言模型应用开发中,检索增强生成(RAG)技术通过将外部知识库与语言模型结合,有效解决了模型知识局限性和时效性问题。其核心原理是将文档向量化存储,通过相似度检索匹配用户查询,再让模型基于检索结果生成精准答案。这种技术显著提升了专业领域问答的准确性和可信度,广泛应用于企业知识库、技术文档查询等场景。智能Agent则在此基础上赋予模型自主决策能力,通过工具调用实现复杂任务自动化。本文基于LangChain 1.3最新特性,详细演示如何构建支持RAG检索和工具调用的混合Agent系统,涵盖向量数据库配置、工具封

weixin_34290631的博客 355

(14-2)Langchin基础知识:使用LangChain构建应用

上下文压缩是指对文本中的上下文信息进行压缩或简化,以便在给定的令牌数量限制下处理文档。在处理文档时需要进行上下文压缩工作,因为 Llama2 模型的最大令牌数量为 2048。(1)请看下面的代码,功能是使用库 LangChain创建一个上下文压缩的检索器。

码农三叔 3256

【LangChain】核心组件详解:文档加载器(Document Loaders)

大型语言模型(LLM)虽然拥有强大的语义理解和文本生成能力,但存在两个致命的局限性:训练数据有截止日期,无法获取实时信息;无法访问私有数据,如企业内部文档、个人笔记等。为了解决这些问题,检索增强生成(Retrieval-Augmented Generation, RAG) 技术应运而生,成为当前大模型应用的核心模式。RAG 的核心思想是:当用户提问时,系统首先在私有知识库中进行语义搜索,找到最相关的内容,然后将这些内容和问题一起交给 LLM 生成答案。我们的第一步就是把文档加载进去。

会当凌绝顶,一览众山小 4459

NVIDIA Jetson AGX Xavier设置风扇转速、工作模式及性能监控

Xavier的风扇在开机之后是默认关闭的,每次重启都需要手动打开风扇,后续可能考虑修改bashrc文件进行自动开启 这个是显示当前风扇的转速,默认应该是0,表示关闭,最大是250 cat /sys/devices/pwm-fan/target_pwm 可以通过修改该文件的值来修改风扇转速 vim /sys/devices/pwm-fan/target_pwm 我一般使用的是100这个值 作者:ryan_ren 链接:https://www.jianshu.com/p/d3c2041f7f7d 来源:简书 著

weixin_43877080的博客 1万+

基于LangChain的RAG开发教程(二)

RAG(Retrieval Augmented Generation,检索增强生成):在生成过程中,外部的数据会通过检索然后传递给LLM,让LLM能够利用这些新知识作为上下文

sgyuanshi的博客 2872

【近源攻击】badusb制作

BadUSB是利用伪造HID设备执行攻击载荷的一种攻击方式。HID(Human InterfaceDevice)设备通常指的就是键盘鼠标等与人交互的设备,用户插入BadUSB,就会自动执行预置在固件中的恶意代码。BadUsb插入后,会模拟键盘鼠标对电脑进行操作,通过这些操作打开电脑的命令终端,并执行一条命令,这条命令将从指定网址下载其他代码并于后台静默运行。这些代码功能包括:窃取信息、反弹shell、发送邮件等,从而实现控制目标机或者窃取信息的目的。

qinjilll的博客 2553

从编译到调通:RK3588与FPGA的PCIe XDMA驱动实战解析

本文详细解析了在RK3588平台上为FPGA板卡编译、加载与调试PCIe XDMA驱动的完整实战流程。内容涵盖环境准备、Makefile深度定制、编译排错、驱动加载与内核日志解读、设备节点分析以及用户空间编程实战,旨在帮助开发者打通RK3588与FPGA之间的高速PCIe通信链路,实现稳定可靠的数据传输。

weixin_29304021的博客 485

LangChain实战入门(二):RAG实战——赋予大模型你的私有知识库

LangChain的检索模块通过将文档加载、分割并向量化存储后,根据用户查询检索最相关的文本片段,最终将其作为上下文提供给大语言模型以生成精确的答案。

优秀、有趣的AI知识共享! 1338

Ansys CFX Pre 中 RGP 表的高级配置与优化策略

本文深入探讨了Ansys CFX Pre中RGP表的高级配置与优化策略,旨在帮助用户将仿真从“能用”提升至“精准好用”。文章重点解析了如何根据具体仿真场景,科学设定温度压力范围、选择流体类型,并针对相变等复杂工况实施网格加密与分离建表等关键优化技术,以显著提升计算精度与稳定性。

weixin_29216957的博客 1184

LangChain的RAG实践

RAG技术将这两种记忆类型进行了整合,最终,在知识密集型的NLP任务上,比如QA,比单独使用上述两种类型的记忆获得了更好的效果。

2301_81888214的博客 1955

鸿蒙开发实战:如何用DevEco Studio 4.0一键迁移安卓Java项目(附避坑清单)

本文详细介绍了如何使用DevEco Studio 4.0将安卓Java项目一键迁移到鸿蒙系统,包括环境准备、代码适配、UI转换及常见问题解决方案。通过实战指南和避坑清单,帮助开发者高效完成项目移植,充分利用鸿蒙生态优势。

weixin_29214199的博客 385

Unity大世界流式加载:工业级架构与优化秘籍

游戏大厂Unity大世界流式加载框架全景解析:从《原神》《和平精英》等标杆案例出发,深入剖析工业级流式加载的完整技术架构。文章系统介绍了大世界分区块管理、异步加载机制、资源优化策略、多平台适配方案,以及业务联动与团队协作流程。重点阐述了Addressable与AssetBundle应用、空间触发器设计、性能自适应等核心技术,并展望AI预测加载、云游戏等未来方向。全面展现了大厂如何通过流式加载技术实现无缝开放世界体验的技术路径与实践经验。

本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度,也有思维广度,无论你是开发者、创业者还是高校学子,都能在这里找到适合自己的成长之路! 613

大模型 基于LangChain的RAG开发教程(二)LangChain核心组件 Retrieval

这篇文章则继续介绍LangChain的第二个核心组件:Retrieval。

2301_81888214的博客 954

题解:AcWing 6051 看病

等知名刷题平台精心挑选而来,并结合各平台提供的算法标签和难度等级进行了系统分类。题目涵盖了从基础到进阶的多种算法和数据结构,旨在为不同阶段的编程学习者提供一条清晰、平稳的学习提升路径。但医院的排队不同其他排队,因为多数情况下,需要病情严重的人优先看病,所以希望BSNY设计系统时,以病情的严重情况作为优先级,判断接下来谁可以去看病。具体是这样的,最近来医院看病的人越来越多了,因此很多人要排队,只有当空闲时放一批病人看病。的操作,输出此时还在排队人中,优先级最大的患者姓名和优先级。后面没有输入,但需要你输出。

团爸讲算法 589

Langchain 1.0.2 从入门到精通(含基础、RAG、Milvus、Ollama、MCP、Agents)

本文详细介绍了LangChain框架及其在大模型应用开发中的核心功能。主要内容包括: LangChain概述:介绍1.0版本的重要更新,定位为连接大模型与外部组件的开发框架,支持Agent、RAG等应用开发。 核心组件: Model I/O:标准化模型输入输出,包含提示模板、模型调用和输出解析 Chains:通过LCEL表达式语言组合工作流 Retrieval:实现RAG流程,包括文档加载、切分、嵌入和向量存储 Agents:构建自主决策的AI代理,支持工具调用和记忆管理 关键技术: 文档处理:支持多种格式

AI全栈 和 IT 编程相关分享 1995

作物生长模型Oryza V3实战1:为什么要研究它

ORYZAV3是水稻生长模拟模型ORYZA2000的最新升级版本(3.5版),作为作物生长模型,它通过数学方法和计算机技术模拟水稻生长发育过程及其与环境条件的相互作用。主要功能包括:模拟不同条件下的水稻生长和产量形成、评估环境胁迫影响、分析土壤碳氮动态以及进行区域尺度模拟。国内应用广泛,科研机构用于气候变化影响评估、灌溉模式比较等研究,并开展参数敏感性分析和应用培训。使用流程分为六个步骤:确定输入参数(气象、土壤、作物三类)、参数校准、设置模拟环境、运行模型、分析结果(输出50个参数)和计算产量(穗干重×收

505

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Langchain V1.3实战:从RAG系统到LangGraph多智能体工作流开发指南

检索增强生成(RAG)技术通过结合检索系统和生成模型,有效解决了大语言模型的知识更新和事实准确性问题。其核心原理是将外部知识库向量化存储,在生成答案前先检索相关文档作为上下文。这种技术架构在企业知识管理、智能客服等场景中具有重要价值,能够显著提升AI应用的准确性和实用性。Langchain作为当前最热门的大语言模型应用开发框架,在V1.3版本中进一步优化了RAG系统的构建流程,同时引入了LangGraph多智能体工作流机制,支持复杂任务的有状态处理。本文基于最新实践,详细解析如何利用Langchain V1

weixin_34221276的博客 365

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【LangChain实战】LangChain 学习笔记(四):输出解析器、文档加载与文本分割(RAG 入门)

从非结构化文本到结构化数据,从 PDF 到可检索知识库——一次讲清! 本文用 DeepSeek 代码演示 StrOutput/Pydantic/JSON 三种输出解析器,拆解 RAG 两阶段五环节,并用真实 PDF/Markdown/QT 文档实操文档加载与三种文本分割器,附 chunk 超长报错解惑。

2601_96587588的博客 553

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

【LangChain】二.LangChain v1.0-高级特性(记忆、RAG 、Multi-Agent )

本文深入解析LangChain框架的三大进阶能力:记忆系统、RAG知识接入和多代理协作。记忆系统分为短期记忆(线程状态持久化)和长期记忆(跨会话存储),强调信息筛选比存储更重要。RAG不是简单的向量库技术,而是按需获取外部知识的模式,建议从基础的2-step模式入手。多代理系统主要用于解决上下文过载和职责分工问题,需结合工具、状态管理等基础能力使用。文章建议开发者先掌握单代理系统,遇到瓶颈再考虑多代理方案,并提供了清晰的学习路线图,强调LangChain的核心价值在于工程化地组织Agent系统。

hrh的博客 500

从零构建RAG Agent:LangChain实战指南与代码解析

检索增强生成(RAG)是一种将外部知识库与大型语言模型(LLM)结合的技术范式,旨在解决LLM的“幻觉”问题和知识更新延迟。其核心原理是通过检索器从向量数据库中找出与用户问题最相关的文档片段,作为上下文增强LLM的输入,从而生成更准确、基于事实的答案。这项技术的核心价值在于将LLM的通用推理能力与特定领域的结构化知识相结合,显著提升了问答系统的可靠性和实用性。在工程实践中,RAG常被应用于构建企业知识库问答、智能客服和文档分析等场景。本文聚焦于如何将RAG能力与智能体(Agent)框架深度集成,通过Lang

weixin_33804582的博客 310

LangChain完全指南:从核心组件到RAG与Agent实战

LangChain并非万能,但它确实极大降低了LLM应用开发的门槛。无论你是想做智能客服、知识库问答,还是自动化工作流,LangChain都提供了成熟的组件和最佳实践。记住:LangChain = 连接 + 编排 + 记忆,而真正的价值在于你如何组合这些能力去解决实际问题。希望这篇文章能帮你快速入门LangChain。如果你在实践中遇到问题,欢迎在评论区交流讨论!

2301_81100537的博客 400
上一篇: Python ABC 抽象类完全指南:从入门到精通
下一篇: Trae国际版与国内版深度测评:AI原生IDE的双生花
玄同765
玄同765 新星创作者: 人工智能技术领域 新星创作者: 人工智能技术领域
博客等级 码龄6年 1万+粉丝 262原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值