在前置章节中，我们已经介绍了RAG开发的基础知识：
- 数据准备 (Data Preparation)： 加载原始文档，切分，并转化为向量 (第三期)。
- 检索 (Retrieval)： 将向量存储到向量数据库，并能够根据查询找到最相关的文档块 (第四期)。
- 生成 (Generation)： LLM根据提示生成答案 (第一、二期)。
- 记忆 (Memory)： 管理对话历史，实现多轮对话 (第五期)。
现在，我们需要将这些独立的篇章连接起来，形成一个高效、智能的RAG系统。一个完整的RAG应用流程通常如下：
数据摄入/索引阶段 (一次性或定期)：
这是RAG系统的“知识库构建”阶段。
- Document Loaders：从文件、网页、数据库等加载原始数据。
- Text Splitters：将大文档切分成小块（Chunks）。
- Embedding Models：将文本块转换为向量。
- Vectorstore：将向量和原始文本块（及元数据）存储到向量数据库中。
- 查询/运行时阶段 (每次用户提问)：
- 用户查询： 用户提出问题。
- (可选) 查询改写/增强： 如果是多轮对话，根据对话历史改写用户查询，使其更明确。
- 检索 (Retrieval)： 将查询向量化，到向量数据库中检索出最相关的文档块。
- 上下文增强 (Context Augmentation)： 将检索到的文档块作为上下文，与用户查询一起构建最终的Prompt。
- 生成 (Generation)： 将包含上下文的Prompt发送给LLM，LLM生成答案。
- 输出： 返回最终答案给用户。
本期我们将主要关注查询/运行时阶段的构建。
第一部分：RAG的核心链：create_retrieval_chain和create_stuff_documents_chain
LangChain 提供了高级的工厂函数来简化RAG链的构建，利用LCEL能用更少的代码实现完整的RAG逻辑。
- create_stuff_documents_chain：将多个文档塞入Prompt
- 作用： 这个链接受一个包含用户问题和检索到的文档列表的字典作为输入，然后将所有文档的内容拼接（stuffing）到Prompt中，最后交给LLM生成答案。
- 这是最简单直观的文档合并策略，适用于文档数量不多、总长度不超LLM上下文窗口的场景。
- 输入：{“question”: str, “context”: List[Document]}
- 输出：str (LLM生成的答案)
- create_retrieval_chain：检索器与文档生成链的组合
- 作用： 这是构建一个基础RAG链的推荐方式。它将一个 Retriever 和一个 create_stuff_documents_chain 组合起来。
- 它负责从用户问题中提取查询，调用检索器获取文档，然后将这些文档和问题一起传递给文档生成链。
- 输入：str (用户问题)
- 输出：dict (包含原始问题、检索到的文档、最终答案等)
【实践：构建一个基础的RAG问答系统】
使用第三期准备的 example.txt 和第四期创建的 Chroma 向量数据库。
from dotenv import load_dotenv import os from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_community.vectorstores import Chroma from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_community.document_loaders import TextLoader # RAG链的关键工厂函数 from langchain.chains.combine_documents import create_stuff_documents_chain from langchain.chains import create_retrieval_chain load_dotenv() # --- 1. 初始化模型和Embedding --- llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0) embeddings_model = OpenAIEmbeddings(model="text-embedding-ada-002") # --- 2. 准备数据和向量数据库 (复用并简化之前的代码) --- # 确保 example.txt 存在 with open("example.txt", "w", encoding="utf-8") as f: f.write("LangChain 是一个强大的框架，用于开发由大型语言模型驱动的应用程序。\n") f.write("作为一名LangChain教程架构师，我负责设计一套全面、深入且易于理解的LangChain系列教程。\n") f.write("旨在帮助读者从入门到精通，掌握LangChain的核心技术和应用。\n") f.write("RAG（检索增强生成）是LangChain中的一个关键应用场景。\n") f.write("通过RAG，我们可以将LLM与外部知识库相结合。\n") f.write("从而让LLM能够回答其训练数据之外的问题。\n") f.write("这大大扩展了LLM的应用范围，解决了幻觉和知识过时的问题。\n") f.write("LangSmith 是 LangChain 的一个强大工具，用于调试和评估 LLM 应用程序。\n") f.write("LCEL 是 LangChain Expression Language 的简称，是构建链条的首选方式。\n") f.write("LangGraph 则用于构建具有循环和复杂状态的 Agent。\n") loader = TextLoader("example.txt", encoding="utf-8") text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20) raw_documents = loader.load() split_documents = text_splitter.split_documents(raw_documents) # 创建并持久化 Chroma 向量数据库 (如果已存在则加载) persist_directory = "./chroma_db_rag_basic" if not os.path.exists(persist_directory) or not Chroma(persist_directory=persist_directory, embedding_function=embeddings_model)._collection.count(): print(f"正在创建并持久化 Chroma 数据库到 '{persist_directory}'...") vectorstore = Chroma.from_documents( documents=split_documents, embedding=embeddings_model, persist_directory=persist_directory ) print("Chroma 数据库创建/加载完成。") else: print(f"从 '{persist_directory}' 加载现有 Chroma 数据库...") vectorstore = Chroma( persist_directory=persist_directory, embedding_function=embeddings_model ) print("Chroma 数据库加载完成。") # --- 3. 创建 Retriever --- retriever = vectorstore.as_retriever(search_kwargs={"k": 2}) # 检索最相关的2个文档块 # --- 4. 定义 RAG 提示模板 --- # 提示中需要包含 {context} 和 {input} 两个变量 rag_prompt = ChatPromptTemplate.from_messages([ ("system", "请根据提供的上下文回答以下问题。\n如果上下文没有明确信息，请说明你不知道。\n\n上下文:\n{context}"), ("user", "{input}") ]) # --- 5. 构建文档合并链 (stuffing) --- # 这个链负责将检索到的文档 {context} 和用户问题 {input} 传入 Prompt 并交给 LLM 生成答案 document_chain = create_stuff_documents_chain(llm, rag_prompt) # --- 6. 构建最终的 RAG 链 --- # 这个链将 retriever 和 document_chain 组合起来 # 它接收用户问题，先通过 retriever 获取文档，再将文档和问题传给 document_chain retrieval_rag_chain = create_retrieval_chain(retriever, document_chain) # --- 7. 调用 RAG 链 --- print("\n--- 基础 RAG 问答系统示例 ---") query1 = "LangChain是做什么的？" response1 = retrieval_rag_chain.invoke({"input": query1}) print(f"问题: {query1}") print(f"回答: {response1['answer']}") # 注意 create_retrieval_chain 的输出是字典，答案在 'answer' 键 print(f"检索到的文档 (部分):\n") for doc in response1["context"]: print(f"- {doc.page_content[:50]}...") # 打印检索到的文档内容 print("-" * 30) query2 = "RAG解决了什么问题？" response2 = retrieval_rag_chain.invoke({"input": query2}) print(f"问题: {query2}") print(f"回答: {response2['answer']}") print(f"检索到的文档 (部分):\n") for doc in response2["context"]: print(f"- {doc.page_content[:50]}...") print("-" * 30) query3 = "2023年诺贝尔物理学奖得主是谁？" # 知识库中没有的信息 response3 = retrieval_rag_chain.invoke({"input": query3}) print(f"问题: {query3}") print(f"回答: {response3['answer']}") # 应该回答不知道 print("-" * 30)代码解析：
- create_stuff_documents_chain(llm, rag_prompt)： 构建了一个只负责将 context 和 input 填充到 rag_prompt 并交给 llm 的链。
- create_retrieval_chain(retriever, document_chain)： 这是关键的组合链。它接收用户 input，自动调用 retriever 获取 context，然后将 {“input”: …, “context”: …} 传入 document_chain。它的输出是一个字典，包含 input, context (检索到的文档), 和 answer (LLM生成的答案)。
- 这种结构非常清晰：retriever 负责找，document_chain 负责回复。
第二部分：文档合并策略 (CombineDocuments Chain)
create_stuff_documents_chain 内部使用的就是 stuff 策略。LangChain 还提供了其他文档合并策略，用于处理不同场景下检索到的文档列表。这些策略通常通过 create_stuff_documents_chain, MapReduceDocumentsChain, RefineDocumentsChain 等工厂函数或类在自定义链中使用。
说明：早期版本使用create_map_reduce_documents_chain、create_refine_documents_chain，后面升级使用MapReduceDocumentsChain和RefineDocumentsChain 实现对应功能，但是没有LECL灵活，目前LangChain的官方文档和迁移指南更推荐使用LangGraph来构建复杂的Map-Reduce流程和Refine工作流（后面我会专门做几期LangGraph的教程），下面完全采用 LCEL 来实现。
stuff (填充/拼接)：
- 原理： 最简单。将所有检索到的 Document 内容简单地拼接成一个大字符串，然后作为 {context} 传入Prompt。
- 优点： 简单，保留所有信息。
- 缺点： 容易超出LLM的上下文窗口限制。
- 适用场景： 检索到的文档数量和长度都较小，总Token数在LLM限制内。
map_reduce (映射-归约)：
原理：
Map (映射)： 将每个检索到的文档块（或分组后的文档）分别传递给LLM，让LLM对每个块生成一个简短的摘要或相关信息。
Reduce (归约)： 将所有这些摘要（或中间结果）再次合并，传递给LLM，让LLM基于这些摘要生成最终的答案。
优点： 可以处理大量文档，避免上下文溢出；每个子任务的Token消耗较小。
缺点： 增加了LLM调用次数，可能增加延迟和成本；摘要过程可能丢失关键细节。
适用场景： 检索到大量文档，且每个文档相对独立，可以被独立总结。
from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate from langchain_core.documents import Document from langchain_core.runnables import RunnablePassthrough from langchain_core.output_parsers import StrOutputParser # --- 准备文档和 Prompt long_doc_content_1 = "这是一个关于人工智能发展史的长篇介绍，从最初的逻辑推理，到专家系统，再到机器学习，直至深度学习和大型语言模型的崛起。它详细描述了各个阶段的关键里程碑和技术突破，以及面临的挑战和伦理考量。AI已经深刻改变了多个行业，未来潜力无限。" long_doc_content_2 = "本节深入探讨了生成式AI的最新进展，特别是扩散模型和Transformer架构。生成式AI能够创造出逼真的图像、文本和音频，在艺术、设计、内容创作等领域展现出巨大潜力。同时，也讨论了其在偏见、版权和滥用方面的问题。" map_docs = [ Document(page_content=long_doc_content_1, metadata={"source": "AIHistory"}), Document(page_content=long_doc_content_2, metadata={"source": "GenerativeAI"}) ] # 定义 map 阶段的 Prompt map_prompt = ChatPromptTemplate.from_template("请总结以下文档的关键信息：\n{context}") # 定义 reduce 阶段的 Prompt reduce_prompt = ChatPromptTemplate.from_template("根据以下总结，生成最终答案：\n{context}\n\n问题: {question}") # --- 使用 LCEL 构建 Map-Reduce 链 --- # 1. 定义 Map 链 map_chain = ( {"context": lambda doc: doc.page_content} | map_prompt | llm | StrOutputParser() ) # 2. 定义 Reduce 步骤中合并总结的函数 def combine_summaries(summaries): """将总结列表合并成一个字符串""" return "\n\n".join(summaries) # 3. 构建完整的 Map-Reduce 链 # 使用 RunnablePassthrough.assign 来并行处理，并将结果赋给新的键 map_reduce_chain = ( RunnablePassthrough.assign( # "summaries" 键的值通过对输入的 "context" 应用 map_chain.map() 来获得 summaries= (lambda x: x["context"]) | map_chain.map() ) | { # 为 reduce_prompt 准备输入 "context": lambda x: combine_summaries(x["summaries"]), # 合并总结 "question": lambda x: x["question"], # 传递原始问题 } | reduce_prompt | llm | StrOutputParser() ) print("\n--- Map-Reduce 文档合并策略示例 ---") question = "生成式AI的最新进展是什么？" result_map_reduce = map_reduce_chain.invoke({"question": question, "context": map_docs}) print(f"问题: {question}") print(f"回答 (Map-Reduce): {result_map_reduce}")refine (精炼/迭代)：
原理：
1、先用第一个检索到的文档块和原始查询生成一个初步答案。
2、然后，将这个初步答案和下一个文档块一起提供给LLM，让LLM根据新文档迭代地精炼之前的答案。这个过程重复，直到所有文档块都被处理。
优点： 适合答案需要逐步构建、或者需要处理文档间冲突的场景。
缺点： 延迟较高，LLM调用次数多。
适用场景： 答案可能分布在多个文档中，且需要逐步累积或修正。
initial_prompt_template = "根据以下内容，简洁地回答问题：\n\n内容: {context}\n\n问题: {question}" initial_prompt = ChatPromptTemplate.from_template(initial_prompt_template) # 2. 定义 Refine 处理链的 Prompt refine_prompt_template = ( "原始问题: {question}\n" "我们已经有了一个初步的答案: {existing_answer}\n" "现在有额外的上下文信息: {context}\n" "请根据新的上下文信息，精炼或扩展之前的答案。如果新信息与问题无关，请返回原答案。" ) refine_prompt = ChatPromptTemplate.from_template(refine_prompt_template) def run_refine_chain(docs, question): # 创建处理第一个文档的链 initial_chain = ( { "context": lambda x: x["context"][0].page_content, # 提取第一个文档的内容 "question": lambda x: x["question"] } | initial_prompt | llm | StrOutputParser() ) # 运行初始链，得到初步答案 initial_answer = initial_chain.invoke({"context": docs, "question": question}) # 创建精炼链 refine_chain = ( { "question": lambda x: x["question"], "existing_answer": lambda x: x["existing_answer"], "context": lambda x: x["context"].page_content # 提取当前文档的内容 } | refine_prompt | llm | StrOutputParser() ) # 循环处理剩余的文档 refined_answer = initial_answer for i, doc in enumerate(docs[1:]): print(f"Refining with doc {i+1}...") refined_answer = refine_chain.invoke({ "question": question, "existing_answer": refined_answer, "context": doc }) return refined_answer question = "生成式AI的最新进展是什么？" print("\n--- Refine 文档合并策略示例---") result_refine = run_refine_chain(map_docs, question) print(f"问题: {question}") print(f"回答 (Refine): {result_refine}")小结： 根据文档长度、数量和回答的复杂性，选择合适的文档合并策略。stuff 最简单，map_reduce 适合大量文档独立总结，refine 适合迭代构建答案。
第三部分：RAG与记忆的结合：多轮对话RAG系统
在第五期我们分享了 RunnableWithMessageHistory 来为任何LCEL链添加记忆。现在，我们将它与 RAG 链结合，构建一个能够记住上下文的多轮对话RAG系统。
核心挑战：历史感知检索
当用户进行多轮对话时，后续的问题可能依赖于之前的上下文（例如“它的调试工具叫什么？”）。简单的 RAG 链无法处理这种依赖。我们需要一个机制来：
- 根据当前问题和对话历史，生成一个新的、独立的查询。
- 用这个新查询去执行检索。
LangChain 提供了 create_history_aware_retriever 来地解决这个问题。
【实践：构建一个带记忆的多轮RAG聊天机器人】
from dotenv import load_dotenv import os from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain_core.output_parsers import StrOutputParser from langchain_community.vectorstores import Chroma from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_community.document_loaders import TextLoader from langchain.chains.combine_documents import create_stuff_documents_chain from langchain.chains import create_retrieval_chain from langchain.chains import create_history_aware_retriever # 历史感知检索器 from langchain_core.messages import HumanMessage, AIMessage from langchain_core.runnables.history import RunnableWithMessageHistory from langchain.memory import ConversationBufferWindowMemory from langchain_core.chat_history import BaseChatMessageHistory load_dotenv() llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0) embeddings_model = OpenAIEmbeddings(model="text-embedding-ada-002") # --- 1. 准备数据和向量数据库 (同上) --- persist_directory_history_rag = "./chroma_db_history_rag" if not os.path.exists(persist_directory_history_rag) or not Chroma(persist_directory=persist_directory_history_rag, embedding_function=embeddings_model)._collection.count(): print(f"正在创建并持久化 Chroma 数据库到 '{persist_directory_history_rag}'...") vectorstore_history_rag = Chroma.from_documents( documents=split_documents, # 使用之前切分好的文档 embedding=embeddings_model, persist_directory=persist_directory_history_rag ) print("Chroma 数据库创建/加载完成。") else: print(f"从 '{persist_directory_history_rag}' 加载现有 Chroma 数据库...") vectorstore_history_rag = Chroma( persist_directory=persist_directory_history_rag, embedding_function=embeddings_model ) print("Chroma 数据库加载完成。") retriever_history_rag = vectorstore_history_rag.as_retriever(search_kwargs={"k": 2}) # --- 2. 创建历史感知检索器 (History-Aware Retriever) --- # 这个 LLM Chain 会根据对话历史和用户最新问题，生成一个独立的查询字符串 history_aware_prompt = ChatPromptTemplate.from_messages([ MessagesPlaceholder(variable_name="chat_history"), # 历史对话 ("user", "{input}"), # 用户当前问题 ("system", "根据上面的对话历史和用户最新问题，生成一个独立的、用于检索相关文档的问题。只返回新的查询，不要添加其他内容。") ]) # 将 llm 和 history_aware_prompt 组合，用于生成新的查询，然后将查询传给 retriever history_aware_retriever = create_history_aware_retriever( llm, retriever_history_rag, # 基础检索器 history_aware_prompt # 用于生成新的查询的Prompt ) # --- 3. 定义 RAG 提示模板 (同上) --- rag_prompt = ChatPromptTemplate.from_messages([ ("system", "请根据提供的上下文回答以下问题。\n如果上下文没有足够的信息，请说明你不知道。\n\n上下文:\n{context}"), MessagesPlaceholder(variable_name="chat_history"), # 确保Prompt也能看到历史 ("user", "{input}") ]) # --- 4. 构建文档合并链 (同上) --- document_chain_history_rag = create_stuff_documents_chain(llm, rag_prompt) # --- 5. 构建最终的 RAG 链 (使用历史感知检索器) --- conversational_rag_chain = create_retrieval_chain( history_aware_retriever, # 这里使用历史感知检索器 document_chain_history_rag ) # --- 6. 整合记忆管理 (使用 RunnableWithMessageHistory) --- # 存储会话历史的字典 (模拟持久化存储) store = {} def get_session_history_for_rag(session_id: str) -> BaseChatMessageHistory: if session_id not in store: store[session_id] = ConversationBufferWindowMemory( k=5, # 保留更多轮次的记忆 return_messages=True, input_key="input", # 指定输入键 output_key="answer" # 指定输出键，与 create_retrieval_chain 的输出匹配 ).chat_memory return store[session_id] # 包装 RAG 链，使其具有记忆功能 with_message_history_rag_chain = RunnableWithMessageHistory( conversational_rag_chain, get_session_history_for_rag, input_messages_key="input", history_messages_key="chat_history", # 与 Prompt 中的 placeholder 对应 output_messages_key="answer" # 与 create_retrieval_chain 的输出字典中的键对应 ) # --- 7. 进行多轮对话测试 --- print("\n--- 带记忆的多轮 RAG 聊天机器人示例 ---") session_id = "rag_user_test_001" print("\n--- 第一轮：介绍 ---") response_m1 = with_message_history_rag_chain.invoke( {"input": "你好，我想了解LangChain。"}, config={"configurable": {"session_id": session_id}} ) print(f"用户: 你好，我想了解LangChain。") print(f"AI: {response_m1['answer']}") print("\n--- 第二轮：关于它的调试工具 ---") response_m2 = with_message_history_rag_chain.invoke( {"input": "它的调试工具叫什么？"}, # 注意这里没有明确指明是LangChain config={"configurable": {"session_id": session_id}} ) print(f"用户: 它的调试工具叫什么？") print(f"AI: {response_m2['answer']}") # 应该能正确回答LangSmith print("\n--- 第三轮：它解决了什么问题？ ---") response_m3 = with_message_history_rag_chain.invoke( {"input": "它解决了什么问题？"}, # 再次隐晦指代 config={"configurable": {"session_id": session_id}} ) print(f"用户: 它解决了什么问题？") print(f"AI: {response_m3['answer']}") # 应该能正确回答RAG解决的问题 print("\n--- 第四轮：问一个知识库没有的问题 ---") response_m4 = with_message_history_rag_chain.invoke( {"input": "谁是美国第一位总统？"}, # 知识库没有的常识问题 config={"configurable": {"session_id": session_id}} ) print(f"用户: 谁是美国第一位总统？") print(f"AI: {response_m4['answer']}") # 应该回答不知道或基于LLM自身知识回答代码解析：
- create_history_aware_retriever： 这是实现多轮RAG的关键！它内部有一个LLM，根据 chat_history 和 input 来生成一个最佳的检索查询。这个新的查询才会被送去 retriever。
- rag_prompt 中也包含MessagesPlaceholder(variable_name=“chat_history”)：尽管 history_aware_retriever 已经利用了历史，但将完整的 chat_history 也传递给最终的 RAG rag_prompt，可以让LLM在生成答案时更好地理解整体对话上下文，生成更连贯、个性化的回答。
- RunnableWithMessageHistory的 output_messages_key=“answer”： 确保 create_retrieval_chain 返回字典中的 answer 字段能够被记忆模块正确捕获并保存为AI的消息。
本期小结
在本期教程中，完成了RAG系统的核心实践：
- 系统性地回顾了RAG的端到端架构。
- 学会了使用 LangChain 提供的 create_stuff_documents_chain 和 create_retrieval_chain 来快速构建基础RAG链。
- 理解了不同文档合并策略（stuff, map_reduce, refine）的适用场景。
- 最重要的是，成功地将 RAG 链与 RunnableWithMessageHistory 及 create_history_aware_retriever 结合，构建了一个能够进行多轮对话、具备上下文理解能力的生产级RAG聊天机器人！
现在不仅能够回答基于知识库的问题，还能记住之前的对话，提供更流畅、更智能的用户体验。
下一期教程中，将深入探讨RAG的高级优化技巧，包括更复杂的检索策略、如何提升生成质量以及如何有效防范“幻觉”问题，让RAG系统更上一层楼！敬请期待！
代码仓库
https://github.com/lgy1027/ai-tutorial
想入门 AI 大模型却找不到清晰方向？备考大厂 AI 岗还在四处搜集零散资料？别再浪费时间啦！2025 年AI 大模型全套学习资料已整理完毕，从学习路线到面试真题，从工具教程到行业报告，一站式覆盖你的所有需求，现在全部免费分享！
👇👇扫码免费领取全部内容👇👇
一、学习必备：100+本大模型电子书+26 份行业报告 + 600+ 套技术PPT，帮你看透 AI 趋势
想了解大模型的行业动态、商业落地案例？大模型电子书？这份资料帮你站在 “行业高度” 学 AI：
1. 100+本大模型方向电子书
2. 26 份行业研究报告：覆盖多领域实践与趋势
报告包含阿里、DeepSeek 等权威机构发布的核心内容，涵盖：
- 职业趋势：《AI + 职业趋势报告》《中国 AI 人才粮仓模型解析》；
- 商业落地：《生成式 AI 商业落地白皮书》《AI Agent 应用落地技术白皮书》；
- 领域细分：《AGI 在金融领域的应用报告》《AI GC 实践案例集》；
- 行业监测：《2024 年中国大模型季度监测报告》《2025 年中国技术市场发展趋势》。
3. 600+套技术大会 PPT：听行业大咖讲实战
PPT 整理自 2024-2025 年热门技术大会，包含百度、腾讯、字节等企业的一线实践：
- 安全方向：《端侧大模型的安全建设》《大模型驱动安全升级（腾讯代码安全实践）》；
- 产品与创新：《大模型产品如何创新与创收》《AI 时代的新范式：构建 AI 产品》；
- 多模态与 Agent：《Step-Video 开源模型（视频生成进展）》《Agentic RAG 的现在与未来》；
- 工程落地：《从原型到生产：AgentOps 加速字节 AI 应用落地》《智能代码助手 CodeFuse 的架构设计》。
二、求职必看：大厂 AI 岗面试 “弹药库”，300 + 真题 + 107 道面经直接抱走
想冲字节、腾讯、阿里、蔚来等大厂 AI 岗？这份面试资料帮你提前 “押题”，拒绝临场慌！
1. 107 道大厂面经：覆盖 Prompt、RAG、大模型应用工程师等热门岗位
面经整理自 2021-2025 年真实面试场景，包含 TPlink、字节、腾讯、蔚来、虾皮、中兴、科大讯飞、京东等企业的高频考题，每道题都附带思路解析：
2. 102 道 AI 大模型真题：直击大模型核心考点
针对大模型专属考题，从概念到实践全面覆盖，帮你理清底层逻辑：
3. 97 道 LLMs 真题：聚焦大型语言模型高频问题
专门拆解 LLMs 的核心痛点与解决方案，比如让很多人头疼的 “复读机问题”：
![]()
三、路线必明： AI 大模型学习路线图，1 张图理清核心内容
刚接触 AI 大模型，不知道该从哪学起？这份「AI大模型 学习路线图」直接帮你划重点，不用再盲目摸索！
路线图涵盖 5 大核心板块，从基础到进阶层层递进：一步步带你从入门到进阶，从理论到实战。
L1阶段:启航篇丨极速破界AI新时代
L1阶段：了解大模型的基础知识，以及大模型在各个行业的应用和分析，学习理解大模型的核心原理、关键技术以及大模型应用场景。
L2阶段：攻坚篇丨RAG开发实战工坊
L2阶段：AI大模型RAG应用开发工程，主要学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。
L3阶段：跃迁篇丨Agent智能体架构设计
L3阶段：大模型Agent应用架构进阶实现，主要学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造Agent智能体。
L4阶段：精进篇丨模型微调与私有化部署
L4阶段：大模型的微调和私有化部署，更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调，并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。
L5阶段：专题集丨特训篇 【录播课】
![]()
四、资料领取：全套内容免费抱走，学 AI 不用再找第二份
不管你是 0 基础想入门 AI 大模型，还是有基础想冲刺大厂、了解行业趋势，这份资料都能满足你！
现在只需按照提示操作，就能免费领取：
👇👇扫码免费领取全部内容👇👇
2025 年想抓住 AI 大模型的风口？别犹豫，这份免费资料就是你的 “起跑线”！
