Web-Dev-For-Beginners 第 10 课：用 LangChain 构建 AI 框架应用——对话记忆、工具调用与结构化输出实战

Web-Dev-For-Beginners 第 10 课：用 LangChain 构建 AI 框架应用——对话记忆、工具调用与结构化输出实战

【免费下载链接】Web-Dev-For-Beginners24 Lessons, 12 Weeks, Get Started as a Web Developer项目地址: https://gitcode.com/GitHub_Trending/we/Web-Dev-For-Beginners

本文是 Web-Dev-For-Beginners 课程第 10 课（AI Framework）的技术指南。你将学习如何以 LangChain 为核心框架，配合 GitHub Models 免费模型服务，完成从单次提问、多轮对话记忆、流式响应、提示词模板、结构化输出，到工具调用、向量检索（Embeddings/FAISS）的完整 AI 应用开发流程，并最终将这些能力整合为一个可运行的编码助手类应用。课程配套的三个可运行示例分别位于 code/python/app.py、code/python/app-chat.py 和 code/python/app-tools.py，可对照本文逐步复现。

为什么选择 AI 框架？

在动手之前，先明确一个关键决策：集成 AI 有主流三条路径，各有取舍。课程原文给出的对比如下：

框架（以 LangChain 为例）在实践中带来的具体收益：

• 统一多个 AI 提供商（OpenAI GPT、Anthropic Claude、GitHub Models、本地模型）在一个接口之下；
• 自动处理会话记忆；
• 提供嵌入（embeddings）、函数调用等常见任务的现成工具；
• 管理错误处理与重试逻辑；
• 把复杂工作流压缩成可读的方法调用。

经验法则：当你需要在不同 AI 模型之间切换，或要构建 Agent、记忆、工具调用等复杂功能时，选择框架；学习基础或构建简单聚焦的应用时，直接使用 API 更合适。就像工匠的专用工具与完整工作坊的区别——关键是让工具匹配任务。

从课程配套代码的 code/python/app.py 也可以看到，所有示例都统一依赖langchain-openai客户端（文件首行注释即安装提示pip install -qU "langchain[openai]"），这就是"统一接口"的直接体现：无论底层是 GitHub Models 还是其他 OpenAI 兼容端点，代码形态保持一致。

5 分钟快速上手路径

课程为赶时间的开发者规划了一条 5 分钟路径：

1. 第 1 分钟：安装 LangChain——pip install langchain langchain-openai；
2. 第 2 分钟：设置 GitHub token 并导入ChatOpenAI客户端；
3. 第 3 分钟：用 system + human 消息创建一段简单对话；
4. 第 4 分钟：添加一个基础工具（如加法函数），体验 AI 工具调用；
5. 第 5 分钟：直观感受"原始 API 调用"与"框架抽象"的差距。

快速验证代码（带消息结构的版本）：

from langchain_openai import ChatOpenAI from langchain_core.messages import SystemMessage, HumanMessage llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini" ) response = llm.invoke([ SystemMessage(content="You are a helpful coding assistant"), HumanMessage(content="Explain Python functions briefly") ]) print(response.content)

5 分钟内你就能体验到：AI 框架如何把复杂的 AI 集成变成简单的方法调用——这正是生产级 AI 应用的基础。

第一个 AI 提示词：LangChain + GitHub Models

环境配置

课程选用 LangChain 连接 GitHub Models，好处是免费使用多种 AI 模型，且只需几个配置参数即可启动：

from langchain_openai import ChatOpenAI import os llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini", ) # 发送一个简单提示词 response = llm.invoke("What's the capital of France?") print(response.content)

这段代码逐行拆解：

• ChatOpenAI：创建 LangChain 客户端，它是通往 AI 的"网关"；
• api_key=os.environ["GITHUB_TOKEN"]：从环境变量读取认证令牌；
• base_url="https://models.github.ai/inference"：把请求指向 GitHub Models 的 OpenAI 兼容推理端点；
• model="openai/gpt-4o-mini"：指定要使用的模型（相当于选择你的 AI 助手）；
• llm.invoke(...)：发送提示词，模型在此返回生成内容；
• response.content：提取并打印纯文本响应。

环境说明：如果使用 GitHub Codespaces，GITHUB_TOKEN已经预置，无需额外操作；在本地运行则需要自行创建一个具备相应权限的 personal access token 并导出为环境变量。

