AI_Agent入门开发指南

key_3_feng2026-05-16 11:35

一、AI Agent 概述

1.1 什么是 Agent？

AI Agent（人工智能代理）是一种能够自主感知环境、做出决策并执行行动的智能系统。与传统的简单问答不同，Agent 具有目标导向 、自主规划 和工具使用能力，可以完成复杂的多步骤任务。

1.2 Agent 与普通 AI 对话的区别

特性 普通 AI 对话 AI Agent
交互模式 被动响应 主动规划
任务执行 仅生成文本 调用工具执行
记忆能力 无状态 持续记忆
复杂任务 难以处理 分解执行
自主性 完全依赖用户 半自主/全自主

1.3 核心架构：感知-决策-行动

AI Agent 的核心是一个闭环反馈系统：

  • 感知层：接收用户输入、外部环境数据
  • 决策层：LLM 大脑进行理解、规划、推理
  • 行动层：调用工具、执行操作、生成响应

二、Agent 核心组件

2.1 LLM 大脑

大型语言模型是 Agent 的核心决策引擎，负责：

  • 理解用户意图
  • 生成执行计划
  • 处理和响应信息

2.2 记忆系统

Agent 的记忆分为两类：

  • 短期记忆：当前对话上下文，通常通过消息历史实现
  • 长期记忆：持久化存储的知识和经验

2.3 工具调用（Tools）

Agent 通过调用外部工具扩展能力：

  • 搜索工具（搜索网络、查询数据库）
  • 计算工具（执行数学运算）
  • API 工具（调用第三方服务）
  • 文件操作（读写文件）

2.4 规划能力

Agent 需要具备任务分解能力，将复杂任务拆解为可执行的子任务。

三、从零搭建一个简单 Agent

下面我们用 Python 从零构建一个基础 Agent 框架：

python 复制代码 
"""
AI Agent 基础框架
实现核心组件：LLM 调用、工具注册、对话循环
"""

import json
import os
from typing import List, Dict, Any, Callable
from dataclasses import dataclass, field
from openai import OpenAI

# ============ 1. 工具定义 ============

@dataclass
class Tool:
    """工具定义类"""
    name: str                           # 工具名称
    description: str                    # 工具描述（供 LLM 理解何时使用）
    func: Callable                      # 工具执行函数
    params_schema: Dict[str, Any] = field(default_factory=dict)  # 参数模式

# 工具注册表
TOOLS: List[Tool] = []

def register_tool(name: str, description: str, params_schema: Dict = None):
    """装饰器：注册工具到工具表"""
    def decorator(func: Callable):
        tool = Tool(
            name=name,
            description=description,
            func=func,
            params_schema=params_schema or {}
        )
        TOOLS.append(tool)
        return func
    return decorator

def get_tools_json() -> List[Dict]:
    """获取工具列表（用于 Function Calling）"""
    return [
        {
            "name": tool.name,
            "description": tool.description,
            "parameters": tool.params_schema
        }
        for tool in TOOLS
    ]

# ============ 2. 定义几个实用工具 ============

@register_tool(
    name="calculator",
    description="执行数学计算，支持加减乘除、幂运算等",
    params_schema={
        "type": "object",
        "properties": {
            "expression": {"type": "string", "description": "数学表达式，如 2+3*5"}
        },
        "required": ["expression"]
    }
)
def calculator(expression: str) -> str:
    """计算器工具"""
    try:
        # 安全计算：仅允许基本数学运算
        allowed_chars = set('0123456789+-*/.() ')
        if all(c in allowed_chars for c in expression):
            result = eval(expression)
            return f"计算结果：{expression} = {result}"
        return "错误：表达式包含非法字符"
    except Exception as e:
        return f"计算错误：{str(e)}"

@register_tool(
    name="weather",
    description="查询指定城市的天气信息",
    params_schema={
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "城市名称"}
        },
        "required": ["city"]
    }
)
def weather(city: str) -> str:
    """天气查询工具（模拟）"""
    # 实际项目中这里会调用真实的天气 API
    weather_data = {
        "北京": "晴，25°C",
        "上海": "多云，28°C",
        "广州": "雷阵雨，30°C"
    }
    return weather_data.get(city, f"未知城市 {city} 的天气信息")

# ============ 3. Agent 核心类 ============

