基于Python编写一个简化版AI Agent智能体

目录

• 1. AI Agents的概念，它和LLM有什么不同？
• 2.工具使用 (Tool Use)
• 3.记忆 (Memory)
• 4.规划 (Planning)
• 5. 总结核心观点

1. AI Agents的概念，它和LLM有什么不同？

如果你觉得人工智能 (AI) 很有意思但又有点模糊，那么你一定会对 AI agent 感兴趣。没错，我们说的就是大语言模型 (LLM) 公司已经投资了数十亿来开发的 AI agent。AI agent 是软件实体，可接收任务、检查环境、根据角色执行操作并根据经验进行调整。

AI Agents与LLM的区别，可以简单粗暴看看下面知乎大神画的图。

总体来说，Agent是在LLM的基础上加上增加三个主要功能：Tools(工具使用), Memory (记忆), Planning (规划)。下面就以这三个功能，用python简单实现一下，帮助大家更好理解这三个功能。

2.工具使用 (Tool Use)

假设我有两个工具，一个是“获取当前的日期和时间信息”，一个是“简单计算器工具”，我将会问三个问题，

• “现在几点了？”,
• “帮我计算 15 * 8 + 20”,
• “今天是什么日期？”

下面是python代码实现：

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
from langchain_core.tools import Tool
import datetime

# 加载环境变量
load_dotenv()
os.environ["OPENAI_API_KEY"] = "sk-某宝35块apikey"
api_key = os.getenv('OPENAI_API_KEY')

# ========== 1. 初始化 LLM（大语言模型） ==========
# LangChain 特点：统一的 LLM 接口，支持多种模型提供商
llm = ChatOpenAI(
    base_url="https://api.openai.com/v1",
    api_key=api_key,
    model="gpt-4o",
    temperature=0.7  # LangChain 特点：统一的参数配置
)

# ========== 2. LLMChain：Prompt → LLM → 输出链的基本流程封装 ==========
def demo_llm_chain():
    """
    演示 LLMChain：支持变量注入与模板复用的核心组件
    LangChain 特点：模板化提示词管理，支持变量替换
    """
    print("=" * 50)
    print(" LLMChain 演示：Prompt → LLM → 输出链")
    print("=" * 50)
    
    # 创建提示词模板 - LangChain 特点：模板复用
    prompt_template = PromptTemplate(
        input_variables=["topic", "style"],
        template="""
        请以{style}的风格，写一段关于{topic}的介绍。
        要求：简洁明了，不超过100字。
        """
    )
    
    # LangChain 0.3 推荐使用 LCEL (LangChain Expression Language)
    # 这是新的链式组合方式：prompt | llm
    chain = prompt_template | llm
    
    # 执行链 - 变量注入
    result = chain.invoke({"topic": "人工智能", "style": "科普"})
    print(f" LLMChain 输出：\n{result.content}\n")
    
    return result.content

# ========== 3. Tools：工具系统 ==========
def get_current_time(query: str) -> str:
    """获取当前时间的工具函数"""
    return f"当前时间是：{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"

def calculate_simple(expression: str) ->http://www.devze.com str:
    """简单计算器工具"""
    try:
        # 安全的数学表达式计算
        allowed_chars = set('0123456789+-*/.() ')
        if all(c in allowed_chars for c in expression):
            result = eval(expression)
            return f"计算结果：{expression} = {result}"
        else:
            return "错误：包含不允许的字符"
    except Exception as e:
        return f"计算错误：{str(e)}"

# LangChain 特点：统一的工具接口定义
tools = [
    Tool(
        name="get_time",
        func=get_current_time,
        description="获取当前的日期和时间信息"
    ),
    Tool(
        name="calculator",
        func=calculate_simple,
        description="执行简单的数学计算，如加减乘除运算"
    )
]

def demo_tools():
    """演示 Tools 工具系统"""
    print("=" * 50)
    print("️ Tools 演示：工具系统")
    print("=" * 50)
    
    for tool in tools:
        print(f"工具名称：{tool.name}")
        print(f"工具描述：{tool.description}")
        
        # 测试工具
        if tool.name == "get_time":
            result = tool.run("现在几点了？")
        else:
            result = tool.run("10 + 5 * 2")
        
        print(f"工具输出：{result}\n")