预期输出：

The capital of France is Paris.

调用链路可以概括为：你的 Python 应用 → LangChain 封装 HTTP 请求 → GitHub Models → GPT-4o-mini 处理提示词并生成响应 → 逐层返回response.content。仓库中 code/python/app.py 与该示例完全一致，可直接运行验证（提示词原文为 "What is the capital of France"）。

构建对话式 AI：消息类型与多轮记忆

单轮问答只是起点。真实应用需要 AI 记住此前讨论的内容——LangChain 通过不同的消息类型来结构化对话，并让 AI 拥有"人格"。

消息类型

可以把消息类型理解为对话中各参与者戴的"帽子"：

第一轮：赋予角色

让 AI 扮演《星际迷航》中的皮卡德舰长（以外交智慧与领导力著称的角色）：

from langchain_core.messages import HumanMessage, SystemMessage from langchain_openai import ChatOpenAI import os llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini", ) messages = [ SystemMessage(content="You are Captain Picard of the Starship Enterprise"), HumanMessage(content="Tell me about you"), ] response = llm.invoke(messages) print(response.content)

• SystemMessage确立 AI 的角色与人格；
• HumanMessage提供初始用户查询；
• 二者共同构成多轮对话的基础。

典型返回（节选）：

I am Captain Jean-Luc Picard, the commanding officer of the USS Enterprise (NCC-1701-D), a starship in the United Federation of Planets. My primary mission is to explore new worlds, seek out new life and new civilizations, and boldly go where no one has gone before. ...

第二轮：维持上下文的关键——把响应追加回消息列表

要保持对话连续性（而不是每次重置上下文），需要持续把 AI 的响应追加到消息列表。完整代码：

from langchain_core.messages import HumanMessage, SystemMessage from langchain_openai import ChatOpenAI import os llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini", ) messages = [ SystemMessage(content="You are Captain Picard of the Starship Enterprise"), HumanMessage(content="Tell me about you"), ] # works response = llm.invoke(messages) print(response.content) print("---- Next ----") messages.append(response) messages.append(HumanMessage(content="Now that I know about you, I'm Chris, can I be in your crew?")) response = llm.invoke(messages) print(response.content)

这里实际调用了两次 LLM：第一次只带两条初始消息，第二次则携带完整对话历史[SystemMessage, HumanMessage, AIMessage, HumanMessage]——相当于 AI 真的"跟进了整个聊天"。第二轮的典型回应：

Welcome aboard, Chris! It's always a pleasure to meet those who share a passion for exploration and discovery. ... Engage!

仓库中 code/python/app-chat.py 就是这段"追加消息实现记忆"的完整可运行版本：第 24 行messages.append(response)与第 25 行追加新的HumanMessage是整个机制的核心——invoke的返回值本身就是AIMessage对象，可以直接放回消息列表。

自查要点

完成本节后可以自问三个问题：

• 能否解释 LangChain 相比手动管理消息列表，如何简化了会话管理？
• invoke()与stream()的区别是什么，分别在什么场景使用？
• 框架的消息类型体系如何改善代码组织？

这些抽象模式（消息类型、流式接口、会话记忆）正是主流 AI 产品（聊天界面、代码补全助手）背后使用的同一套架构模式。进阶思考题：如何设计一个框架抽象，用单一接口同时支持 OpenAI、Anthropic、Google 等不同模型提供商？

流式响应（Streaming）

ChatGPT 那种"逐字打字"的效果就是流式：内容在生成过程中就逐步呈现，交互更自然、反馈更即时。

用 LangChain 实现流式

from langchain_openai import ChatOpenAI import os llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini", streaming=True ) # 流式接收响应 for chunk in llm.stream("Write a short story about a robot learning to code"): print(chunk.content, end="", flush=True)

流式的价值：

• 内容生成中即显示，无需干等；
• 让用户感知到"确实在处理"；
• 即使总耗时不变，主观上更快；
• 用户可以在 AI 仍在"思考"时就开始阅读。

体验提示：流式在长响应场景（代码讲解、创意写作、详细教程）中价值最明显——用户看到的是进度，而不是空白屏幕。

提示词模板（Prompt Templates）

提示词模板像古典修辞中的结构框架：一次搭建好骨架，再按需填入不同内容，无需重写。