class SimpleAgent:
    """简单 Agent 实现"""
    
    def __init__(self, api_key: str = None, model: str = "gpt-4o-mini"):
        """
        初始化 Agent
        
        Args:
            api_key: OpenAI API 密钥
            model: 使用的模型
        """
        self.client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
        self.model = model
        self.messages = []  # 对话历史
        self.max_turns = 10  # 最大交互轮次（防止无限循环）
    
    def add_system_prompt(self, prompt: str):
        """添加系统提示词"""
        self.messages.append({"role": "system", "content": prompt})
    
    def chat(self, user_input: str) -> str:
        """
        核心对话方法：处理用户输入并返回响应
        
        采用 ReAct 模式（Reasoning + Acting）
        """
        # 添加用户消息
        self.messages.append({"role": "user", "content": user_input})
        
        # 限制对话长度
        if len(self.messages) > 50:
            self.messages = [self.messages[0]] + self.messages[-49:]
        
        turn = 0
        while turn < self.max_turns:
            turn += 1
            
            # 调用 LLM
            response = self.client.chat.completions.create(
                model=self.model,
                messages=self.messages,
                tools=get_tools_json(),
                tool_choice="auto"
            )
            
            assistant_msg = response.choices[0].message
            self.messages.append(assistant_msg.model_dump())
            
            # 判断是否需要调用工具
            if assistant_msg.tool_calls:
                # 执行工具调用
                for tool_call in assistant_msg.tool_calls:
                    tool_result = self._execute_tool(tool_call)
                    # 添加工具结果到对话
                    self.messages.append({
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "content": tool_result
                    })
                # 继续循环，让 LLM 根据工具结果生成回复
                continue
            else:
                # 无工具调用，返回最终回复
                return assistant_msg.content
        
        return "已达到最大交互次数，请重新开始对话"
    
    def _execute_tool(self, tool_call) -> str:
        """执行单个工具调用"""
        tool_name = tool_call.function.name
        tool_args = json.loads(tool_call.function.arguments)
        
        # 查找并执行工具
        for tool in TOOLS:
            if tool.name == tool_name:
                try:
                    return tool.func(**tool_args)
                except Exception as e:
                    return f"工具执行错误：{str(e)}"
        
        return f"未找到工具：{tool_name}"

# ============ 4. 使用示例 ============

if __name__ == "__main__":
    # 创建 Agent 实例
    agent = SimpleAgent()
    
    # 设置系统提示词
    agent.add_system_prompt(
        "你是一个智能助手，可以帮助用户完成各种任务。"
        "当你需要执行计算或查询天气时，可以使用相应的工具。"
    )
    
    # 对话示例
    print("=" * 50)
    print("Agent 对话演示")
    print("=" * 50)
    
    # 测试计算功能
    response = agent.chat("帮我计算 (25 + 15) * 2 等于多少？")
    print(f"\n用户：帮我计算 (25 + 15) * 2 等于多少？")
    print(f"Agent：{response}")
    
    # 测试天气功能
    response = agent.chat("北京今天天气怎么样？")
    print(f"\n用户：北京今天天气怎么样？")
    print(f"Agent：{response}")

运行上述代码前，请确保设置环境变量：

bash 复制代码 
export OPENAI_API_KEY="your-api-key"

四、工具调用实战

4.1 Function Calling 机制

主流大模型（如 GPT-4、Claude、GLM 等）都支持 Function Calling，这是一种让模型「决定」调用外部工具的能力：

  1. 工具描述：定义工具的名称、描述、参数
  2. 模型决策：模型根据用户意图选择合适的工具
  3. 参数生成：模型生成工具调用的参数
  4. 执行与反馈：执行工具并返回结果给模型

4.2 多工具协作示例

下面是一个更复杂的多工具协作场景：

python 复制代码 
"""
多工具协作 Agent 示例
集成搜索、计算、文件操作等多种工具
"""

import json
from datetime import datetime
from typing import List, Dict

# ============ 扩展工具集 ============