# ========== 4. 简化版 Agents：手动工具选择演示 ==========
def demo_simple_agents():
    """
    演示简化版 Agents：手动工具选择和执行
    LangChain 特点：工具集成和智能选择（这里用简化版演示概念）
    """
    print("=" * 50)
    print(" 简化版 Agents 演示：工具选择与执行")
    print("=" * 50)
    
    # 创建工具选择提示词
    tool_selection_prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个智能助手，可以使用以下工具：
        1. get_time - 获取当前时间
        2. calculator - 执行数学计算
        
        请分析用户问题，选择合适的工具并说明原因。
        只回答工具名称和原因，格式：工具名称|原因"""),
        ("human", "{question}")
    ])
    
    tool_chain = tool_selection_prompt | llm
    
    test_questions = [
        "现在几点了？",
        "帮我计算 15 * 8 + 20",
        "今天是什么日期？"
    ]
    
    for question in test_questions:
        print(f" 用户问题：{question}")
        
        # 1. 工具选择
        selection_result = tool_chain.invoke({"question": question})
        print(f" 工具选择：{selection_result.content}")
        
        # 2. 执行工具（简化版手动执行）
        if "get_time" in selection_result.content.lower():
            result = get_current_time(question)
        elif "calculator" in selection_result.content.lower():
            # 提取数学表达式（简化处理）
            if "15 * 8 + 20" in question:
                result = calculate_simple("15 * 8 + 20")
            else:
                result = "需要具体的数学表达式"
        else:
            result = "未找到合适的工具"
        
        print(f"️ 工具执行结果：{result}\n")

def main():
    """主函数：依次演示各个核心组件"""
    print(" LangChain 0.3 核心组件实战演示")
    print("基于 OpenAI API 的完整示例（兼容版本）\n")
    
    try:
        # 1. LLMChain 演示（使用 LCEL）
        demo_llm_chain()
        
        # 2. Tools 演示
        demo_tools()
        
        # 3. 简化版 Agents tools演示
        demo_simple_agents()
        
        print("✅ 所有演示完成！")
        
    except Exception as e:
        print(f"❌ 演示过程中出现错误：{str(e)}")
        print("请检查 API 密钥和网络连接")

if __name__ == "__main__":
    main()

上面代码大致分两步问大模型：

Step1：“请分析用户问题，选择合适的工具并说明原因，只回答工具名称和原因，格式：工具名称|原因”。

Step2： 提出模型的结果，再结合问题传给对应的方法，最后得出结论。

这是运行结果：

3.记忆 (Memory)

假设我问大模型三个问题，如下所示，

conversations = [
        "我叫Michael，今年85岁",
        "我喜欢编程和阅读",
        "你还记得我的名字吗？",
        "我的爱好是什么？"
    ]

下面是完整代码：

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
from langchain_core.tools import Tool
import datetime

# 加载环境变量
load_dotenv()
os.environ["OPENAI_API_KEY"] = "sk-某宝35块apikey"
api_key = os.getenv('OPENAI_API_KEY')

# ========== 1. 初始化 LLM（大语言模型） ==========
# LangChain 特点：统一的 LLM 接口，支持多种模型提供商
llm = ChatOpenAI(
    base_url="https://api.openai.com/v1",
    api_key=api_key,
    model="gpt-4o",
    temperature=0.7  # LangChain 特点：统一的参数配置
)


# ========== 5. Memory：记忆系统 ==========
def demo_memory():
    """
    演示 Memory：对话记忆管理
    LangChain 特点：自动管理对话历史
    """
    print("=" * 50)
    print(" Memory 演示：记忆系统")
    print("=" * 50)
    
    # 使用简化的记忆管理方式
    conversation_history = []
    
    # 创建带记忆的对话提示词
    memory_prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个友好的助手，能够记住之前的对话内容。以下是对话历史：{history}"),
        ("human", "{input}")
    ])
    
    memory_chain = memory_prompt | llm
    
    # 模拟多轮对话
    conversations = [
        "我叫Michael，今年85岁",
        "我喜欢编程和阅读",
        "你还记得我的名字吗？",
        "我的爱好是什么？"
    ]
    
    for i, user_input in enumerate(conversations, 1):
        print(f" 第{i}轮对话：{user_input}")
        
        # 构建历史记录字符串
        history_str = "\n".join([f"用户: {h['user']}\n助手: {h['assistant']}" for h in conversation_history])
        
        # 获取回复
        response = memory_chain.invoke({
            "history": history_str,
     javascript       "input": user_input
        })
        
        print(f" 助手回复：{response.content}\n")
        
        # 更新对话历史
        conversation_history.append({
            "user": user_input,
            "assistant": response.content
        })
        
        # 显示当前记忆内容
        print(f" 当前记忆：{len(conversation_history)} 轮对话")
        print(f" 记忆内容：{conversation_history}")
        print("-" * 30)

def main():
    try:

        # Memory 演示
        demo_memory()

        print("✅ 所有演示完成！")
        
    except Exception as e:
        print(f"❌ 演示过程中出现错误：{str(e)}")
        print("请检查 API 密钥和网络连接")

if __name__ == "__main__":
    main()

通过上面代码，我们可以看出， 最关键的部分是conversation_history.append，每次将对话信息保留，再传给大模型。

下面是运行结果：

随着对话内容越来越多，会影响大模型的回复效率，甚至会超出token范围，所以每个一段时间或对话次数超过某个阈值，我们需要大模型对所以历史对话做一个总结，来压缩历史对话的内容。

4.规划 (Planning)

假设我有几个工具，我问大模型’我要去日本东京，帮我安排行程。'，下面是可以用到的提示词

        你是一个专业任务规划AI。请将以下任务分解为5-7个有序的关键步骤。

        输出要求:

        1. 只输出jsON格式，而且JSON格式要正确

        2. JSON内容包含一个"steps"数组，每个步骤是一个对象，包含"id"(数字序号)和"description"(用到的步骤，如research_destination)

        3. 确保步骤间有逻辑顺序和依赖关系

        可以用到的步骤：

        1. research_destination - 进行目的地研究 - 收集当地文化、天气和景点信息

        2. book_transportation - 预订交通工具 - 选择航班和当地交通方式

        3. reserve_accommodation - 安排住宿 - 根据预算选择酒店或民宿

        4. plan_activities - 规划每日活动 - 创建景点游览和餐饮计划

        5. prepare_documents - 准备旅行文件 - 检查签证、打印预订确认单

        6. pack_luggage - 整理行李 - 根据天气准备衣物和必需品

        7. calculator - 执行数学计算

        8. confirm_arrival - 确认抵达安排 - 联系接机服务和酒店

可以看到，我给大模型挖了个坑，多了一个‘calculator - 执行数学计算’的步骤，看大模型怎么给我们安排。

下面是完整代码

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
from langchain_core.tools import Tool
import json

# 加载环境变量
load_dotenv()
os.environ["OPENAI_API_KEY"] = "sk-淘宝key"
api_key = os.getenv('OPENAI_API_KEY')

# ========== 1. 初始化 LLM（大语言模型） ==========
# LangChain 特点：统一的 LLM 接口，支持多种模型提供商
llm = ChatOpenAI(
    base_url="https://api.openai.com/v1",
    api_key=api_key,
    model="gpt-4o",
    temperature=0.7  # LangChain 特点：统一的参数配置
)



# 以下是具体的子任务方法
def research_destination():
    print("进行目的地研究 - 收集当地文化、天气和景点信息")

def book_transportation():
    print("预订交通工具 - 选择航班和当地交通方式")

def reserve_accommodation():
    print("安排住宿 - 根据预算选择酒店或民宿")

def plan_activities():
    print("规划每日活动 - 创建景点游览和餐饮计划")

def prepare_documents():
    print("准备旅行文件 - 检查签证、打印预订确认单")

def pack_luggage():
    print("整理行李 - 根据天气准备衣物和必需品")

def confirm_arrival():
    print("确认抵达安排 - 联系接机服务和酒店")

def calculator():
    print(12*25)

# LangChain 特点：统一的工具接口定义
tools = [
    Tool(
        name="research_destination",
        func=research_destination,
        description="进行目的地研究 - 收集当地文化、天气和景点信息"
    ),
    Tool(
        name="book_transportation",
        func=book_transportation,
        description="预订交通工具 - 选择航班和当地交通方式"
    ),
    Tool(
        name="reserve_accommodation",
        func=reserve_accommodation,
        description="安排住宿 - 根据预算选择酒店或民宿"
    ),
    Tool(
        name="plan_activities",
        func=book_transportation,
        description="规划每日活动 - 创建景点游览和餐饮计划"
    ),
    Tool(
        name="prepare_documents",
        func=prepare_documents,
        description="准备旅行文件 - 检查签证、打印预订确认单"
    ),
    Tool(
        name="pack_luggage",
        func=pack_luggage,
        description="整理行李 - 根据天气准备衣物和必需品"
    ),
    Tool(
        name="calculator",
        func=calculator,
        description="执行简单的数学计算，如加减乘除运算"
    ),
    Tool(
        name="confirm_arrival",
        func=confirm_arrival,
        description="确认抵达安排 - 联系接机服务和酒店"
    )
]
def explain_and_process(json_data):
    """
    解释并处理旅行计划JSON数据

    参数:
    json_data -- 包含旅行计划步骤的JSON字符串

    返回:
    处理后的计划步骤列表
    """
    # 1. 解析JSON数据
    try:
        plan_data = json.loads(json_data)
        print("✅ JSON解析成功！数据结构验证通过")
    except json.JSONDecodeError as e:
        print(f"❌ JSON解析错误: {str(e)}")
        return None

    # 2. 解释数据结构
    print("\n JSON结构分析:")
    print(f"- 顶层对象包含 {len(plan_data)} 个键: {list(plan_data.keys())}")
    print(f"- 'steps' 键包含 {len(plan_data['steps'])} 个步骤")

    # 3. 提取并处理步骤数据
    steps = []
    print("\n 计划步骤详情:")
    for step in plan_data["steps"]:
        # 验证必要字段
        if "id" not in step or "description" not in step:
            print(f"⚠️ 警告: 步骤缺少必要字段 - {step}")
            continue

        # 创建步骤对象
        step_obj = {
            "id": step["id"],
            "description": step["description"],
            "status": "pending"  # 添加执行状态
        }
        steps.append(step_obj)

        # 打印步骤信息
        print(f"步骤 {step['id']}: {step['description']}")

        if "research_destination" in step['description'].lower():
            research_destination()
        elif "book_transportation" in step['description'].lower():
            book_transportation()
        elif "reserve_accommodation" in step['description'].lower():
            reserve_accommodation()
        elif "plan_activities" in step['description'].lower():
            plan_activities()
        elif "prepare_documents" in step['descript编程客栈ion'].lower():
            prepare_documents()
        elif "pack_luggage" in step['description'].lower():
            pack_luggage()
        elif "calculator" in step['description'].lower():
            calculator()
        elif "confirm_arrival" in step['description'].lower():
            confirm_arrival()

    # 4. 添加额外信息
    print("\n✨ 处理后的数据结构:")
    print(f"- 总步骤数: {len(steps)}")
    print(f"- 首个步骤: {steps[0]['description']}")
    print(f"- 最后步骤: {steps[-1]['description']}")

    return steps

def plan_agents():
    """
    演示简化版 Agents：手动工具选择和执行
    LangChain 特点：工具集成和智能选择（这里用简化版演示概念）
    """
    print("=" * 50)
    print(" 简化版 Agents 演示：计划选择与执行")
    print("=" * 50)

    # 创建工具选择提示词
    tool_selection_prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个专业任务规划AI。请将以下任务分解为5-7个有序的关键步骤。
        输出要求:
        1. 只输出JSON格式，而且JSON格式要正确编程客栈
        2. JSON内容包含一个"steps"数组，每个步骤是一个对象，包含"id"(数字序号)和"description"(用到的步骤，如research_destination)
        3. 确保步骤间有逻辑顺序和依赖关系
        可以用到的步骤：
        1. research_destination - 进行目的地研究 - 收集当地文化、天气和景点信息
        2. book_transportation - 预订交通工具 - 选择航班和当地交通方式
        3. reserve_accommodation - 安排住宿 - 根据预算选择酒店或民宿
        4. plan_activities - 规划每日活动 - 创建景点游览和餐饮计划
        5. prepare_documents - 准备旅行文件 - 检查签证、打印预订确认单
        6. pack_luggage - 整理行李 - 根据天气准备衣物和必需品
        7. calculator - 执行数学计算
        8. confirm_arrival - 确认抵达安排 - 联系接机服务和酒店
        """),
        ("human", "{question}")
    ])

    tool_chain = tool_selection_prompt | llm

    question = '我要去日本东京，帮我安排行程。'
    print(f" 用户问题：{question}")

    # 1. 工具选择
    selection_result = tool_chain.invoke({"question": question})
    response_json = selection_result.content.replace('json','').replace('```','')
    print(f" 返回json：{response_json}")
    explain_and_process(response_json)

