glmos-code-explain

一、模型介绍

1.1 模型分类

模型应用

• 按输入数据类型：语言模型、视觉模型、语音模型、多模态模型
• 按核心能力：语言模型、推理模型（OpenAI o1、o3，Anthropic Claude 3.7 Sonnet、Baichuan-M1-preview、DeepSeek-R1、字节跳动UltraMem、通义千问 QwQ-32B）、感知模型（文本、图片）
• 按领域划分：通用大模型、行业大模型、垂直大模型
• 按模型使用类型：Chat 模型（又称对话模型，可通过接口调用）、Base模型（又称基座模型，可直接进行微调）

模型架构：

• 按模型架构：Transformer架构（BERT、GPT系列）、卷积神经网络（CNN）、循环神经网络（RNN/LSTM）
• 按训练数据与任务类型：监督学习模型、自监督学习模型、强化学习模型
• 按技术范式：预训练+微调模型、生成式模型、蒸馏与压缩模型

模型公司： OpenAI、百川智能、Meta AI、Anthropic、Google、百度、腾讯、DeepSeek、智谱、Moonshot、讯飞星火、字节豆包、OpenGVLab

1.2 模型使用

1.2.1 智能助手

DeepSeek创造历史！登顶全球AI应用第2名，豆包排名第10

1.2.2 API 调用

OpenAI API 风格调用

curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-4o",
        "messages": [
            {
                "role": "user",
                "content": "Write a one-sentence bedtime story about a unicorn."
            }
        ]
    }'

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <DeepSeek API Key>" \
  -d '{
        "model": "deepseek-chat",
        "messages": [
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"}
        ],
        "stream": false
      }'

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user", 
            "content": "你是谁？"
        }
    ]
}'

API 配置

本地 AI Coding	部署访问-PC	部署访问-H5
	独立部署小助手 嵌入网站中

‍

‍

1.3 模型部署

Ollama 是一个开源项目，旨在提供一个简单、高效的方式来管理和运行大型语言模型（LLMs）。它允许用户在不同的硬件环境中轻松部署和运行这些模型，特别适合开发者和研究人员使用，在大模型使用上提供高效、灵活的解决方案。。

以下是一个简单的 Python 示例，展示如何使用 Ollama 运行一个语言模型：

import ollama

# 下载并运行模型
model = ollama.run("gpt-3")

# 生成文本
response = model.generate("你好，世界！")
print(response)

模型本地部署

二、Prompt

写好提示词：如何写好提示词（Prompt）https://langgptai.feishu.cn/wiki/RXdbwRyASiShtDky381ciwFEnpe

提示词模版工具：https://kimi.moonshot.cn/chat/cv75fn0r7lpta9pk7qlg

模型越来越强大，Prompt 越来越轻量。特定场景任务仍然需要好的 Prompt，得以让模型充分理解发挥推理能力，并给出限定的结果内容。

三、RAG

RAG（Retrieval-Augmented Generation，检索增强生成）是一种结合信息检索与生成模型的人工智能技术，旨在通过外部知识库增强大语言模型（LLMs）的生成能力，解决传统模型在知识局限性、时效性和幻觉问题上的不足。以下是其核心内容：

RAG 的核心原理

1. 检索（Retrieval） 从外部知识库（如数据库、文档集或互联网）中检索与用户查询相关的信息。检索方式包括：

   • 向量检索：通过嵌入模型将文本转换为向量，利用相似度算法（如余弦相似度）匹配相关内容[citation:1][citation:7]。
   • 关键词检索：基于传统搜索引擎技术（如TF-IDF、BM25）筛选信息[citation:18]。
   • 混合检索：结合向量与关键词方法，提升召回率和准确率[citation:16]。

2. 增强（Augmented） 将检索到的上下文信息整合到生成模型的输入中，通常通过以下方式：

   • 上下文拼接：将检索结果直接拼接到用户问题后，作为LLM的输入[citation:5][citation:14]。
   • 动态路由：根据问题类型选择不同的知识库或检索策略（如逻辑路由与语义路由结合）[citation:15]。

3. 生成（Generation） 基于增强后的上下文，LLM生成最终答案。此过程可能结合多轮对话管理和答案验证技术，确保输出的准确性与连贯性[citation:8][citation:11]。

GraphRAG

大多数RAG方法使用向量相似性作为检索技术，我们将其称为基线RAG（Baseline RAG），某些情况下，基线RAG的表现并不理想。以下是几个典型的场景：