@register_tool(
    name="web_search",
    description="搜索互联网获取最新信息",
    params_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "搜索关键词"},
            "max_results": {"type": "integer", "description": "返回结果数量", "default": 5}
        },
        "required": ["query"]
    }
)
def web_search(query: str, max_results: int = 5) -> str:
    """
    模拟网络搜索功能
    实际项目中可接入 SerpAPI、Google Search 等服务
    """
    # 这里返回模拟数据，实际项目请接入真实搜索 API
    results = [
        f"搜索结果 1：关于「{query}」的最新资讯（来源：新闻网站）",
        f"搜索结果 2：「{query}」的相关讨论（来源：社区论坛）",
        f"搜索结果 3：「{query}」的百科介绍（来源：维基百科）"
    ]
    return "\n".join(results[:max_results])

@register_tool(
    name="save_to_file",
    description="将内容保存到文件",
    params_schema={
        "type": "object",
        "properties": {
            "filename": {"type": "string", "description": "文件名"},
            "content": {"type": "string", "description": "要保存的内容"}
        },
        "required": ["filename", "content"]
    }
)
def save_to_file(filename: str, content: str) -> str:
    """文件保存工具"""
    try:
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(content)
        return f"文件已保存：{filename}"
    except Exception as e:
        return f"保存失败：{str(e)}"

@register_tool(
    name="read_file",
    description="读取文件内容",
    params_schema={
        "type": "object",
        "properties": {
            "filename": {"type": "string", "description": "要读取的文件名"}
        },
        "required": ["filename"]
    }
)
def read_file(filename: str) -> str:
    """文件读取工具"""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        return f"文件不存在：{filename}"
    except Exception as e:
        return f"读取失败：{str(e)}"

@register_tool(
    name="get_current_time",
    description="获取当前日期和时间",
    params_schema={
        "type": "object",
        "properties": {}
    }
)
def get_current_time() -> str:
    """获取当前时间"""
    return f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"

# ============ Agent 增强版 ============

class EnhancedAgent(SimpleAgent):
    """增强版 Agent，支持更多功能"""
    
    def __init__(self, api_key: str = None, model: str = "gpt-4o-mini"):
        super().__init__(api_key, model)
        self.conversation_history = []  # 持久化对话历史
    
    def chat(self, user_input: str) -> str:
        """对话方法，添加上下文管理"""
        # 添加时间上下文
        time_context = f"\n\n[系统信息] 当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
        enhanced_input = user_input + time_context
        
        response = super().chat(enhanced_input)
        
        # 保存对话历史
        self.conversation_history.append({
            "user": user_input,
            "assistant": response,
            "timestamp": datetime.now().isoformat()
        })
        
        return response
    
    def get_history(self, limit: int = 10) -> List[Dict]:
        """获取对话历史"""
        return self.conversation_history[-limit:]
    
    def clear_history(self):
        """清空对话历史"""
        self.conversation_history = []
        self.messages = []

# ============ 使用示例 ============

if __name__ == "__main__":
    # 创建增强版 Agent
    agent = EnhancedAgent()
    
    agent.add_system_prompt(
        """你是一个功能强大的 AI 助手。
        你可以使用以下工具：
        - calculator: 执行数学计算
        - weather: 查询城市天气
        - web_search: 搜索互联网
        - save_to_file: 保存内容到文件
        - read_file: 读取文件内容
        - get_current_time: 获取当前时间
        
        请根据用户需求选择合适的工具来完成任务。"""
    )
    
    print("=" * 50)
    print("增强版 Agent 对话演示")
    print("=" * 50)
    
    # 测试搜索功能
    response = agent.chat("帮我搜索一下 AI Agent 最新的发展趋势")
    print(f"\nAgent：{response}")
    
    # 测试时间功能
    response = agent.chat("现在几点了？")
    print(f"\nAgent：{response}")
    
    # 查看对话历史
    print("\n--- 对话历史 ---")
    for item in agent.get_history():
        print(f"用户: {item['user']}")
        print(f"助手: {item['assistant'][:50]}...")
        print("---")

五、记忆与上下文管理

5.1 短期记忆（对话上下文）

短期记忆通过维护消息历史实现：

