【本期目标】

• 系统性地回顾 RAG 架构的各个环节。

• 掌握如何使用 LangChain 提供的 create_stuff_documents_chain 和 create_retrieval_chain 快速构建 RAG 应用。

• 理解并应用不同文档合并策略（stuffing, map_reduce, refine）在RAG中的作用。

• 学习如何将 RAG 链与对话记忆 (RunnableWithMessageHistory) 结合，实现有上下文的知识问答。

• 通过完整的LCEL案例，实践构建一个能够响应多轮提问的知识库聊天机器人。

---

引言：从理论到实践——RAG的完整蓝图

在前置章节中，我们已经介绍了RAG开发的基础知识：

• 数据准备 (Data Preparation)： 加载原始文档，切分，并转化为向量 (第三期)。

• 检索 (Retrieval)： 将向量存储到向量数据库，并能够根据查询找到最相关的文档块 (第四期)。

• 生成 (Generation)： LLM根据提示生成答案 (第一、二期)。

• 记忆 (Memory)： 管理对话历史，实现多轮对话 (第五期)。

现在，我们需要将这些独立的篇章连接起来，形成一个高效、智能的RAG系统。一个完整的RAG应用流程通常如下：

1. 数据摄入/索引阶段 (一次性或定期)：

   这是RAG系统的“知识库构建”阶段。

   • Document Loaders：从文件、网页、数据库等加载原始数据。

   • Text Splitters：将大文档切分成小块（Chunks）。

   • Embedding Models：将文本块转换为向量。

   • Vectorstore：将向量和原始文本块（及元数据）存储到向量数据库中。

2. 查询/运行时阶段 (每次用户提问)：

   • 用户查询： 用户提出问题。

   • (可选) 查询改写/增强： 如果是多轮对话，根据对话历史改写用户查询，使其更明确。

   • 检索 (Retrieval)： 将查询向量化，到向量数据库中检索出最相关的文档块。

   • 上下文增强 (Context Augmentation)： 将检索到的文档块作为上下文，与用户查询一起构建最终的Prompt。

   • 生成 (Generation)： 将包含上下文的Prompt发送给LLM，LLM生成答案。

   • 输出： 返回最终答案给用户。

本期我们将主要关注查询/运行时阶段的构建。

第一部分：RAG的核心链：create_retrieval_chain和create_stuff_documents_chain

LangChain 提供了高级的工厂函数来简化RAG链的构建，利用LCEL能用更少的代码实现完整的RAG逻辑。

1. create_stuff_documents_chain：将多个文档塞入Prompt

   • 作用： 这个链接受一个包含用户问题和检索到的文档列表的字典作为输入，然后将所有文档的内容拼接（stuffing）到Prompt中，最后交给LLM生成答案。

   • 这是最简单直观的文档合并策略，适用于文档数量不多、总长度不超LLM上下文窗口的场景。

   • 输入：{"question": str, "context": List[Document]}

   • 输出：str (LLM生成的答案)

2. create_retrieval_chain：检索器与文档生成链的组合

   • 作用： 这是构建一个基础RAG链的推荐方式。它将一个 Retriever 和一个 create_stuff_documents_chain 组合起来。

   • 它负责从用户问题中提取查询，调用检索器获取文档，然后将这些文档和问题一起传递给文档生成链。

   • 输入：str (用户问题)

   • 输出：dict (包含原始问题、检索到的文档、最终答案等)

这份完整版的大模型 AI 学习和面试资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

【实践：构建一个基础的RAG问答系统】

使用第三期准备的 example.txt 和第四期创建的 Chroma 向量数据库。

from dotenv import load_dotenvimport osfrom langchain_openai import ChatOpenAI, OpenAIEmbeddingsfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_core.output_parsers import StrOutputParserfrom langchain_community.vectorstores import Chromafrom langchain.text_splitter import RecursiveCharacterTextSplitterfrom langchain_community.document_loaders import TextLoader# RAG链的关键工厂函数from langchain.chains.combine_documents import create_stuff_documents_chainfrom langchain.chains import create_retrieval_chainload_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_chainretrieval_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 ChatOpenAIfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_core.documents import Documentfrom langchain_core.runnables import RunnablePassthroughfrom langchain_core.output_parsers import StrOutputParser# --- 准备文档和 Promptlong_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 阶段的 Promptmap_prompt = ChatPromptTemplate.from_template("请总结以下文档的关键信息：\n{context}")# 定义 reduce 阶段的 Promptreduce_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 处理链的 Promptrefine_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_answerquestion = "生成式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 链无法处理这种依赖。我们需要一个机制来：

