使用Python从零搭建一个AI Agent的实战指南

用户输入 → LLM推理 → 决定是否调用工具 → 执行工具 → 观察结果 → 继续推理 → 输出

import json
from openai import OpenAI

client = OpenAI()  # 确保API key已配置

# 定义工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "城市名称"}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "数学表达式"}
                },
                "required": ["expression"]
            }
        }
    }
]

# 工具实现
def get_weather(city: str) -> str:
    # 实际项目中接入天气API
    return f"{city}今天晴，气温22°C"

def calculate(expression: str) -> str:
    try:
        result = eval(expression)  # 生产环境请用安全解析器
        return str(result)
    except Exception as e:
        return f"计算错误: {e}"

TOOL_MAP = {
    "get_weather": get_weather,
    "calculate": calculate,
}

def run_agent(user_input: str, max_steps: int = 5) -> str:
    messages = [{"role": "user", "content": user_input}]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )

        msg = response.choices[0].message
        messages.append(msg)

        # 没有工具调用，直接返回结果
        if not msg.tool_calls:
            return msg.content

        # 执行工具调用
        for tool_call in msg.tool_calls:
            fn_name = tool_call.function.name
            fn_args = json.loads(tool_call.function.arguments)

            print(f"  🔧 调用工具: {fn_name}({fn_args})")
            result = TOOL_MAP[fn_name](**fn_args)

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "达到最大步数限制"

# 简单查询
print(run_agent("北京天气怎么样？"))
# 🔧 调用工具: get_weather({'city': '北京'})
# 北京今天晴，气温22°C

# 多步推理
print(run_agent("北京和上海哪个更暖和？"))
# 🔧 调用工具: get_weather({'city': '北京'})
# 🔧 调用工具: get_weather({'city': '上海'})
# 根据查询结果，上海今天25°C，北京22°C，上海更暖和

import sqlite3

class AgentMemory:
    def __init__(self, db_path: str = "agent_memory.db"):
        self.conn = sqlite3.connect(db_path)
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY,
                key TEXT UNIQUE,
                value TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        """)
        self.conn.commit()

    def save(self, key: str, value: str):
        self.conn.execute(
            "INSERT OR REPLACE INTO memories (key, value) VALUES (?, ?)",
            (key, value)
        )
        self.conn.commit()

    def recall(self, key: str) -> str | None:
        row = self.conn.execute(
            "SELECT value FROM memories WHERE key = ?", (key,)
        ).fetchone()
        return row[0] if row else None

    def list_all(self) -> list[dict]:
        rows = self.conn.execute(
            "SELECT key, value FROM memories ORDER BY created_at DESC LIMIT 20"
        ).fetchall()
        return [{"key": r[0], "value": r[1]} for r in rows]