python 复制代码 
class MemoryManager:
    """记忆管理器"""
    
    def __init__(self, max_history: int = 50):
        self.short_term_memory = []  # 短期记忆：对话历史
        self.long_term_memory = []   # 长期记忆：重要信息
        self.max_history = max_history
    
    def add_turn(self, role: str, content: str):
        """添加一轮对话"""
        self.short_term_memory.append({
            "role": role,
            "content": content
        })
        # 自动裁剪过长的历史
        if len(self.short_term_memory) > self.max_history:
            self.short_term_memory = self.short_term_memory[-self.max_history:]
    
    def add_to_long_term(self, key: str, value: str):
        """添加到长期记忆"""
        self.long_term_memory.append({"key": key, "value": value})
    
    def get_context_window(self, window_size: int = 10) -> List[Dict]:
        """获取最近的上下文窗口"""
        return self.short_term_memory[-window_size:]
    
    def summarize_if_needed(self, threshold: int = 20) -> str:
        """当历史过长时进行摘要"""
        if len(self.short_term_memory) > threshold:
            # 简单的摘要逻辑：保留首尾消息
            summary = f"[摘要：对话共 {len(self.short_term_memory)} 轮]"
            return summary
        return ""

5.2 长期记忆策略

  • 向量数据库：使用 Embedding 将重要信息向量化存储
  • 关键信息提取：从对话中提取用户偏好、任务状态等
  • 定期总结：定期将对话精华压缩存储

六、完整实战案例

下面是一个可运行的多工具 Agent 系统，具备完整的对话循环和错误处理：

python 复制代码 
"""
完整的多工具 Agent 系统
包含：搜索 + 计算 + 天气 + 文件操作
可直接运行（需要配置 API Key）
"""

import json
import os
from typing import List, Dict, Optional
from openai import OpenAI
from datetime import datetime

# ============ 工具定义 ============

class ToolRegistry:
    """工具注册表"""
    
    def __init__(self):
        self.tools: List[Dict] = []
        self.functions: Dict = {}
    
    def register(self, name: str, description: str, parameters: Dict, func: callable):
        """注册工具"""
        self.tools.append({
            "type": "function",
            "function": {
                "name": name,
                "description": description,
                "parameters": parameters
            }
        })
        self.functions[name] = func
    
    def get_tools(self) -> List[Dict]:
        return self.tools
    
    def execute(self, name: str, arguments: str) -> str:
        """执行工具"""
        if name not in self.functions:
            return f"错误：未找到工具 {name}"
        try:
            args = json.loads(arguments) if isinstance(arguments, str) else arguments
            result = self.functions[name](**args)
            return str(result)
        except Exception as e:
            return f"执行错误：{str(e)}"

# 全局工具注册表
registry = ToolRegistry()

# ============ 实现工具函数 ============

def search_web(query: str, max_results: int = 3) -> str:
    """模拟网络搜索"""
    results = [
        f"1. 「{query}」权威解释 - 来源：Wikipedia",
        f"2. 「{query}」最新动态 - 来源：技术博客", 
        f"3. 「{query}」实践指南 - 来源：开发者社区"
    ]
    return "\n".join(results[:max_results])

def calculate(expression: str) -> str:
    """安全计算器"""
    allowed = set('0123456789+-*/.()e ')
    if all(c in allowed for c in expression):
        try:
            result = eval(expression)
            return f"结果：{expression} = {result}"
        except:
            return "计算表达式无效"
    return "表达式包含非法字符"

def query_weather(city: str) -> str:
    """查询天气"""
    weather_db = {
        "北京": "晴 26°C 适宜出行",
        "上海": "多云 28°C 略有闷热",
        "深圳": "阵雨 31°C 记得带伞",
        "成都": "阴 24°C 体感舒适"
    }
    if city in weather_db:
        return f"{city}今日天气：{weather_db[city]}"
    return f"暂无{city}的天气数据"

def save_file(filename: str, content: str) -> str:
    """保存文件"""
    try:
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(content)
        return f"✅ 文件已保存至：{filename}"
    except Exception as e:
        return f"❌ 保存失败：{str(e)}"

def read_file_content(filename: str) -> str:
    """读取文件"""
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        return f"❌ 文件不存在：{filename}"
    except Exception as e:
        return f"❌ 读取失败：{str(e)}"

def get_date() -> str:
    """获取日期"""
    return datetime.now().strftime("%Y年%m月%d日 %H:%M:%S")

# 注册所有工具
registry.register(
    name="web_search",
    description="搜索互联网获取信息，适用于回答实时性问题或查询最新资讯",
    parameters={
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "搜索关键词"},
            "max_results": {"type": "integer", "description": "最大结果数", "default": 3}
        },
        "required": ["query"]
    },
    func=search_web
)