1. 基线RAG很难将信息串联起来：当一个问题的答案需要通过多个不同的信息片段，并通过它们共享的属性来连接，进而提供新的综合见解时，基线RAG表现得很差。例如，在回答类似“如何通过现有的数据推断出新结论”这种问题时，基线RAG无法很好地处理这些散布在不同文档中的相关信息，它可能会遗漏一些关键联系点。
2. 基线RAG无法有效理解大型数据集或单一大文档的整体语义概念：当被要求在大量数据或复杂文档中进行总结、提炼和理解时，基线RAG往往表现不佳。例如，如果问题要求对整个文档或多篇文档的主题进行总结和理解，基线RAG的简单向量检索方法可能无法处理文档间的复杂关系，导致对全局语义的理解不完整。

为了应对这些挑战，技术社区正在努力开发扩展和增强RAG的方法。微软研究院（MicrosoftResearch）提出的GraphRAG方法，使用LLM基于输入语料库构建知识图谱。这个图谱与社区总结和图谱机器学习输出结合，能够在查询时增强提示（prompt）。GraphRAG在回答以上两类问题时，展示了显著的改进，尤其是在复杂信息的推理能力和智能性上，超越了基线RAG之前应用于私有数据集的其他方法。

四、Function Calling

Function Calling 技术是一种让语言模型（如 GPT-4 等）能够与外部工具、API 或函数进行交互的机制。它使模型不仅能生成文本，还能根据用户需求动态调用预定义的功能（如查询天气、计算数学公式、调用数据库等），从而扩展模型的实际应用能力。

Function calling是个非常不错的技术设计，但唯一的问题就是，编写这个外部函数的工作量太大了，一个简单的外部函数往往就得上百行代码，而且，为了让大模型“认识”这些外部函数，我们还要额外为每个外部函数编写一个JSON Schema格式的功能说明，此外，我们还需要精心设计一个提示词模版，才能提高 Function calling 响应的准确率。

from dotenv import load_dotenv
import openai
import json
import re
import os

load_dotenv()

# 替换为你的OpenAI API密钥
OPENAI_API_KEY = os.getenv("friday_api_key") 
BASE_URL ="https://aigc.sankuai.com/v1/openai/native"
openai_client = openai.OpenAI(api_key=OPENAI_API_KEY, base_url=BASE_URL)

# 预定义工具集
TOOLS = {
    "get_weather": {
        "description": "获取指定城市的当天天气信息",
        "parameters": {"city": "城市名称"},
        "response": "当前天气的天气情况，如：晴，25℃，空气质量优"
    },
    "generate_text": {
        "description": "根据提示生成文本内容",
        "parameters": {"prompt": "你需要作为一位散文专家，提供足够清晰明确的指令，以确保生成文本的质量"},
        "response": "生成的文本"
    }
}


# mock天气工具
def get_weather(city):
    """模拟天气查询工具"""
    weather_data = {
        "北京": "晴，25℃，空气质量优",
        "上海": "多云，28℃，东南风3级",
        "广州": "阵雨，30℃，湿度85%"
    }
    return weather_data.get(city, "天气信息暂不可用")
  
# 小作文工具
def generate_text(prompt):
    """文本生成工具"""
    print(f"文本生成工具, Prompt:{prompt}")
    response = openai_client.chat.completions.create(
        model="gpt-4o-2024-11-20",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )
    return response.choices[0].message.content.strip()
  
def task_planner(user_task):
    """任务规划器（使用GPT进行任务分解）"""
    system_msg = f'''
                    你是一个高级任务规划AI，请将用户任务分解为可执行的步骤。
                    可用工具：{json.dumps(TOOLS, indent=2)}
                    输出要求：
                    1. 使用JSON格式，包含steps数组
                    2. 每个步骤包含：
                       - "type"（"tool_call"或"text_generation"）
                       - "tool_name"（工具名称，如果是工具调用）
                       - "parameters"（参数对象）
                       - "description"（步骤描述）
                    3. 需要步骤存在先后顺序，需要处理参数依赖（用{{前序步骤编号}}标记）,比如{{step1}}
                    4. 如果使用了tool，请确保给出的参数符合tool的要求
                '''

    response = openai_client.chat.completions.create(
        model="gpt-4o-2024-11-20",
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": user_task}
        ],
        temperature=0.1
    )
  
    try:
        plan = json.loads(re.search(r'\{.*\}', response.choices[0].message.content.strip(), re.DOTALL).group())
        return plan['steps']
    except Exception as e:
        print(f"解析失败，使用备用计划，原数据{response}")
        return [
            {
                "type": "tool_call",
                "tool_name": "get_weather",
                "parameters": {"city": "上海"},
                "description": "获取上海天气信息"
            },
            {
                "type": "text_generation",
                "tool_name": "generate_text",
                "parameters": {"prompt": "根据{step1}的天气写一篇散文"},
                "description": "生成天气相关散文"
            }
        ]
  