创建可复用提示词

from langchain_core.prompts import ChatPromptTemplate # 定义一个代码讲解模板 template = ChatPromptTemplate.from_messages([ ("system", "You are an expert programming instructor. Explain concepts clearly with examples."), ("human", "Explain {concept} in {language} with a practical example for {skill_level} developers") ]) # 用不同变量值使用同一模板 questions = [ {"concept": "functions", "language": "JavaScript", "skill_level": "beginner"}, {"concept": "classes", "language": "Python", "skill_level": "intermediate"}, {"concept": "async/await", "language": "JavaScript", "skill_level": "advanced"} ] for question in questions: prompt = template.format_messages(**question) response = llm.invoke(prompt) print(f"Topic: {question['concept']}\n{response.content}\n---\n")

模板带来的好处：

• 整个应用的提示词结构保持一致；
• 告别混乱的字符串拼接，只用干净的变量；
• 结构不变，AI 行为更可预期；
• 一处修改模板，全局生效。

结构化输出（Structured Output）

AI 返回的是一段无法解析的自由文本，最让人头疼。结构化输出让 AI 按你定义的格式返回数据——可以要求 JSON、特定数据结构或任何你需要的形态。

定义输出 Schema

from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import JsonOutputParser from pydantic import BaseModel, Field class CodeReview(BaseModel): score: int = Field(description="Code quality score from 1-10") strengths: list[str] = Field(description="List of code strengths") improvements: list[str] = Field(description="List of suggested improvements") overall_feedback: str = Field(description="Summary feedback") # 配置解析器 parser = JsonOutputParser(pydantic_object=CodeReview) # 创建带格式指令的提示词 prompt = ChatPromptTemplate.from_messages([ ("system", "You are a code reviewer. {format_instructions}"), ("human", "Review this code: {code}") ]) # 组装 LCEL 链：提示词 -> 模型 -> 解析器 chain = prompt | llm | parser # 获得结构化响应 code_sample = """ def calculate_average(numbers): return sum(numbers) / len(numbers) """ result = chain.invoke({ "code": code_sample, "format_instructions": parser.get_format_instructions() }) print(f"Score: {result['score']}") print(f"Strengths: {', '.join(result['strengths'])}")

几个值得注意的实现细节：

• CodeReview用 Pydantic 模型定义字段与描述，描述会进入提示词，引导模型按字段作答；
• parser.get_format_instructions()把格式要求注入 system 消息的{format_instructions}占位符；
• chain = prompt | llm | parser使用了 LCEL 管道语法，三段式组合在课程后续的完整应用与作业中反复出现。

结构化输出的意义：

• 返回格式每次一致，不再靠猜；
• 可直接对接数据库与 API，无需额外清洗；
• 异常响应在进入应用逻辑前就被拦截；
• 代码更干净——你明确知道自己在处理什么。

工具调用（Tool Calling）

工具是让 AI 拥有"超越对话的动手能力"的核心特性：你向 AI 描述可用工具，当用户请求匹配时，AI 可以选择调用工具并采取行动。

用 Python 定义工具

以加法为例：

from typing_extensions import Annotated, TypedDict class add(TypedDict): """Add two integers.""" # Annotations 的顺序：类型，可选默认值，可选描述 a: Annotated[int, ..., "First integer"] b: Annotated[int, ..., "Second integer"] tools = [add] functions = { "add": lambda a, b: a + b }

这里发生了什么：继承TypedDict并配合Annotated类型，为 LLM 提供了清晰的"工具蓝图"——工具做什么、需要什么参数；functions字典则是工具箱，告诉代码当 AI 决定调用某个工具时具体执行什么。

接着把工具绑定到模型：

llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini", ) llm_with_tools = llm.bind_tools(tools)

调用bind_tools传入tools数组后，llm_with_tools就"知道"了这个工具。发起调用：

query = "What is 3 + 12?" res = llm_with_tools.invoke(query) if res.tool_calls: for tool in res.tool_calls: print("TOOL CALL: ", functions[tool["name"]](**tool["args"])) print("CONTENT: ", res.content)

当对带工具的 LLM 调用invoke后，响应对象的tool_calls属性可能被填充。每个被识别的工具调用带有name和args，分别标识要调用哪个工具、用什么参数。仓库中 code/python/app-tools.py 正是这个完整流程的可运行版本（该文件还同时绑定了add与joke两个工具）。

