{ "cells": [ { "cell_type": "code", "execution_count": null, "id": "df3517ed", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "来啦！帮你整理一下结果：\n", "\n", "---\n", "\n", "**🌤 北京今天天气：**\n", "- 天气：☀️ 晴天\n", "- 温度：32°C\n", "- 湿度：45%\n", "- 适合出行，不过天气较热，注意防暑哦！\n", "\n", "**🧮 计算结果：**\n", "- 356 × 128 = **45,568**\n", "\n", "---\n", "\n", "还有什么需要帮忙的吗？😊\n" ] } ], "source": [ "import os\n", "from langchain_openai import ChatOpenAI\n", "from langchain_core.tools import tool\n", "from langchain.agents import create_agent\n", "from dotenv import load_dotenv\n", "\n", "load_dotenv()\n", "\n", "# ============================================================\n", "# 第一步：初始化模型\n", "# ============================================================\n", "model = ChatOpenAI(\n", " model_name=\"deepseek-chat\",\n", " api_key=os.getenv(\"OPENAI_API_KEY\"),\n", " base_url=\"https://api.deepseek.com\"\n", ")\n", "\n", "\n", "# ============================================================\n", "# 第二步：定义工具（只有两个，一清二楚）\n", "# docstring 就是给模型的\"使用说明书\"\n", "# ============================================================\n", "\n", "@tool\n", "def get_weather(city: str) -> str:\n", " \"\"\"查询指定城市的实时天气。\n", "\n", " 当用户问\"某地天气怎么样\"、\"热不热\"、\"要不要带伞\"时调用。\n", "\n", " Args:\n", " city: 城市名称，例如\"北京\"、\"上海\"、\"深圳\"\n", " \"\"\"\n", " # 模拟天气数据（实际项目中对接真实天气 API）\n", " weather_db = {\n", " \"北京\": \"☀️ 晴天，32°C，湿度 45%，适合出行\",\n", " \"上海\": \"🌧️ 小雨，28°C，湿度 80%，建议带伞\",\n", " \"深圳\": \"⛅ 多云，30°C，湿度 65%\",\n", " }\n", " return weather_db.get(city, f\"抱歉，暂无「{city}」的天气数据\")\n", "\n", "\n", "@tool\n", "def calculator(expression: str) -> str:\n", " \"\"\"执行数学计算，支持加减乘除和括号。\n", "\n", " 当用户说\"帮我算\"、\"等于多少\"、\"计算一下\"时调用。\n", "\n", " Args:\n", " expression: 数学表达式，例如 \"128 * 456\"、\"2 ** 10\"、\"(88 + 12) / 5\"\n", " \"\"\"\n", " try:\n", " result = eval(expression)\n", " return f\"🧮 {expression} = {result}\"\n", " except Exception as e:\n", " return f\"❌ 计算出错：{e}\"\n", "\n", "\n", "# ============================================================\n", "# 第三步：组装 Agent\n", "# create_agent 内部自动构建了 Think→Act→Observe 循环\n", "# ============================================================\n", "tools = [get_weather, calculator]\n", "\n", "agent = create_agent(\n", " model=model,\n", " tools=tools,\n", " system_prompt=(\n", " \"你是一个热心肠的生活助手，会查天气、会做算术。\\n\"\n", " \"规则：\\n\"\n", " \"1. 用户问天气 → 调用 get_weather。\\n\"\n", " \"2. 用户要计算 → 调用 calculator。\\n\"\n", " \"3. 一个请求涉及多个工具时，逐个调用，每次观察结果后再决定下一步。\\n\"\n", " \"4. 闲聊类的问候直接回答，不用调工具。\"\n", " ),\n", ")\n", "\n", "# ============================================================\n", "# 第四步：运行 Agent\n", "# ============================================================\n", "response = agent.invoke({\n", " \"messages\": [\n", " {\"role\": \"user\", \"content\": \"北京今天天气怎么样？顺便帮我算一下 356 × 128\"}\n", " ]\n", "})\n", "\n", "print(response[\"messages\"][-1].content)" ] }, { "cell_type": "code", "execution_count": 7, "id": "cea0eb90", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.display import Image, display\n", "\n", "# draw_mermaid_png() 生成 Mermaid 格式的流程图 PNG\n", "display(Image(agent.get_graph().draw_mermaid_png()))" ] }, { "cell_type": "code", "execution_count": 8, "id": "7149adaf", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/1r/_xp9zgm56dqbl9ytglx51ccw0000gn/T/ipykernel_3092/2895360633.py:5: DeprecationWarning: `langchain-community` is being sunset and is no longer actively maintained. See https://github.com/langchain-ai/langchain-community/issues/674 for details and migration guidance toward standalone integration packages.\n", " from langchain_community.tools.tavily_search import TavilySearchResults\n" ] } ], "source": [ "import os\n", "import operator\n", "from typing import Annotated, List, Tuple, TypedDict, Union, Literal\n", "\n", "from langchain_community.tools.tavily_search import TavilySearchResults\n", "from langchain_community.chat_models import ChatTongyi\n", "from langchain_core.prompts import ChatPromptTemplate\n", "from langchain.agents import create_agent\n", "from pydantic import BaseModel, Field\n", "\n", "#https://tavily.com/\n", "#uv pip install tavily-python -i https://pypi.tuna.tsinghua.edu.cn/simple\n", "\n", "# ---- 配置区：请替换为你自己的 Key ----\n", "os.environ[\"TAVILY_API_KEY\"] = os.getenv('TAVILY_API_KEY')\n", "DASHSCOPE_API_KEY = os.getenv('QWEN_API_KEY')" ] }, { "cell_type": "code", "execution_count": 9, "id": "335582a6", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/1r/_xp9zgm56dqbl9ytglx51ccw0000gn/T/ipykernel_3092/110325753.py:2: LangChainDeprecationWarning: The class `TavilySearchResults` was deprecated in LangChain 0.3.25 and will be removed in 1.0. An updated version of the class exists in the `langchain-tavily package and should be used instead. To use it run `pip install -U `langchain-tavily` and import as `from `langchain_tavily import TavilySearch``.\n", " search_tool = TavilySearchResults(max_results=3)\n" ] } ], "source": [ "# 初始化搜索工具，max_results 控制每次搜索返回的条数\n", "search_tool = TavilySearchResults(max_results=3)\n", "tools = [search_tool]\n", "\n", "# 规划阶段用推理能力强的 Qwen-Max\n", "planner_llm = ChatTongyi(\n", " model=\"qwen-max\",\n", " temperature=0.1, # 低温度保证规划稳定\n", " api_key=DASHSCOPE_API_KEY,\n", ")\n", "\n", "# 执行阶段可以用更经济的模型，这里用 Qwen-Plus\n", "executor_llm = ChatTongyi(\n", " model=\"qwen-plus\",\n", " temperature=0.01,\n", " api_key=DASHSCOPE_API_KEY,\n", ")\n", "\n", "# 创建执行 Agent—— 它就是一个标准的 ReAct Agent\n", "executor_agent = create_agent(\n", " model=executor_llm,\n", " tools=tools,\n", " system_prompt=\"你是一个执行力很强的助手。请根据给定的任务步骤，准确完成并给出结果。\",\n", ")" ] }, { "cell_type": "code", "execution_count": 10, "id": "455c80ff", "metadata": {}, "outputs": [], "source": [ "class PlanExecute(TypedDict):\n", " \"\"\"贯穿整个工作流的状态对象\"\"\"\n", " input: str # 用户原始输入\n", " plan: List[str] # 当前计划步骤列表\n", " # past_steps 用 operator.add 做累加——每次节点返回新步骤时自动追加到历史\n", " past_steps: Annotated[List[Tuple[str, str]], operator.add]\n", " response: str # 最终回复（非空时流程结束）\n", "\n", "\n", "class Plan(BaseModel):\n", " \"\"\"规划器输出的结构化计划\"\"\"\n", " steps: List[str] = Field(\n", " description=\"需要顺序执行的步骤列表，每一步必须独立且包含完整上下文\"\n", " )\n", "\n", "\n", "class Response(BaseModel):\n", " \"\"\"直接回复用户的内容\"\"\"\n", " response: str\n", "\n", "\n", "class Act(BaseModel):\n", " \"\"\"\n", " 重规划器的决策输出——要么回复用户，要么给出更新后的计划。\n", " 用 Union 类型确保一次只走一条分支。\n", " \"\"\"\n", " action: Union[Response, Plan] = Field(\n", " description=\"如果任务已完成，返回 Response；如果还需要继续，返回 Plan\"\n", " )" ] }, { "cell_type": "code", "execution_count": null, "id": "3c359e17", "metadata": {}, "outputs": [], "source": [ "# 规划器的系统提示——核心是\"拆得合理、不越界\"\n", "planner_prompt = ChatPromptTemplate.from_messages([\n", " (\n", " \"system\",\n", " \"\"\"你是一个擅长任务分解的规划专家。对于用户提出的目标，请将其拆解为顺序执行的步骤列表。\n", "\n", "规则：\n", "1. 每一步必须自包含——执行者不需要上下文就能理解这步要做什么\n", "2. 不要添加无关步骤，最后一步的结果应该直接导向最终答案\n", "3. 优先使用中文描述步骤\n", "4. 步骤数量控制在 3~6 步，过少说明拆分不到位，过多说明混入了无关操作\"\"\",\n", " ),\n", " (\"placeholder\", \"{messages}\"),\n", "])\n", "\n", "# 将提示词模板和 LLM 拼成一条链，with_structured_output 让 LLM 直接输出 Plan 对象\n", "planner_chain = planner_prompt | planner_llm.with_structured_output(Plan)\n", "\n", "\n", "def plan_step(state: PlanExecute) -> dict:\n", " \"\"\"规划节点：分析用户原始输入，生成执行计划\"\"\"\n", " result = planner_chain.invoke({\"messages\": [(\"user\", state[\"input\"])]})\n", " return {\"plan\": result.steps}" ] }, { "cell_type": "code", "execution_count": 12, "id": "b3bb7698", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Step 1: 收集通义灵码、文心快码、CodeGeeX在2025年的最新信息，重点关注代码补全准确率的数据。\n", " Step 2: 整理上述三款工具支持的编程语言范围，并记录下来用于对比。\n", " Step 3: 调查并记录通义灵码、文心快码、CodeGeeX的价格策略，包括但不限于订阅费用、免费试用条件等。\n", " Step 4: 基于收集到的信息，从代码补全准确率、支持语言数量、价格三个方面对三款工具进行综合评估。\n", " Step 5: 根据评估结果撰写选型建议报告，明确推荐哪款工具以及选择的理由。\n" ] } ], "source": [ "result = planner_chain.invoke({\n", " \"messages\": [(\n", " \"user\",\n", " \"帮我调研一下2025年国内主流代码助手工具（通义灵码、文心快码、CodeGeeX），\"\n", " \"从代码补全准确率、支持语言、价格三个维度做对比，最后给出选型建议。\"\n", " )]\n", "})\n", "\n", "for i, step in enumerate(result.steps, 1):\n", " print(f\" Step {i}: {step}\")" ] }, { "cell_type": "code", "execution_count": 13, "id": "c931f167", "metadata": {}, "outputs": [], "source": [ "def execute_step(state: PlanExecute) -> dict:\n", " \"\"\"\n", " 从当前计划中取出第一步，交给执行 Agent 去跑。\n", " 执行完后把 (步骤描述, 执行结果) 追加到 past_steps。\n", " \"\"\"\n", " plan = state[\"plan\"]\n", "\n", " # 把完整计划格式化，让 Agent 知道\"我在做什么、后面还有什么\"\n", " plan_overview = \"\\n\".join(f\" {i+1}. {step}\" for i, step in enumerate(plan))\n", " current_task = plan[0] # 只取第一步\n", "\n", " # 拼装给 Agent 的指令：先展示全貌，再指定当前任务\n", " task_prompt = f\"\"\"以下是完整的执行计划：\n", "{plan_overview}\n", "\n", "现在请你只执行第 1 步，不要做后续步骤：\n", " → {current_task}\n", "\n", "请直接给出这一步的执行结果，不要啰嗦。\"\"\"\n", "\n", " agent_result = executor_agent.invoke({\n", " \"messages\": [(\"user\", task_prompt)]\n", " })\n", "\n", " # 取 Agent 最后一条消息的内容作为这一步的产出\n", " step_output = agent_result[\"messages\"][-1].content\n", "\n", " return {\n", " # 这一步走完后，计划需要弹出已执行的第一项——这个逻辑在 replan_step 里\n", " \"past_steps\": [(current_task, step_output)],\n", " }" ] }, { "cell_type": "code", "execution_count": 14, "id": "09fcc978", "metadata": {}, "outputs": [], "source": [ "replanner_prompt = ChatPromptTemplate.from_template(\"\"\"\n", "你是一个项目进度管控专家。根据以下信息，判断当前任务的状态并做出决策。\n", "\n", "## 用户原始目标\n", "{input}\n", "\n", "## 原始计划\n", "{plan}\n", "\n", "## 已完成的步骤及结果\n", "{past_steps}\n", "\n", "## 决策规则\n", "1. 如果所有步骤已完成且结果充分，直接给出最终答案（使用 Response）\n", "2. 如果还有步骤未执行，返回更新后的计划（使用 Plan），注意：\n", " - 只保留尚未执行的步骤\n", " - 如果已完成步骤的结果表明原计划的后续步骤需要调整，直接修改\n", " - 不要返回已经做过的步骤\n", "3. 如果某个步骤执行失败了，请在计划中补充重试或替代方案\n", "\"\"\")\n", "\n", "replanner_chain = replanner_prompt | planner_llm.with_structured_output(Act)\n", "\n", "\n", "def replan_step(state: PlanExecute) -> dict:\n", " \"\"\"审视执行进度，决定下一步走向\"\"\"\n", " output = replanner_chain.invoke(state)\n", "\n", " if isinstance(output.action, Response):\n", " # 任务完成，直接返回给用户\n", " return {\"response\": output.action.response}\n", " else:\n", " # 还有步骤要执行，更新计划列表\n", " return {\"plan\": output.action.steps}" ] }, { "cell_type": "code", "execution_count": 15, "id": "059b47e1", "metadata": {}, "outputs": [], "source": [ "from langgraph.graph import StateGraph, START, END\n", "\n", "# ---- 第一步：创建状态图，绑定状态类型 ----\n", "workflow = StateGraph(PlanExecute)\n", "\n", "# ---- 第二步：注册三个核心节点 ----\n", "workflow.add_node(\"planner\", plan_step) # 规划节点\n", "workflow.add_node(\"executor\", execute_step) # 执行节点\n", "workflow.add_node(\"replanner\", replan_step) # 重规划节点\n", "\n", "# ---- 第三步：编排边的流向 ----\n", "workflow.add_edge(START, \"planner\") # 入口 → 规划\n", "workflow.add_edge(\"planner\", \"executor\") # 规划 → 执行\n", "workflow.add_edge(\"executor\", \"replanner\") # 执行 → 重规划\n", "\n", "# ---- 第四步：条件分支——重规划后走哪条路 ----\n", "def should_continue(state: PlanExecute) -> Literal[\"executor\", \"__end__\"]:\n", " \"\"\"如果 response 字段非空，说明重规划器认为任务完成，结束流程\"\"\"\n", " if state.get(\"response\"):\n", " return END\n", " return \"executor\"\n", "\n", "workflow.add_conditional_edges(\"replanner\", should_continue, {\n", " \"executor\": \"executor\",\n", " \"__end__\": END,\n", "})\n", "\n", "# ---- 编译 ----\n", "app = workflow.compile()" ] }, { "cell_type": "code", "execution_count": 16, "id": "3cfea5cc", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.display import Image, display\n", "\n", "# xray=True 会展示更多内部细节\n", "display(Image(app.get_graph(xray=True).draw_mermaid_png()))" ] }, { "cell_type": "code", "execution_count": 19, "id": "d518abb7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "==================================================\n", "📍 当前节点: planner\n", " plan: ['访问通义灵码、文心快码、CodeGeeX的官方网站或通过其他可信渠道收集资料，记录下关于代码补全准确率的信息。', '同样从上述来源收集三种工具支持的编程语言范围，并做好比较记录。', '查找并记录这三种代码助手工具的价格信息，包括但不限于订阅费用、是否有免费试用等条件。', '基于收集到的数据，对三大代码助手在代码补全准确率、支持的语言种类以及价格三个方面进行综合对比分析。', '根据对比结果，结合不同用户群体的需求特点，给出具体的选型建议。']\n", "\n", "==================================================\n", "📍 当前节点: executor\n", " past_steps: [('访问通义灵码、文心快码、CodeGeeX的官方网站或通过其他可信渠道收集资料，记录下关于代码补全准确率的信息。', '根据公开可信来源检索结果，关于三款代码助手的**代码补全准确率**信息整理如下（仅限官方或权威第三方评测披露数据）：\\n\\n- **通义灵码**： \\n 官方未直接公布具体数值型准确率（如Top-1准确率、HumanEval通过率等），但明确指出其底层模型（Qwen2.5-Coder、Qwen3-Coder）在 **LiveCodeBench、BigCodeBench 等主流代码评测中位列开源模型第一**，部分指标“**甚至超过闭源大模型**”；在企业真实场景中，开发者反馈“**代码补全准确率很高**”，前端/Java/Go/Python/C++等主流语言的生成准确性“**大幅提升**”。\\n\\n- **文心快码（Comate）**： \\n 百度官方披露其**代码采纳率（Acceptance Rate）达 44%**（内部万级工程师数据，2024年6月）；SaaS真实场景下统一计算的**采纳率为36.36%（旗舰版）**，对应模型4.0版本；同时标注“**点赞率87.64%**”，反映用户对补全结果的认可度高。\\n\\n- **CodeGeeX**： \\n 在多语言代码生成基准 **HumanEval-X 上，求解率（Pass@1）为 47%~60%**（依语言而异，平均显著优于其他开源基线模型）；该基准涵盖Python、C++、Java、JavaScript、Go五种语言，是当前公认的代码功能正确性评测标准之一。\\n\\n> 注：三者均未统一采用同一评测集（如HumanEval）进行横向对比，且“采纳率”“求解率”“榜单排名”属不同评估维度，不可直接数值换算。以上数据均源自官网、信通院报告、权威媒体及GitHub官方文档。')]\n", "\n", "==================================================\n", "📍 当前节点: replanner\n", " plan: ['同样从上述来源收集三种工具支持的编程语言范围，并做好比较记录。', '查找并记录这三种代码助手工具的价格信息，包括但不限于订阅费用、是否有免费试用等条件。', '基于收集到的数据，对三大代码助手在代码补全准确率、支持的语言种类以及价格三个方面进行综合对比分析。', '根据对比结果，结合不同用户群体的需求特点，给出具体的选型建议。']\n", "\n", "==================================================\n", "📍 当前节点: executor\n", " past_steps: [('同样从上述来源收集三种工具支持的编程语言范围，并做好比较记录。', '| 工具名称 | 支持的编程语言（明确列出） |\\n|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\\n| GitHub Copilot | JavaScript, Python, Java, Ruby, Go, PHP, C++, C#, Swift, TypeScript, Kotlin, Rust, Scala, Perl, C, HTML, CSS, SQL, Shell (bash), Lua, YAML, Dart, R, Julia, VB, Groovy, Matlab, Terraform, ABAP（基于训练数据，支持“几乎所有语言”，官方明确列举约20+种） |\\n| Tabnine | JavaScript, TypeScript, Python, Java, C, C++, C#, Go, PHP, Ruby, Kotlin, Dart, Rust, Lua, Perl, YAML, CUDA, SQL, Scala, Shell (bash), Swift, R, Julia, VB, Groovy, Matlab, Terraform, ABAP, HTML5, CSS, React/Vue, PHP, etc. — **超80种语言及框架** |\\n| Amazon CodeWhisperer | Python, Java, JavaScript, TypeScript, C#, Go, PHP, Rust, Kotlin, SQL, Scala, C, C++, Shell scripting, Ruby, and others — **官方确认支持至少16种主流语言**，持续扩展中 |')]\n", "\n", "==================================================\n", "📍 当前节点: replanner\n", " plan: ['查找并记录这三种代码助手工具的价格信息，包括但不限于订阅费用、是否有免费试用等条件。', '基于收集到的数据，对三大代码助手在代码补全准确率、支持的语言种类以及价格三个方面进行综合对比分析。', '根据对比结果，结合不同用户群体的需求特点，给出具体的选型建议。']\n", "\n", "==================================================\n", "📍 当前节点: executor\n", " past_steps: [('查找并记录这三种代码助手工具的价格信息，包括但不限于订阅费用、是否有免费试用等条件。', '- **GitHub Copilot** \\n - Free tier: Yes — “GitHub Copilot Free” with limited functionality for individual developers (no credit card required); verified students, faculty, OSS contributors, and GitHub MVPs qualify for extended free access. \\n - Pro tier: $10 USD per user/month (billed monthly; gradual rollout for new sign-ups). Includes full features, agents, and priority support. \\n - Business/Enterprise: Custom pricing; not publicly disclosed; requires contact sales. \\n - Free trial: Not separately advertised — free tier serves as entry point; Pro offers no explicit time-limited trial, but eligible users may switch between Free and Pro.\\n\\n- **Tabnine** \\n - Free tier: “Dev Preview” — free, basic code completion (limited IDE support, no advanced AI agents). \\n - Dev Plan: $9 USD per user/month (billed monthly) or $39/user/year (≈$3.25/month); includes AI chat in IDE, whole-line/full-function completions, comment-to-code; 14-day free trial available (no credit card required). \\n - Enterprise Plan: $39 USD per user/month (billed annually); includes VPC/on-prem/air-gapped deployment, SSO, IP indemnification, zero data retention. \\n - Note: No permanent “Free” plan beyond Dev Preview; 90-day trial mentioned in some sources appears outdated — current official docs emphasize 14-day Dev Plan trial.\\n\\n- **Amazon CodeWhisperer (now Amazon Q Developer)** \\n - Free tier: Yes — “Free forever” tier for individuals; includes real-time suggestions, reference tracking, and 50 security scans per user/month. \\n - Pro tier: $19 USD per user/month (billed monthly) or discounted annual billing; adds organizational license/policy management, unlimited security scans, enterprise administration, and AWS IAM Identity Center integration. \\n - Free trial: Not offered separately — free tier functions as perpetual entry-level option; no time-limited trial for Pro tier.')]\n", "\n", "==================================================\n", "📍 当前节点: replanner\n", " plan: ['基于收集到的数据，对三大代码助手在代码补全准确率、支持的语言种类以及价格三个方面进行综合对比分析。', '根据对比结果，结合不同用户群体的需求特点，给出具体的选型建议。']\n", "\n", "==================================================\n", "📍 当前节点: executor\n", " past_steps: [('基于收集到的数据，对三大代码助手在代码补全准确率、支持的语言种类以及价格三个方面进行综合对比分析。', '**三大代码助手综合对比分析（代码补全准确率、支持语言种类、价格）：**\\n\\n| 维度 | GitHub Copilot | Amazon CodeWhisperer | Tabnine |\\n|------------------|--------------------------------------|---------------------------------------|-------------------------------------|\\n| **代码补全准确率** | ⭐⭐⭐⭐⭐（行业领先，上下文理解优秀，生成复杂代码能力强；实测一致高质） | ⭐⭐⭐⭐（表现良好，尤其在AWS生态内精准；安全扫描增强可靠性） | ⭐⭐⭐⭐（质量稳定，本地模型可定制；离线场景下准确性略降但可控） |\\n| **支持语言种类** | 30+ 种主流语言（含Python、JS、TS、Java、Go、Rust等） | 15+ 种（覆盖主流语言，AWS相关语言如CloudFormation强化支持） | 30+ 种（与Copilot相当，兼容性广；Jupyter、Sublime等小众环境支持更优） |\\n| **价格** | $10/月（无免费 tier；企业版另计） | 免费 tier 可用；Enterprise 版需联系报价（含安全审计等高级功能） | 免费 tier 可用；Pro 版 $12/月起；支持私有部署与离线许可（企业级灵活定价） |')]\n", "\n", "==================================================\n", "📍 当前节点: replanner\n", " response: 根据收集到的数据，我已经完成了对2025年国内三大代码助手工具（通义灵码、文心快码、CodeGeeX）在代码补全准确率、支持语言种类以及价格三个维度上的综合对比分析。以下是具体的选型建议：\n", "\n", "1. **代码补全准确率**：\n", " - 通义灵码：尽管没有直接公布具体数值，但其底层模型在主流代码评测中表现优秀，实际用户反馈良好。\n", " - 文心快码：官方披露的采纳率数据表明其实用性较强，且用户点赞率高...\n" ] } ], "source": [ "inputs = {\n", " \"input\": (\n", " \"帮我调研2025年国内三大代码助手工具（通义灵码、文心快码、CodeGeeX），\"\n", " \"从代码补全准确率、支持语言、价格三个维度做对比，最后给出选型建议。\"\n", " \"请用中文输出最终结果。\"\n", " )\n", "}\n", "\n", "# stream 模式可以看到每一步的中间输出\n", "for event in app.stream(inputs):\n", " for node_name, node_output in event.items():\n", " print(f\"\\n{'='*50}\")\n", " print(f\"📍 当前节点: {node_name}\")\n", " # 避免打印太长的内容\n", " for key, value in node_output.items():\n", " if isinstance(value, str) and len(value) > 200:\n", " print(f\" {key}: {value[:200]}...\")\n", " else:\n", " print(f\" {key}: {value}\")" ] }, { "cell_type": "code", "execution_count": null, "id": "40b3940e", "metadata": {}, "outputs": [], "source": [ "from langchain_core.messages import ToolMessage, AIMessage\n", "from langgraph.prebuilt import ToolNode, tools_condition\n", "from typing import Annotated\n", "from operator import add\n", "\n", "\n", "# ============================================================\n", "# 定义工具：模拟向外部系统发送消息\n", "# ============================================================\n", "@tool\n", "def send_message(channel: str, content: str) -> str:\n", " \"\"\"向指定渠道发送消息。\n", "\n", " Args:\n", " channel: 发送渠道，\"wechat\"（企业微信）、\"email\"（邮件）、\"sms\"（短信）\n", " content: 消息正文内容\n", " \"\"\"\n", " # 实际生产环境这里会调飞书/钉钉/企微的 API\n", " return f\"📨 已通过 {channel} 发送：{content}\"\n", "\n", "\n", "tools = [send_message]\n", "\n", "# 模型绑定工具\n", "model_with_tools = ChatOpenAI(\n", " model_name=\"deepseek-chat\",\n", " api_key=os.getenv(\"OPENAI_API_KEY\"),\n", " base_url=\"https://api.deepseek.com\",\n", ").bind_tools(tools)\n", "\n", "\n", "# ============================================================\n", "# 定义状态\n", "# ============================================================\n", "class MsgState(TypedDict):\n", " messages: Annotated[list, add] # add 表示追加而非覆盖\n", "\n", "\n", "# ============================================================\n", "# 定义节点\n", "# ============================================================\n", "def chatbot_node(state: MsgState) -> dict:\n", " \"\"\"LLM 推理节点：决定是否调工具、调哪个工具\"\"\"\n", " response = model_with_tools.invoke(state[\"messages\"])\n", " return {\"messages\": [response]}\n", "\n", "\n", "# 工具执行节点（LangGraph 内置）\n", "tool_node = ToolNode(tools=tools)\n", "\n", "\n", "# ============================================================\n", "# 构建图：chatbot → 条件判断 → tools → chatbot（循环）\n", "# ============================================================\n", "builder = StateGraph(MsgState)\n", "builder.add_node(\"chatbot\", chatbot_node)\n", "builder.add_node(\"tools\", tool_node)\n", "\n", "builder.set_entry_point(\"chatbot\")\n", "builder.add_conditional_edges(\n", " \"chatbot\",\n", " tools_condition, # 内置函数：有 tool_calls → \"tools\"，否则 → END\n", " {\"tools\": \"tools\", \"__end__\": END},\n", ")\n", "builder.add_edge(\"tools\", \"chatbot\")\n", "\n", "# 编译 + 断点：在工具节点执行前暂停\n", "memory = MemorySaver()\n", "graph = builder.compile(\n", " checkpointer=memory,\n", " interrupt_before=[\"tools\"], # 👈 工具实际调用前拦截\n", ")" ] } ], "metadata": { "kernelspec": { "display_name": "05_langgraph (3.11.x)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.-1" } }, "nbformat": 4, "nbformat_minor": 5 }