def execute_plan(steps):
    """执行任务计划"""
    context = {}
  
    for idx, step in enumerate(steps, 1):
        print(f"\n{'='*30}")
        print(f"步骤 {idx}: {step['description']}")
  
        # 处理参数中的占位符
        params = step.get('parameters', {}).copy()
        for k, v in params.items():
            if isinstance(v, str) and "{step" in v:
                params[k] = re.sub(r'\{step(\d+)\}', lambda m: str(context.get(int(m.group(1)), '')), v)
  
        if step['type'] == 'tool_call':
            tool = step['tool_name']
            print(f"调用工具 {tool}: {params}")
      
            if tool == 'get_weather':
                result = get_weather(params['city'])
            elif tool == 'generate_text':
                result = generate_text(params['prompt'])
            else:
                result = "未知工具"
      
            print(f"工具返回结果:{result}")
            context[idx] = result
      
        elif step['type'] == 'text_generation':
            result = generate_text(params['prompt'])
            print("生成文本:")
            print(result)
            context[idx] = result
  
    return context

  
def main():
    task = "查询北京今天的天气，并写一篇关于该城市适合该天气的简短散文"
    print(f"原始任务: {task}")
  
    print("\n开始任务规划...")
    steps = task_planner(task)
  
    print("\n生成的执行计划:")
    for i, step in enumerate(steps, 1):
        print(f"{i}. [{step['type']}] {step['description']}")
  
    print(f"\n{'='*30}")
    print("\n开始执行计划...")
    print(json.dumps(steps, indent=2, ensure_ascii=False))
    final_context = execute_plan(steps)
  
    print(f"\n{'='*30}")
    print("\n最终结果:")
    print(final_context.get(len(steps), "任务未完成"))

  
main()

五、Agent

5.1 Agent 架构

24年6 月，OpenAI 的应用研究主管 Lilian Weng 撰写了一篇博客，认为 AI Agent 可能会成为新时代的开端。她提出了 Agent=LLM + 规划技能 + 记忆 + 工具使用的基础架构，其中 LLM 扮演了 Agent 的 “大脑”，在这个系统中提供推理、规划等能力，在 ReAct 框架中，LLM 通过交替进行推理（Reasoning）和行动（Action）来完成任务。

规划（Planning）： 负责规划大模型的行动，规划是Agent的决策中心，它将目标分解为可执行的步骤，并制定实现目标的策略。

记忆（Memory）： 负责管理大模型对话时的记忆，分为短期和长期记忆，记忆系统允许Agent存储和检索信息，支持学习和长期知识积累，为Agent提供信息存储和检索的能力。

短期记忆：一个在线客服AI，在对话中记住用户的问题和偏好，以提供即时的个性化服务。

长期记忆：一个科研AI Agent，存储先前研究的数据和结果，在新项目中利用这些信息加速发现过程

工具使用（Tools Use）： 负责让大模型可以连接外部工具，工具使用是Agent利用外部资源或工具来增强其感知、决策和行动能力的过程。这些工具可以是API、软件库、硬件设备或其他服务。

行动（Action） ：负责管理大模型行动的基本流程，行动是Agent执行任务和与环境交互的具体实施者。基于规划和记忆执行的具体动作，是Agent对于环境的响应和任务的完成。

5.2 MCP

官网：https://modelcontextprotocol.io/introduction

MCP官方服务器合集：https://github.com/modelcontextprotocol/servers

Github热门导航：https://github.com/punkpeye/awesome-mcp-servers

MCP集合：https://github.com/ahujasid/blender-mcp

MCP导航：https://mcp.so/ https://smithery.ai/

支持各类客户端的调用：https://modelcontextprotocol.io/clients

5.2.1 MCP 介绍

MCP，全称是Model Context Protocol，模型上下文协议，由Claude母公司Anthropic于24年11月正式提出。MCP 是一种开放协议，它标准化了应用程序如何向LLMs提供上下文。将 MCP 想象成 AI 应用的 USB-C 端口。就像 USB-C 提供了一种标准化的方式将您的设备连接到各种外围设备和配件一样，MCP 提供了一种标准化的方式将 AI 模型连接到不同的数据源和工具。

