听劝！别再手动调参了，LangChain+RAG三步搭建生产级问答系统

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

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

• 数据准备 (Data Preparation)： 加载原始文档，切分，并转化为向量 (第三期)。
• 检索 (Retrieval)： 将向量存储到向量数据库，并能够根据查询找到最相关的文档块 (第四期)。
• 生成 (Generation)： LLM根据提示生成答案 (第一、二期)。
• 记忆 (Memory)： 管理对话历史，实现多轮对话 (第五期)。

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

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

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

2. • Document Loaders：从文件、网页、数据库等加载原始数据。
   • Text Splitters：将大文档切分成小块（Chunks）。
   • Embedding Models：将文本块转换为向量。
   • Vectorstore：将向量和原始文本块（及元数据）存储到向量数据库中。

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

4. • 用户查询： 用户提出问题。
   • (可选) 查询改写/增强： 如果是多轮对话，根据对话历史改写用户查询，使其更明确。
   • 检索 (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**

2. • 作用： 这个链接受一个包含用户问题和检索到的文档列表的字典作为输入，然后将所有文档的内容拼接（stuffing）到Prompt中，最后交给LLM生成答案。
   • 这是最简单直观的文档合并策略，适用于文档数量不多、总长度不超LLM上下文窗口的场景。
   • 输入：{“question”: str, “context”: List[Document]}
   • **输出：**str (LLM生成的答案)

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

4. • 作用： 这是构建一个基础RAG链的推荐方式。它将一个 Retriever 和一个 create_stuff_documents_chain 组合起来。
   • 它负责从用户问题中提取查询，调用检索器获取文档，然后将这些文档和问题一起传递给文档生成链。
   • **输入：**str (用户问题)
   • **输出：**dict (包含原始问题、检索到的文档、最终答案等)

【实践：构建一个基础的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的消息。

如何学习大模型 AI ？

我国在AI大模型领域面临人才短缺，数量与质量均落后于发达国家。2023年，人才缺口已超百万，凸显培养不足。随着Al技术飞速发展，预计到2025年，这一缺口将急剧扩大至400万，严重制约我国Al产业的创新步伐。加强人才培养，优化教育体系，国际合作并进，是破解困局、推动AI发展的关键。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

2025最新大模型学习路线

明确的学习路线至关重要。它能指引新人起点、规划学习顺序、明确核心知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。

对于从来没有接触过AI大模型的同学，我帮大家准备了从零基础到精通学习成长路线图以及学习规划。可以说是最科学最系统的学习路线。

针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。

大模型经典PDF书籍

新手必备的大模型学习PDF书单来了！全是硬核知识，帮你少走弯路！

配套大模型项目实战

所有视频教程所涉及的实战项目和项目源码等

博主介绍＋AI项目案例集锦

MoPaaS专注于Al技术能力建设与应用场景开发，与智学优课联合孵化，培养适合未来发展需求的技术性人才和应用型领袖。

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

为什么要学习大模型？

2025人工智能大模型的技术岗位与能力培养随着人工智能技术的迅速发展和应用 ， 大模型作为其中的重要组成部分 ， 正逐渐成为推动人工智能发展的重要引擎 。大模型以其强大的数据处理和模式识别能力， 广泛应用于自然语言处理 、计算机视觉 、 智能推荐等领域 ，为各行各业带来了革命性的改变和机遇 。

适合人群

• 在校学生：包括专科、本科、硕士和博士研究生。学生应具备扎实的编程基础和一定的数学基础，有志于深入AGI大模型行业，希望开展相关的研究和开发工作。
• IT行业从业人员：包括在职或失业者，涵盖开发、测试、运维、产品经理等职务。拥有一定的IT从业经验，至少1年以上的编程工作经验，对大模型技术感兴趣或有业务需求，希望通过课程提升自身在IT领域的竞争力。
• IT管理及技术研究领域人员：包括技术经理、技术负责人、CTO、架构师、研究员等角色。这些人员需要跟随技术发展趋势，主导技术创新，推动大模型技术在企业业务中的应用与改造。
• 传统AI从业人员：包括算法工程师、机器视觉工程师、深度学习工程师等。这些AI技术人才原先从事机器视觉、自然语言处理、推荐系统等领域工作，现需要快速补充大模型技术能力，获得大模型训练微调的实操技能，以适应新的技术发展趋势。
  

课程精彩瞬间

大模型核心原理与Prompt：掌握大语言模型的核心知识，了解行业应用与趋势；熟练Python编程，提升提示工程技能，为Al应用开发打下坚实基础。

RAG应用开发工程：掌握RAG应用开发全流程，理解前沿技术，提升商业化分析与优化能力，通过实战项目加深理解与应用。

Agent应用架构进阶实践：掌握大模型Agent技术的核心原理与实践应用，能够独立完成Agent系统的设计与开发，提升多智能体协同与复杂任务处理的能力，为AI产品的创新与优化提供有力支持。

模型微调与私有化大模型：掌握大模型微调与私有化部署技能，提升模型优化与部署能力，为大模型项目落地打下坚实基础。

顶尖师资，深耕AI大模型前沿技术

实战专家亲授，让你少走弯路

一对一学习规划，职业生涯指导

• 真实商业项目实训
• 大厂绿色直通车

人才库优秀学员参与真实商业项目实训

以商业交付标准作为学习标准，具备真实大模型项目实践操作经验可写入简历，支持项目背调

大厂绿色直通车，冲击行业高薪岗位

文中涉及到的完整版的大模型 AI 学习资料已经上传优快云，朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】