1. 根据当前问题和对话历史，生成一个新的、独立的查询。

2. 用这个新查询去执行检索。

LangChain 提供了 create_history_aware_retriever 来地解决这个问题。

【实践：构建一个带记忆的多轮RAG聊天机器人】​​​​​​​

from dotenv import load_dotenvimport osfrom langchain_openai import ChatOpenAI, OpenAIEmbeddingsfrom langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholderfrom langchain_core.output_parsers import StrOutputParserfrom langchain_community.vectorstores import Chromafrom langchain.text_splitter import RecursiveCharacterTextSplitterfrom langchain_community.document_loaders import TextLoaderfrom langchain.chains.combine_documents import create_stuff_documents_chainfrom langchain.chains import create_retrieval_chainfrom langchain.chains import create_history_aware_retriever # 历史感知检索器from langchain_core.messages import HumanMessage, AIMessagefrom langchain_core.runnables.history import RunnableWithMessageHistoryfrom langchain.memory import ConversationBufferWindowMemoryfrom langchain_core.chat_history import BaseChatMessageHistoryload_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 组合，用于生成新的查询，然后将查询传给 retrieverhistory_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']}") # 应该能正确回答LangSmithprint("\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聊天机器人！

现在不仅能够回答基于知识库的问题，还能记住之前的对话，提供更流畅、更智能的用户体验

代码仓库

https://github.com/lgy1027/ai-tutorial

第四部分：AI大模型学习路线

如果你对AI大模型入门感兴趣，那么你需要的话可以点击这里大模型重磅福利：入门进阶全套104G学习资源包免费分享！

扫描下方csdn官方合作二维码获取哦！

这是一份大模型从零基础到进阶的学习路线大纲全览，小伙伴们记得点个收藏！

第一阶段： 从大模型系统设计入手，讲解大模型的主要方法；

第二阶段： 在通过大模型提示词工程从Prompts角度入手更好发挥模型的作用；

第三阶段： 大模型平台应用开发借助阿里云PAI平台构建电商领域虚拟试衣系统；

第四阶段： 大模型知识库应用开发以LangChain框架为例，构建物流行业咨询智能问答系统；

第五阶段： 大模型微调开发借助以大健康、新零售、新媒体领域构建适合当前领域大模型；

第六阶段： 以SD多模态大模型为主，搭建了文生图小程序案例；

第七阶段： 以大模型平台应用与开发为主，通过星火大模型，文心大模型等成熟大模型构建大模型行业应用。

100套AI大模型商业化落地方案

大模型全套视频教程

200本大模型PDF书籍

👉学会后的收获：👈

• 基于大模型全栈工程实现（前端、后端、产品经理、设计、数据分析等），通过这门课可获得不同能力；

• 能够利用大模型解决相关实际项目需求： 大数据时代，越来越多的企业和机构需要处理海量数据，利用大模型技术可以更好地处理这些数据，提高数据分析和决策的准确性。因此，掌握大模型应用开发技能，可以让程序员更好地应对实际项目需求；

• 基于大模型和企业数据AI应用开发，实现大模型理论、掌握GPU算力、硬件、LangChain开发框架和项目实战技能， 学会Fine-tuning垂直训练大模型（数据准备、数据蒸馏、大模型部署）一站式掌握；

• 能够完成时下热门大模型垂直领域模型训练能力，提高程序员的编码能力： 大模型应用开发需要掌握机器学习算法、深度学习框架等技术，这些技术的掌握可以提高程序员的编码能力和分析能力，让程序员更加熟练地编写高质量的代码。

LLM面试题合集

大模型产品经理资源合集

大模型项目实战合集

👉获取方式：
😝有需要的小伙伴，可以保存图片到wx扫描二v码免费领取【保证100%免费】🆓