5.2.2 MCP 核心概念

MCP把大模型运行环境称作 MCP Client，也就是MCP客户端，同时，把外部函数运行环境称作MCP Server，也就是MCP服务器，

根据MCP协议定义，MCP Server可以提供三种类型的标准能力，Resources、Tools、Prompts，每个Server可同时提供者三种类型能力或其中一种。

1. Resources：客户端可读取的数据（如 API 响应或文件内容），资源，类似于文件数据读取，可以是文件资源或是API响应返回的内容。
2. Tools：可以被LLM（经用户批准）调用的功能，工具，第三方服务、功能函数，通过此可控制LLM可调用哪些函数。
3. Prompts: 提示：帮助用户完成特定任务的预写模板，提示词，为用户预先定义好的完成特定任务的模板。

5.2.3 Message Format 消息格式

MCP 使用 JSON-RPC 2.0 作为其线格式。传输层负责将 MCP 协议消息转换为 JSON-RPC 格式进行传输，并将接收到的 JSON-RPC 消息转换回 MCP 协议消息，使用的 JSON-RPC 消息类型有三种：

{
  jsonrpc: "2.0",
  id: number | string,
  method: string,
  params?: object
}

{
  jsonrpc: "2.0",
  id: number | string,
  result?: object,
  error?: {
    code: number,
    message: string,
    data?: unknown
  }
}

{
  jsonrpc: "2.0",
  method: string,
  params?: object
}

5.2.3 MCP服务器通讯机制

当前支持两种传输方式：标准输入输出（Standard Input/Output，stdio）和基于HTTP 的服务器推送事件（Server-Sent-Events，SSE ）。

• Stdio：采用请求-响应模式，客户端发送请求，服务器返回响应，每次请求都是独立的，适合本地集成和命令行工具。
• SSE：允许服务器通过单个持久的 HTTP 连接，持续向客户端推送数据，实现实时更新，

MCP 支持自定义传输，任何传输实现只需符合传输接口，可支持自定义网络协议、专用通信渠道、与现有系统集成。

5.2.4 MCP 调用 Demo

这里我们尝试一个入门级的示例，创建一个天气查询的服务器。通过使用OpenWeather API，创建一个能够实时查询天气的服务器（server），并使用stdio方式进行通信。

import asyncio
import os
import json
import sys
from typing import Optional
from contextlib import AsyncExitStack
from openai import OpenAI
from dotenv import load_dotenv
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# 加载 .env 文件，确保 API Key 受到保护
load_dotenv()