运行后你应看到类似输出：

TOOL CALL: 15 CONTENT:

AI 分析 "What is 3 + 12"，依据工具的名称、描述和字段规格判定这是add工具的适用场景；结果 15 来自functions字典中对应函数的执行：

print("TOOL CALL: ", functions[tool["name"]](**tool["args"]))

更有实际意义的工具：调用 Web API

加法只是演示概念，真实工具通常执行更复杂的操作，比如调用 Web API。课程扩展了示例，让 AI 从互联网抓取内容：

class joke(TypedDict): """Tell a joke.""" category: Annotated[str, ..., "The joke category"] def get_joke(category: str) -> str: response = requests.get( f"https://api.chucknorris.io/jokes/random?category={category}", headers={"Accept": "application/json"} ) if response.status_code == 200: return response.json().get("value", f"Here's a {category} joke!") return f"Here's a {category} joke!" functions = { "add": lambda a, b: a + b, "joke": lambda category: get_joke(category) } query = "Tell me a joke about animals" # 其余代码同上（bind_tools + invoke + 遍历 tool_calls）

运行后你会得到类似这样的响应：

TOOL CALL: Chuck Norris once rode a nine foot grizzly bear through an automatic car wash, instead of taking a shower. CONTENT:

完整的流程是：用户查询 → LangChain/模型分析 → 判断工具是否可用 → 选定joke工具并抽取参数 → 执行joke(category="animals")发起 API 请求 → 返回笑话内容并展示给用户；若没有匹配工具，则直接生成 AI 响应。整个完整代码见 code/python/app-tools.py，其中get_joke的容错设计值得注意：请求失败（非 200）时回退到一句模板文案，而不是让异常中断对话——这是工具实现中"防御式编程"的示范。

嵌入（Embeddings）与文档处理

嵌入是"给思想建立坐标系"：把任意文本转换为捕获其语义的数值坐标，相似的Concepts在多维空间中彼此靠近。基于此可以实现语义检索——RAG（检索增强生成）的地基。

创建并使用嵌入

from langchain_openai import OpenAIEmbeddings from langchain_community.vectorstores import FAISS from langchain_community.document_loaders import TextLoader from langchain.text_splitter import CharacterTextSplitter # 初始化嵌入（同样走 GitHub Models 端点） embeddings = OpenAIEmbeddings( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="text-embedding-3-small" ) # 加载并切分文档 loader = TextLoader("documentation.txt") documents = loader.load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(documents) # 创建向量库 vectorstore = FAISS.from_documents(texts, embeddings) # 执行相似性检索 query = "How do I handle user authentication?" similar_docs = vectorstore.similarity_search(query, k=3) for doc in similar_docs: print(f"Relevant content: {doc.page_content[:200]}...")

关键参数说明：

• model="text-embedding-3-small"：嵌入模型名称，与聊天模型走同一base_url端点；
• CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)：按 1000 字符切块、不重叠，块大小与重叠度决定检索粒度与召回质量；
• FAISS.from_documents(texts, embeddings)：对切块逐条计算嵌入并建立本地向量索引；
• similarity_search(query, k=3)：对查询同样计算嵌入，返回向量空间中最近的 3 个文档块。

多种格式的文档加载器

from langchain_community.document_loaders import ( PyPDFLoader, CSVLoader, JSONLoader, WebBaseLoader ) # 加载不同类型的文档 pdf_loader = PyPDFLoader("manual.pdf") csv_loader = CSVLoader("data.csv") json_loader = JSONLoader("config.json") web_loader = WebBaseLoader("https://example.com/docs") # 处理所有文档 all_documents = [] for loader in [pdf_loader, csv_loader, json_loader, web_loader]: docs = loader.load() all_documents.extend(docs)

基于嵌入你可以做到：

• 构建真正"理解语义"而非仅关键词匹配的搜索；
• 创建能针对你的文档问答的 AI；
• 构建推荐真正相关内容的推荐系统；
• 自动整理与归类内容。

整个流程可概括为：文档 → 文本切分 → 计算嵌入 → 向量库；查询 → 查询嵌入 → 相似性检索 → 命中相关文档 → 交给 LLM 生成回答。

构建完整的 AI 应用