def main():
    try:

        print("=== AI旅行规划Agent演示 ===")

        plan_agents()

        print("✅ 所有演示完成！")
        
    except Exception as e:
        print(f"❌ 演示过程中出现错误：{str(e)}")
        print("请检查 API 密钥和网络连接")

if __name__ == "__main__":
    main()

执行结果：

可以看出，大模型会先安排所需要的计划，再去执行，这就是Agent的‘计划制定’能力，而Agent的计划能力还包括‘计划反思’。这里不做展示，后续可以试图添加这个功能。

计划反思

制定计划后，必须对其优点进行反思和评估。Agent需要利用反馈机制（通常是从已有模型中汲取灵感）来完善和改进其战略和规划方法。为了更好地与人类python的价值观和偏好保持一致，Agent会主动与人类接触，从而纠正一些误解，并将这些有针对性的反馈吸收到其规划方法中。此外，它们还可以从有形或虚拟环境中获得反馈，如任务完成情况的提示或行动后的观察，帮助它们修改和完善计划。

5. 总结核心观点

AI Agents 是 LLM 的进化形态，通过集成 工具使用、记忆、规划 三大核心能力，实现了从“对话”到“行动”的跨越。

本文通过具体的代码示例和运行结果，直观地展示了每个核心功能（工具调用、上下文记忆、任务分解规划）的实现原理和效果。

这为理解更复杂的AI Agent系统（如具备计划反思、多Agent协作等）提供了基础。

到此这篇关于基于Python编写一个简化版AI Agent智能体的文章就介绍到这了,更多相关Python AI智能体内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！