class MCPClient:
    def __init__(self):
        """初始化 MCP 客户端"""
        self.exit_stack = AsyncExitStack()
        self.openai_api_key = os.getenv("OPENAI_API_KEY")  # 读取 OpenAI API Key
        self.base_url = os.getenv("BASE_URL")  # 读取 BASE URL
        self.model = os.getenv("MODEL")  # 读取 model
  
        if not self.openai_api_key:
            raise ValueError("❌ 未找到 OpenAI API Key，请在 .env 文件中设置 OPENAI_API_KEY")
  
        self.client = OpenAI(api_key=self.openai_api_key, base_url=self.base_url)
        # 创建OpenAI client
        self.session: Optional[ClientSession] = None
        self.exit_stack = AsyncExitStack()

    async def connect_to_server(self, server_script_path: str):
        """连接到 MCP 服务器并列出可用工具"""
        is_python = server_script_path.endswith('.py')
        is_js = server_script_path.endswith('.js')
  
        if not (is_python or is_js):
            raise ValueError("服务器脚本必须是 .py 或 .js 文件")
  
        command = "python" if is_python else "node"
        server_params = StdioServerParameters(
            command=command,
            args=[server_script_path],
            env=None
        )
  
        # 启动 MCP 服务器并建立通信
        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
        self.stdio, self.write = stdio_transport
        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
        await self.session.initialize()
  
        # 列出 MCP 服务器上的工具
        response = await self.session.list_tools()
        tools = response.tools
        print("\n已连接到服务器，支持以下工具:", [tool.name for tool in tools])

    async def process_query(self, query: str) -> str:
        """使用大模型处理查询并调用可用的 MCP 工具 (Function Calling)"""
        messages = [{"role": "user", "content": query}]

        response = await self.session.list_tools()

        # openai qwq ds-v3 支持 tools
        available_tools = [{
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description,
                "input_schema": tool.inputSchema # 请求参数说明
            }
        } for tool in response.tools]
        print(available_tools)
  
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            tools=available_tools  # 传入工具
        )
  
  
        # 处理返回的内容
        content = response.choices[0]
        if content.finish_reason == "tool_calls":
            # 如何是需要使用工具，就解析工具
            tool_call = content.message.tool_calls[0]
            tool_name = tool_call.function.name
            tool_args = json.loads(tool_call.function.arguments)
      
            # 执行工具
            result = await self.session.call_tool(tool_name, tool_args)
            print(f"\n\n[Calling tool {tool_name} with args {tool_args}]\n\n")
            print(f"\n\n[Calling tool {tool_name} with result {result}]\n\n")
      
            # 将模型返回的调用哪个工具数据和工具执行完成后的数据都存入messages中
            messages.append(content.message.model_dump())
            # 工具返回的内容
            messages.append({
                "role": "tool",
                "content": result.content[0].text,
                "tool_call_id": tool_call.id,
            })
      
            # 将上面的结果再返回给大模型用于生产最终的结果，（4o、claude 模型支持检测是否回答用户问题，若没有回答会尝试调用其它工具）
            response = self.client.chat.completions.create(
                model=self.model,
                messages=messages,
            )
            return response.choices[0].message.content
        return content.message.content

    async def chat_loop(self):
        """运行交互式聊天循环"""
        print("\n🤖 MCP 客户端已启动！输入 'quit' 退出")
  
        while True:
            try:
                query = input("\n你: ").strip()
                if query.lower() == 'quit':
                    break
          
                response = await self.process_query(query)  # 发送用户输入到 OpenAI API
                print(f"\n🤖 OpenAI: {response}")
            except Exception as e:
                print(f"\n⚠ 发生错误: {str(e)}")

    async def cleanup(self):
        """清理资源"""
        await self.exit_stack.aclose()

async def main():
    if len(sys.argv) < 2:
        print("Usage: python client.py <path_to_server_script>")
        sys.exit(1)
  
    client = MCPClient()
    try:
        await client.connect_to_server(sys.argv[1])
        await client.chat_loop()
    finally:
        await client.cleanup()

if __name__ == "__main__":
    asyncio.run(main())

import json
import httpx
import os
from typing import Any
from dotenv import load_dotenv
from mcp.server.fastmcp import FastMCP

load_dotenv()

# 初始化 MCP 服务器
mcp = FastMCP("WeatherServer")

# OpenWeather API 配置
OPENWEATHER_API_BASE = "https://api.openweathermap.org/data/2.5/weather"
API_KEY = os.getenv("open_weather_api")  # 从 .env 文件获取 OpenWeather API Key
USER_AGENT = "weather-app/1.0"

async def fetch_weather(city: str) -> dict[str, Any] | None:
    """
    从 OpenWeather API 获取天气信息。
    :param city: 城市名称（需使用英文，如 Beijing）
    :return: 天气数据字典；若出错返回包含 error 信息的字典
    """
    params = {
        "q": city,
        "appid": API_KEY,
        "units": "metric",
        "lang": "zh_cn"
    }
  
    headers = {"User-Agent": USER_AGENT}
  
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(
                OPENWEATHER_API_BASE,
                params=params,
                headers=headers,
                timeout=30.0
            )
            response.raise_for_status()
            print(response.json)
            return response.json()  # 返回字典类型
        except httpx.HTTPStatusError as e:
            return {"error": f"HTTP 错误: {e.response.status_code}"}
        except Exception as e:
            return {"error": f"请求失败: {str(e)}"}

def format_weather(data: dict[str, Any] | str) -> str:
    """
    将天气数据格式化为易读文本。
    :param data: 天气数据（可以是字典或 JSON 字符串）
    :return: 格式化后的天气信息字符串
    """
    # 如果传入的是字符串，则先转换为字典
    if isinstance(data, str):
        try:
            data = json.loads(data)
        except Exception as e:
            return f"无法解析天气数据: {e}"

    # 如果数据中包含错误信息，直接返回错误提示
    if "error" in data:
        return f"⚠ {data['error']}"

    # 提取数据时做容错处理
    city = data.get("name", "未知")
    country = data.get("sys", {}).get("country", "未知")
    temp = data.get("main", {}).get("temp", "N/A")
    humidity = data.get("main", {}).get("humidity", "N/A")
    wind_speed = data.get("wind", {}).get("speed", "N/A")
    # weather 可能为空列表，因此用 [0] 前先提供默认字典
    weather_list = data.get("weather", [{}])
    description = weather_list[0].get("description", "未知")

    return (
        f"🌍 {city}, {country}\n"
        f"🌡 温度: {temp}°C\n"
        f"💧 湿度: {humidity}%\n"
        f"🌬 风速: {wind_speed} m/s\n"
        f"⛅ 天气: {description}\n"
    )