现在把前面所有能力整合成一个综合应用——一个能回答问题、使用工具、并保持对话记忆的编码助手。

完整应用示例

from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_core.prompts import ChatPromptTemplate from langchain_core.messages import HumanMessage, SystemMessage, AIMessage from langchain_community.vectorstores import FAISS from typing_extensions import Annotated, TypedDict import os import requests class CodingAssistant: def __init__(self): self.llm = ChatOpenAI( api_key=os.environ["GITHUB_TOKEN"], base_url="https://models.github.ai/inference", model="openai/gpt-4o-mini" ) self.conversation_history = [ SystemMessage(content="""You are an expert coding assistant. Help users learn programming concepts, debug code, and write better software. Use tools when needed and maintain a helpful, encouraging tone.""") ] # 定义工具 self.setup_tools() def setup_tools(self): class web_search(TypedDict): """Search for programming documentation or examples.""" query: Annotated[str, "Search query for programming help"] class code_formatter(TypedDict): """Format and validate code snippets.""" code: Annotated[str, "Code to format"] language: Annotated[str, "Programming language"] self.tools = [web_search, code_formatter] self.llm_with_tools = self.llm.bind_tools(self.tools) def chat(self, user_input: str): # 将用户消息加入会话历史 self.conversation_history.append(HumanMessage(content=user_input)) # 获取 AI 响应 response = self.llm_with_tools.invoke(self.conversation_history) # 如有工具调用则处理 if response.tool_calls: for tool_call in response.tool_calls: tool_result = self.execute_tool(tool_call) print(f"🔧 Tool used: {tool_call['name']}") print(f"📊 Result: {tool_result}") # 将 AI 响应加入会话历史 self.conversation_history.append(response) return response.content def execute_tool(self, tool_call): tool_name = tool_call['name'] args = tool_call['args'] if tool_name == 'web_search': return f"Found documentation for: {args['query']}" elif tool_name == 'code_formatter': return f"Formatted {args['language']} code: {args['code'][:50]}..." return "Tool execution completed" # 使用示例 assistant = CodingAssistant() print("🤖 Coding Assistant Ready! Type 'quit' to exit.\n") while True: user_input = input("You: ") if user_input.lower() == 'quit': break response = assistant.chat(user_input) print(f"🤖 Assistant: {response}\n")

从源码结构看，这个类的组织方式体现了生产级 AI 应用的典型骨架：

• 类封装：CodingAssistant把 LLM 客户端、会话历史、工具集、工具执行逻辑收敛在一个可维护的对象中，而不是散落的顶层脚本；
• 会话记忆：conversation_history以SystemMessage初始化，chat()每轮先把HumanMessage追加进去、调用后再把AIMessage（响应对象）追加回去——与前面皮卡德示例的记忆机制完全一致，只是被持久化到了实例属性；
• 工具检测与执行：setup_tools()内部定义两个TypedDict工具（web_search、code_formatter）并bind_tools；execute_tool()按tool_call['name']分发，未命中时返回兜底文案。课程示例中工具返回的是模拟结果字符串，实际落地时在这里替换为真实的搜索 API 或格式化调用即可。

应用要点：

• 记住完整对话，保持上下文连续；
• 通过工具调用执行动作，而不只是聊天；
• 遵循可预测的交互模式；
• 自动管理错误处理与复杂工作流。

延伸思考：如何将这个应用扩展到多用户、持久化存储或对接外部数据库？重点考虑可扩展性与状态管理。

作业：构建你自己的 AI 学习助手

目标：创建一个帮助学生理解编程概念的 AI 应用，提供讲解、代码示例与交互测验。

需求

核心功能（必须实现）：

1. 对话界面：实现跨多个问题保持上下文的聊天系统；
2. 教育工具：至少两个辅助学习的工具——代码解释工具、概念测验生成器；
3. 个性化学习：用 system 消息适配不同技能水平的响应；
4. 响应格式化：为测验题目实现结构化输出。

实现步骤

步骤 1：环境搭建

pip install langchain langchain-openai

步骤 2：基础聊天功能

• 创建StudyAssistant类；
• 实现对话记忆；
• 为教学支持场景配置人格（system 消息）。

步骤 3：添加教育工具