registry.register(
    name="calculator",
    description="执行数学计算，支持加减乘除和括号",
    parameters={
        "type": "object",
        "properties": {
            "expression": {"type": "string", "description": "数学表达式，如 2+3*4"}
        },
        "required": ["expression"]
    },
    func=calculate
)

registry.register(
    name="weather_query",
    description="查询城市天气情况",
    parameters={
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "城市名称"}
        },
        "required": ["city"]
    },
    func=query_weather
)

registry.register(
    name="file_save",
    description="将内容保存到文件",
    parameters={
        "type": "object",
        "properties": {
            "filename": {"type": "string", "description": "文件名"},
            "content": {"type": "string", "description": "文件内容"}
        },
        "required": ["filename", "content"]
    },
    func=save_file
)

registry.register(
    name="file_read",
    description="读取文件内容",
    parameters={
        "type": "object",
        "properties": {
            "filename": {"type": "string", "description": "要读取的文件名"}
        },
        "required": ["filename"]
    },
    func=read_file_content
)

registry.register(
    name="get_time",
    description="获取当前日期和时间",
    parameters={"type": "object", "properties": {}},
    func=get_date
)

# ============ MultiToolAgent 主类 ============

class MultiToolAgent:
    """多工具 Agent"""
    
    def __init__(self, api_key: str = None):
        self.client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
        self.model = "gpt-4o-mini"
        self.messages = []
        self.max_turns = 8
        
        # 系统提示词
        self.messages.append({
            "role": "system",
            "content": """你是一个智能助手，名为「小智」。你的职责是：
1. 准确理解用户问题
2. 必要时调用工具获取信息或执行操作
3. 以友好、专业的方式回答问题

可用工具：web_search（搜索）、calculator（计算）、weather_query（查天气）、
         file_save（保存文件）、file_read（读取文件）、get_time（获取时间）"""
        })
    
    def chat(self, user_input: str) -> str:
        """对话入口"""
        self.messages.append({"role": "user", "content": user_input})
        
        for _ in range(self.max_turns):
            response = self.client.chat.completions.create(
                model=self.model,
                messages=self.messages,
                tools=registry.get_tools(),
                tool_choice="auto"
            )
            
            msg = response.choices[0].message
            self.messages.append(msg.model_dump())
            
            if msg.tool_calls:
                # 执行所有工具调用
                for call in msg.tool_calls:
                    result = registry.execute(
                        call.function.name,
                        call.function.arguments
                    )
                    self.messages.append({
                        "role": "tool",
                        "tool_call_id": call.id,
                        "content": result
                    })
                continue
            
            return msg.content
        
        return "已达到最大交互次数"
    
    def reset(self):
        """重置对话"""
        self.messages = [self.messages[0]]  # 保留系统提示词

# ============ 运行演示 ============

if __name__ == "__main__":
    print("🤖 MultiToolAgent 系统演示")
    print("=" * 50)
    
    # 创建 Agent（请先设置 OPENAI_API_KEY 环境变量）
    agent = MultiToolAgent()
    
    # 演示对话
    queries = [
        "今天几号了？",
        "北京天气怎么样？",
        "帮我算一下 128 * 256 + 1024",
        "帮我把 'Hello, AI Agent!' 保存到 hello.txt 文件",
        "用几句话介绍一下 AI Agent 的发展趋势"
    ]
    
    for q in queries:
        print(f"\n👤 用户：{q}")
        print(f"🤖 助手：{agent.chat(q)}")
        print("-" * 50)

七、进阶方向

7.1 ReAct 模式

ReAct（Reasoning + Acting）是一种让 Agent 显式进行推理并行动的框架：

python 复制代码 
"""
ReAct 模式实现
让 Agent 显式展示思考过程
"""