@mcp.tool()
async def query_weather(city: str) -> str:
    """
    输入指定城市的英文名称，返回今日天气查询结果。
    :param city: 城市名称（需使用英文）
    :return: 格式化后的天气信息
    """
    data = await fetch_weather(city)
    return format_weather(data)

if __name__ == "__main__":
    # 以标准 I/O 方式运行 MCP 服务器
    mcp.run(transport="stdio")

MCP Inspector

在实际开发MCP服务器的过程中，Anthropic提供了一个非常便捷的debug工具：Inspector。借助Inspector，我们能够非常快捷的调用各类server，并测试其功能。Inspector具体功能实现流程如下。

运行 Inspector npx -y @modelcontextprotocol/inspector uv run server.py

5.2.5 MCP 生态支持

OpenAIhttps://openai.github.io/openai-agents-python/mcp/

agent=Agent(
    name="Assistant",
    instructions="Use the tools to achieve the task",
    mcp_servers=[mcp_server_1 http://api.mcp.com. python mcp_demo.py, mcp_server_2]
)

Curosr

‍

5.3 Workflow 大模型应用开发平台

• dify https://cloud.dify.ai/

  

• coze https://www.coze.cn/

  

5.4 Agent Platform

OpenAI Agent SDK

https://openai.github.io/openai-agents-python/ https://mp.weixin.qq.com/s/vfjzj06iw1QRxIKBXUy-oQ

from agents import Agent, InputGuardrail,GuardrailFunctionOutput, Runner
from pydantic import BaseModel
import asyncio

class HomeworkOutput(BaseModel):
    is_homework: bool
    reasoning: str

 # 检测防护
guardrail_agent = Agent(
    name="Guardrail check",
    instructions="Check if the user is asking about homework.",
    output_type=HomeworkOutput,
)

math_tutor_agent = Agent(
    name="Math Tutor",
    handoff_description="Specialist agent for math questions",
    instructions="You provide help with math problems. Explain your reasoning at each step and include examples",
)

history_tutor_agent = Agent(
    name="History Tutor",
    handoff_description="Specialist agent for historical questions",
    instructions="You provide assistance with historical queries. Explain important events and context clearly.",
)


async def homework_guardrail(ctx, agent, input_data):
    result = await Runner.run(guardrail_agent, input_data, context=ctx.context)
    final_output = result.final_output_as(HomeworkOutput)
    return GuardrailFunctionOutput(
        output_info=final_output,
        tripwire_triggered=not final_output.is_homework,
    )
 
# 分发
triage_agent = Agent(
    name="Triage Agent",
    instructions="You determine which agent to use based on the user's homework question",
    handoffs=[history_tutor_agent, math_tutor_agent],
    input_guardrails=[
        InputGuardrail(guardrail_function=homework_guardrail),
    ],
)

async def main():
    print('[task 1]: who was the first president of the united states? ')
    result = await Runner.run(triage_agent, "who was the first president of the united states?")
    print(result.final_output)

    print('[task 2]: 7 + 8 = ? ')
    result = await Runner.run(triage_agent, "7 + 8 = ?")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Agent TARS

https://agent-tars.com/?utm_source=ai-bot.cn

Agent TARS 是宇宙中研发的多模态 AI Agent 预览版。基于知识解析网络平台，与别的系统协作，实时完成各种任务的执行。Agent TARS 规范提供通用接口，展示多模态元素和语言交流。Agent TARS 通过结构特征和工具特效的结合，成为了多模态交互的强大工具。目前 Agent TARS 主要支持 MacOS，尚不支持其他系统。

5.5 GUI Agent

browser-user

https://github.com/browser-use/browser-use

爬去总结内容

{"done":{"text":"总结成功获取小红书笔记《儿童友好| 🎀18图总结上海200➕遛娃好去处》核心内容：\n\n【分类体系】\n1. 自然休闲（公园绿地）\n2. 美育美德（博物馆美术馆）\n3. 活力运动（体育设施）\n4. 主题游乐（儿童乐园）\n\n【重点区域】\n- 黄浦江沿岸8区滨水空间（静安/黄浦/虹口等）\n- 全市分布200+免费场所（公园/博物馆为主）\n\n【特色推荐】\n✓ 17条轮渡线路亲子体验\n✓ 90%场所免费开放\n✓ 2024年新增儿童友好设施计划\n\n数据来源：上海发布（2024-01-03），完整地图可通过随申办搜索'儿童友好画报'获取","success":true}}

Result: 总结成功获取小红书笔记《儿童友好| 🎀18图总结上海200➕遛娃好去处》核心内容：

【分类体系】

1. 自然休闲（公园绿地）
2. 美育美德（博物馆美术馆）
3. 活力运动（体育设施）
4. 主题游乐（儿童乐园）

【重点区域】

• 黄浦江沿岸8区滨水空间（静安/黄浦/虹口等）
• 全市分布200+免费场所（公园/博物馆为主）

【特色推荐】
✓ 17条轮渡线路亲子体验
✓ 90%场所免费开放
✓ 2024年新增儿童友好设施计划

数据来源：上海发布（2024-01-03），完整地图可通过随申办搜索'儿童友好画报'获取

Mobile GUI Agent

智谱清言 AutoGLM

5.6 多智能体

秒哒、Manus、TARS

六、模型迭代

6.1 模型微调（Fine-tuning

大模型微调全流程指南与效果优化实战手册 如何微调训练私有大模型

6.1.1 模型微调过程

当前工业界最佳实践（如GPT-4、Claude等）通常会完整经历预训练、指令微调、对齐优化、部署评估这四个阶段，

展开查看微调四阶段说明

1. 预训练（Pretraining）

   • 目标：通过海量无标注数据学习通用语言表示
   • 方法：自监督学习（如掩码语言建模/因果建模）
   • 公式表示：

2. 指令微调（Instruction Fine-tuning）

   • 目标：使模型适应任务指令的响应格式
   • 方法：监督学习（人类标注的输入-输出对）
   • 典型损失函数：

3. 对齐优化（Alignment）

   • 常用方法：

     • RLHF（基于人类反馈的强化学习） 策略模型 → 生成响应 → 奖励评分 → PPO更新
     • DPO（直接偏好优化）等新方法

4. 部署评估：：

   • 领域适应（Domain Adaptation），人类偏好评分
   • 安全微调（Safety Fine-tuning），毒性检测得分
   • 指令跟随：ROUGE/BLEU

6.1.2 对齐优化方案

对齐用到的方案： ①强化学习（Reinforcement Learning from Human Feedback，RLHF）②基于人类反馈的监督学习（SLHF）、③对比学习（Contrastive Learning）、④直接偏好优化（Direct Preference Optimization, DPO）

强化学习微调过程：

强化学习算法：

PPO（近端策略优化）： 属于强化学习算法，通过最大化奖励信号优化策略，同时限制策略更新的幅度（通过KL散度惩罚）。

• 特点：需训练价值模型（Critic）评估状态价值，结合奖励模型（Reward Model）生成优势函数，通过Actor-Critic架构迭代优化[2][3][18]。
• 适用场景：需动态调整生成策略的任务（如对话生成、复杂推理），且具备人类反馈或奖励模型支持，OpenAI的GPT-4通过PPO优化生成内容的逻辑性和安全性。

GRPO（群体相对策略优化）： PPO的改进版本，属于无价值模型的强化学习方法。通过对比同一输入下多个输出的相对优势，直接优化策略。

• 特点：无需单独训练价值模型，通过组内对比计算优势值，降低计算资源消耗。
• 适用场景：复杂推理任务（如数学解题、逻辑推导），需高效利用生成多样性提升策略质量，DeepSeek Math模型通过GRPO提升数学解题的步骤准确性。

DPO 等其他变体

• 特点：绕过奖励模型训练，直接通过偏好数据优化策略（如 DPO），进一步简化流程。
• 场景：DPO 是 RLHF 的替代方案，但目标一致（对齐人类偏好），可归入广义的 RLHF 技术范畴。

6.1.3 微调路线选择建议

• 优先SFT：标注数据充足且任务目标明确时（如风格迁移、特定领域问答）。
• 选择PPO：需结合人类反馈动态优化策略，且资源充足（如通用对话系统）。
• 尝试GRPO：面向复杂推理任务（如数学、代码生成），需高效利用生成多样性并减少计算开销。

‍

6.2 模型蒸馏（Distill）

模型蒸馏（Knowledge Distillation, KD）是一种模型压缩技术，旨在将大模型（Teacher Model）的知识迁移到小模型（Student Model） 中，使其在保持较高性能的同时减少计算和存储开销。该方法由 Hinton 等人在2015年提出，广泛应用于自然语言处理（NLP）、计算机视觉（CV）等领域。

模型蒸馏详细介绍

核心思想

• Teacher Model：通常是高性能但计算量大的模型（如BERT、GPT-3）。

• Student Model：轻量级模型（如TinyBERT、DistilBERT），目标是模仿Teacher的行为。

• 知识迁移方式：

  • 软标签（Soft Targets） ：Teacher输出的概率分布（比One-Hot标签包含更多信息）。
  • 中间层特征（Intermediate Features） ：让Student学习Teacher的隐藏层表示。
  • 关系知识（Relation Knowledge） ：如Teacher不同样本间的相似性。

蒸馏方法分类

(1) 基于输出的蒸馏（Logits Distillation）

• 核心：让Student模仿Teacher的预测概率分布（Softmax输出）。

• 损失函数：

  • KL散度（Kullback-Leibler Divergence） ：衡量两个概率分布的差异。
  • 交叉熵损失（Cross-Entropy Loss） ：结合真实标签（Hard Labels）和Teacher的软标签（Soft Labels）。

  LKD=α⋅LCE(y,Student)+(1−α)⋅LKL(Teacher,Student)

  • 其中，α 是权重系数（通常0.1~0.5）。

(2) 基于特征的蒸馏（Feature Distillation）

• 核心：让Student模仿Teacher的中间层特征（如Transformer的Attention或Hidden States）。

• 方法：

  • L2距离：最小化Teacher和Student的隐藏层输出差异。
  • 注意力蒸馏（Attention Distillation） ：让Student学习Teacher的Attention权重（如TinyBERT）。

(3) 基于关系的蒸馏（Relation Distillation）

• 核心：让Student学习Teacher样本间的关系模式（如相似度矩阵）。
• 应用：适用于对比学习（Contrastive Learning）或检索任务。

典型蒸馏流程

1. 训练Teacher模型：在大规模数据上训练高性能模型（如BERT）。

2. 生成软标签：用Teacher对训练数据预测概率分布（Soft Targets）。

3. 训练Student模型：

   • 输入：原始数据 + Teacher的软标签。
   • 优化目标：最小化KL散度 + 交叉熵损失。

4. 可选：中间层对齐（如TinyBERT采用多层特征蒸馏）。

蒸馏的优势

✅ 模型压缩：Student模型参数量可减少50%~90%，推理速度提升2~10倍。
✅ 性能接近Teacher：Student通常能达到Teacher 90%~95%的准确率。
✅ 适用于边缘设备：可在手机、嵌入式设备上部署轻量模型。

应用场景

• NLP：BERT → DistilBERT / TinyBERT（适用于文本分类、问答等）。
• CV：ResNet-50 → MobileNet（适用于图像分类、目标检测）。
• 语音：Wav2Vec 2.0 → 轻量语音识别模型。

6.3 模型蒸馏和微调区别

模型蒸馏和模型微调是深度学习中两种不同的模型优化技术，虽然它们都涉及对预训练模型的进一步训练，但目标、方法和应用场景有显著区别。以下是两者的详细对比：

展开查看对比

模型蒸馏核心是模型压缩，通过知识迁移减少计算开销，适合部署；模型微调核心是任务适配，通过调整参数提升特定任务性能，在实际应用中，两者可结合使用：

1. 先微调Teacher模型：在目标任务上微调大模型（如BERT）。
2. 再蒸馏到Student模型：用微调后的Teacher指导轻量Student训练（如DistilBERT）。
3. 最终部署Student：获得高性能且轻量化的模型。

七 AI IDE

7.1 Curosr

官网：https://www.cursor.com/ 使用教程：https://www.runoob.com/cursor/cursor-tutorial.html

Cursor 编辑器是一款专为现代开发者设计的 AI 驱动的代码编辑器，AI 功能可以显著提升开发效率，减少重复性工作，让开发者更专注于创造性工作。

• 跨平台支持、丰富的插件生态系统、强大的代码编辑功能、集成终端
• 代码补全、代码生成、代码解释、代码调试