• 代码解释器（Code Explainer）：把代码拆解为易懂的片段；
• 测验生成器（Quiz Generator）：针对编程概念生成题目；
• 进度追踪器（Progress Tracker）：记录已覆盖的主题。

步骤 4：增强功能（可选）

• 实现流式响应改善用户体验；
• 加入文档加载，把课程材料纳入上下文；
• 为基于相似性的内容检索创建嵌入。

评分标准

示例代码结构

class StudyAssistant: def __init__(self, skill_level="beginner"): # 初始化 LLM、工具与会话记忆 pass def explain_code(self, code, language): # 工具：解释代码如何工作 pass def generate_quiz(self, topic, difficulty): # 工具：生成练习题 pass def chat(self, user_input): # 主对话界面 pass # 使用示例 assistant = StudyAssistant(skill_level="intermediate") response = assistant.chat("Explain how Python functions work")

加分挑战：

• 添加语音输入/输出能力；
• 用 Streamlit 或 Flask 实现 Web 界面；
• 用嵌入基于课程材料构建知识库；
• 添加进度追踪与个性化学习路径。

GitHub Copilot Agent 挑战

课程还提供了一个面向 AI Agent 协作的挑战：使用 Agent 模式构建一个高级 AI 代码审查助手，综合运用工具调用、结构化输出与对话记忆，对代码提交给出完整反馈。

任务描述：创建一个CodeReviewAssistant类，实现：

1. 分析代码复杂度并建议改进的工具；
2. 对照最佳实践检查代码的工具；
3. 使用 Pydantic 模型的结构化输出，保证审查格式一致；
4. 跟踪审查会话的对话记忆；
5. 能处理代码提交并给出详细、可执行反馈的主聊天界面。

助手应能审查多种编程语言的代码，在一次会话中跨多次代码提交保持上下文，并给出总体评分与详细的改进建议。这个挑战本质上要求你把本课学到的四类能力（bind_tools+TypedDict工具、Pydantic +JsonOutputParser结构化输出、消息列表记忆、LCEL 链式组装）全部组合到一个类里——正是CodingAssistant完整应用的进阶版。

总结与 AI 集成决策框架

你已掌握的

核心框架概念：

• 框架收益：理解何时选择框架而非直接 API 调用；
• LangChain 基础：配置并连接 AI 模型；
• 消息类型：用SystemMessage、HumanMessage、AIMessage构建结构化对话。

进阶特性：

• 工具调用：创建并集成自定义工具；
• 会话记忆：跨多轮保持上下文；
• 流式响应：实时逐块输出；
• 提示词模板：可复用、动态化的提示词；
• 结构化输出：一致、可解析的响应；
• 嵌入：语义搜索与文档处理能力。

实践应用：

• 把多种特性组合成生产级应用；
• 实现健壮的错误管理与校验；
• 创建扩展 AI 能力的自定义工具。

AI 集成决策框架

按以下顺序做选择：

• 简单单次查询 → 直接 API 调用（HTTP 请求、最小依赖）；
• 需要单模型、单提供商的较多调用 → SDK 集成（提供商 SDK、模型专属）；
• 需要对话记忆 → 框架基础用法（LangChain 基本聊天）；
• 还需要工具或复杂特性 → 完整框架实现（LangChain 加工具、记忆、Agent）。

下一步方向

• 立即动手：用这些概念构建让你兴奋的项目；通过 LangChain 试验不同模型；创建解决你实际问题的工具；
• 进阶方向：AI Agent（自主规划与执行复杂任务）、RAG（把 AI 与自有知识库结合）、多模态 AI（文本、图像、音频混合）、生产部署（扩展与监控）；
• 持续练习：每个用例都是一次新的学习，不同模型、不同工具、不同场景的反复实践是掌握这类技术的唯一捷径。

本课的全部示例代码可在仓库中直接查看运行：app.py（首次提示词）、app-chat.py（多轮对话记忆）、app-tools.py（双工具调用）。课程第 10 课的完整教学文档见 10-ai-framework-project/README.md，作业参考实现位于 solution。你现在已具备构建智能、会对话、能调用工具的完整 AI 应用的知识——问题只剩一个：你要创造什么？

【免费下载链接】Web-Dev-For-Beginners24 Lessons, 12 Weeks, Get Started as a Web Developer项目地址: https://gitcode.com/GitHub_Trending/we/Web-Dev-For-Beginners