class ReActAgent:
    """ReAct 模式的 Agent"""
    
    SYSTEM_PROMPT = """你是一个采用 ReAct 模式的智能助手。
    对于每个问题，你需要按以下格式思考：
    
    Thought: 分析当前情况，考虑是否需要调用工具
    Action: 工具名称（如有需要）
    Action Input: 工具参数（如有需要）
    Observation: 工具执行结果
    ... (重复 Thought/Action/Action Input/Observation 直到完成任务)
    Final Answer: 最终回答
    """
    
    def __init__(self, api_key: str = None):
        self.client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
        self.messages = [{"role": "system", "content": self.SYSTEM_PROMPT}]
    
    def chat(self, question: str) -> str:
        self.messages.append({"role": "user", "content": question})
        
        # 连续对话直到得到最终答案
        max_iterations = 10
        for _ in range(max_iterations):
            response = self.client.chat.completions.create(
                model="gpt-4o-mini",
                messages=self.messages,
                tools=registry.get_tools()
            )
            
            msg = response.choices[0].message
            self.messages.append(msg.model_dump())
            
            # 检查是否有工具调用
            if msg.tool_calls:
                for call in msg.tool_calls:
                    result = registry.execute(call.function.name, call.function.arguments)
                    self.messages.append({
                        "role": "tool",
                        "tool_call_id": call.id,
                        "content": f"Observation: {result}"
                    })
                continue
            
            # 检查是否包含最终答案
            if "Final Answer:" in msg.content:
                return msg.content
            else:
                return msg.content
        
        return "无法完成推理"

7.2 Multi-Agent 协作

多个 Agent 协同工作，各司其职：

复制代码 
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  规划 Agent │ ──▶ │ 执行 Agent  │ ──▶ │  审核 Agent │
└─────────────┘     └─────────────┘     └─────────────┘
      分解任务          调用工具           质量把控

7.3 RAG 增强

结合检索增强生成（Retrieval-Augmented Generation），让 Agent 具备知识库查询能力。

7.4 主流框架简介

框架 特点 适用场景
LangChain 功能全面，组件丰富 快速原型开发
AutoGen 微软出品，Multi-Agent 强 多 Agent 协作
CrewAI 角色驱动，易上手 任务编排
Dify 低代码，平台化 快速部署上线

八、总结

本文从核心概念出发，详细介绍了 AI Agent 的架构设计和实现方法：

  1. 核心架构：感知层 → 决策层 → 行动层的闭环系统
  2. 关键组件：LLM 大脑、记忆系统、工具调用、规划能力
  3. 实战代码：从简单框架到完整的多工具 Agent
  4. 进阶方向：ReAct 模式、Multi-Agent、RAG 增强

AI Agent 是大模型应用的重要方向，掌握其核心原理和实现方法，将帮助你在 AI 时代占据先机。建议从本文的示例代码入手，逐步扩展功能，最终构建满足自己需求的智能 Agent 系统。

相关推荐
IT界的渣1 小时前
AI文章改写系统源码，AI文字创作系统，AI文章工具原创一手源码，支持多个自媒体多平台
人工智能·媒体·ai自动写文章·ai文章工具·ai文章改写源码·ai文字创作系统
逻辑君1 小时前
物理学研究报告【20260001】
人工智能·算法
MarkHD1 小时前
本地化人工智能实践：下载并运行通义千问Qwen2.5-4B模型
人工智能
武汉唯众智创1 小时前
从0到1搭建AI心理健康预警系统：我是如何用BERT+BiLSTM捕捉情绪拐点的
人工智能·ai大模型·ai心理健康·校园心理健康·ai心理健康预警系统
新知图书1 小时前
带搜索工具的对话 Agent示例与解析
人工智能·langchain·agent·智能体·langgraph
小仙女的小稀罕1 小时前
适合企业行政开工作会议的，一加会议转任务工具
大数据·人工智能
AI科技星1 小时前
算法联盟·全域数学公理体系下黑洞标量毛发与LVK引力波O4全维理论、求导、证明、计算、验证、分析
人工智能·线性代数·算法·架构·学习方法·量子计算
YuanDaima20481 小时前
图论基础原理与题目说明
数据结构·人工智能·python·算法·图论·手撕代码
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03【AI】2026 年具身智能模型和世界模型总结04CC-Switch & Claude 基于 Linux 服务器安装使用指南05人工智能最新动态 AI 日报 · 2026年5月10日06AI科技热点日报 | 2026年5月11日07Gemini大升级、AI眼镜首发、Android XR亮相，13天后见分晓08零基础教你claude code 接入 deepseek V409codex app每次打开重连5次Reconnecting问题解决102026年AI前瞻：量子AI、具身智能与科学发现的新纪元