建议收藏：想做AI编程产品？先从这段不到400行的Agent代码开始！

本文链接：https://blog.csdn.net/bagell/article/details/147739017

前言

去年以来，以Cursor为代表的AI编程工具横空出世，彻底点燃了全球开发者对AI辅助编程的热情。海外各种新颖的AI开发工具层出不穷，几乎每周都有新的概念或产品涌现。反观国内，除了几家互联网大厂有所布局，专注于AI编程工具的初创公司似乎相对较少。这固然有国内大模型编程能力仍在追赶的原因，但或许也有一部分原因是，很多人觉得构建一个AI编程工具，特别是具备复杂交互和能力的“智能体（Agent）”，门槛很高，非常复杂。

事实真的如此吗？今天，我们就尝试用不到400行Python代码，带你从零实现一个简单的AI编程智能体。通过这个例子，我们将揭示AI编程智能体的核心原理，希望能打消一些顾虑，为大家构建自己的AI编程产品提供一些启发和参考！

1. AI编程智能体的基本框架

一个AI智能体并非无所不能的神祇，它的核心是大模型 (LLM)，但大模型本身是没有感知外部环境和执行外部动作能力的。要让大模型变得“智能”起来，能够完成实际任务（比如读取文件、修改代码），就需要赋予它工具 (Tools)，并构建一个**“感知-决策-行动”的循环**来协调这一切。

用一个简单的框架来描述：

感知 (Perception): 智能体接收用户的指令或环境信息（例如用户说“帮我读一下某个文件”）。
决策 (Reasoning): 大模型根据指令和它掌握的工具信息进行思考和规划，决定下一步做什么。它可能会决定需要调用某个工具来获取更多信息，或者直接给出答案，或者决定调用某个工具来执行一个动作。
行动 (Action): 如果大模型决定调用工具，它会输出一个特定的格式来表明它想调用哪个工具以及传入什么参数。
执行 (Execution): 开发者编写的“调度层”代码会捕获大模型的工具调用指令，并真正执行对应的工具函数。
观察 (Observation): 工具执行完成后，会产生一个结果（例如文件内容、执行成功/失败信息）。
反馈 (Feedback): 工具的执行结果被反馈给大模型，作为新的输入信息。
再决策/输出 (Re-Reasoning/Output): 大模型接收到工具结果后，会再次决策：是根据结果继续调用其他工具，还是已经获得足够信息，可以直接生成最终回复给用户。

这个循环不断往复，直到任务完成。我们的不到400行代码，就是要实现这个循环中的关键环节：工具的定义、大模型调用工具的解析、工具的执行以及结果的反馈。

下面通过一个流程图来更直观地展示这个基本框架：
“感知-决策-行动”循环

2. 智能体如何调用工具？核心机制解析

这是AI Agent的核心魔法之一：大模型如何知道要调用工具，以及如何告诉外部系统它想调用哪个工具和参数？

在深入代码之前，我们可以通过一个简单的例子来建立直观的理解。假设我们告诉大模型，它有一个叫做 get_weather(<地点名称>) 的工具，调用它可以获取指定地点的天气信息。

对话示例：

你: 你是一个天气专家。当我问你某个地方的天气时，你只需要回复我 get_weather(<地点名称>)。然后我会告诉你那里的实际天气。明白了吗？
大模型: 明白了。当你问我某个地方的天气时，我会回复 get_weather(<地点名称>)，然后你会提供具体的天气信息。
你: 好的，那慕尼黑天气怎么样？
大模型:get_weather(慕尼黑)
你: 慕尼黑现在天气：炎热潮湿，28摄氏度。
大模型: 好的，我已经知道慕尼黑的天气是炎热潮湿，28摄氏度了。下一个地方呢？比如巴黎天气如何？

这个例子非常清晰地展示了工具调用的核心思想：我们告诉大模型它有哪些工具（尽管这里没有提供正式的Schema，只是通过指令），当用户需求出现时，大模型“决定”要使用某个工具，并以约定的格式（这里是 get_weather(...) **字符串）**告诉我们它想调用的工具和参数。然后，**外部系统（也就是我们）**负责“执行”这个工具（这里是我们手动提供了天气信息），并将结果“反馈”给大模型，大模型再利用这个信息生成最终的用户回复。

理解了这个“大模型输出指令 -> 外部代码执行 -> 结果反馈回大模型”的循环，你就抓住了Agent工具调用的核心。

现在，我们来看看在实际编程中如何实现这一机制。诀窍在于两个关键点：

工具定义 (Tool Definition / Schema): 我们在调用大模型API时，会额外提供一个参数，告诉模型它“拥有”哪些工具，每个工具叫什么名字，是用来做什么的，以及调用它需要哪些参数（参数名、类型、描述）。这通常是通过一个结构化的数据格式来描述，比如JSON Schema。这些信息相当于给了大模型一本“工具书”。
结构化输出 (Structured Output): 当大模型在决策阶段认为调用某个工具能更好地完成任务时，它不会直接返回自然语言回复，而是会按照API约定的格式，输出一个结构化的信息，明确指示：“我决定调用工具A，参数是X和Y”。

让我们看看具体如何操作。假设我们有一个read_file函数，用来读取文件内容。我们需要定义它的Schema：

# 这是一个示例的JSON Schema定义
read_file_schema = {
    "type": "function",
    "function": {
        "name": "read_file", # 工具名称
        "description": "读取指定路径文件的内容", # 工具描述
        "parameters": { # 参数定义
            "type": "object",
            "properties": {
                "path": { # 参数名
                    "type": "string", # 参数类型
                    "description": "要读取文件的相对路径"# 参数描述
                }
            },
            "required": ["path"] # 必需的参数
        }
    }
}

在调用支持工具调用的LLM API时（例如OpenAI, Together AI, 或国内一些大模型的Function Calling接口），我们会把这个Schema列表作为参数传进去。

当用户输入“帮我读取 /path/to/your/file.txt 这个文件的内容”时，如果大模型认为read_file工具可以完成这个任务，它就可能返回类似这样的结构化输出：

{
  "tool_calls": [
    {
      "id": "call_abc123", # 调用ID
      "type": "function",
      "function": {
        "name": "read_file", # 模型决定调用的工具名称
        "arguments": "{\"path\": \"/path/to/your/file.txt\"}" # 模型决定的参数，通常是JSON字符串
      }
    }
  ],
"role": "assistant",
"content": null # 如果模型只调用工具，content可能为空
}

关键点来了： 大模型只是告诉你它“想”干什么，具体的执行必须由我们编写的外部代码来完成。我们的代码需要：

检查大模型的回复中是否包含 tool_calls。
如果包含，解析出工具的名称 (function.name) 和参数 (function.arguments)。
根据工具名称，调用我们实际定义的Python函数（比如查找一个函数映射表）。
执行对应的函数，并将解析出的参数传进去。
将函数执行的结果，按照API的要求格式化，添加回对话历史中，并再次调用大模型。这次调用时，大模型就能看到“工具调用的结果是XXX”，然后才能根据这个结果生成最终的用户回复。

理解了这个“大模型输出指令 -> 外部代码执行 -> 结果反馈回大模型”的循环，你就抓住了Agent工具调用的核心。

3. 构建我们的AI编程智能体

现在，我们来实现一个简单的AI编程智能体，它拥有读文件、列文件和编辑文件三个基础的编程工具。我们将代码整合在一起，看看它有多简单。

首先，安装并导入必要的库（这里我们使用一个通用的client对象代表任何支持工具调用的LLM客户端，读者可以根据实际情况替换为OpenAI, Together AI或其他国内厂商的SDK）：

# 假设你已经安装了某个支持工具调用的SDK，例如 together 或 openai
# pip install together # 或 pip install openai

import os
import json
from pathlib import Path # 用于处理文件路径

# 这里的 client 只是一个占位符，你需要用实际的LLM客户端替换
# 例如: from together import Together; client = Together()
# 或者: from openai import OpenAI; client = OpenAI()
# 请确保 client 对象支持 chat.completions.create 方法并能处理 tools 参数
class MockLLMClient:
    def chat(self):
        class Completions:
            def create(self, model, messages, tools=None, tool_choice="auto"):
                print("\n--- Calling Mock LLM ---")
                print("Messages:", messages)
                print("Tools provided:", [t['function']['name'] for t in tools] if tools else"None")
                print("-----------------------")
                # 在实际应用中，这里会调用真实的API并返回模型响应
                # 模拟一个简单的工具调用响应
                last_user_message = None
                for msg in reversed(messages):
                    if msg['role'] == 'user':
                        last_user_message = msg['content']
                        break

                if last_user_message:
                    if"Read the file secret.txt"in last_user_message and tools:
                         # 模拟模型决定调用 read_file 工具
                        return MockResponse(tool_calls=[MockToolCall("read_file", '{"path": "secret.txt"}')])
                    elif"list files"in last_user_message and tools:
                         # 模拟模型决定调用 list_files 工具
                        return MockResponse(tool_calls=[MockToolCall("list_files", '{}')])
                    elif"Create a congrats.py script"in last_user_message and tools:
                         # 模拟模型决定调用 edit_file 工具
                         # 这是一个简化的模拟，实际模型会解析出路径和内容
                         args = {
                             "path": "congrats.py",
                             "old_str": "",
                             "new_str": "print('Hello, AI Agent!')\n# Placeholder for rot13 code"
                         }
                         return MockResponse(tool_calls=[MockToolCall("edit_file", json.dumps(args))])

                # 模拟一个处理完工具结果后的回复
                if messages and messages[-1]['role'] == 'tool':
                     tool_result = messages[-1]['content']
                     # 需要往前查找对应的assistant/tool_calls消息来判断是哪个工具
                     tool_call_msg_index = -2# 通常在倒数第二个
                     while tool_call_msg_index >= 0and messages[tool_call_msg_index].get('role') != 'assistant':
                          tool_call_msg_index -= 1

                     if tool_call_msg_index >= 0and messages[tool_call_msg_index].get('tool_calls'):
                          called_tool_name = messages[tool_call_msg_index]['tool_calls'][0]['function']['name'] # 简化处理，假设只有一个工具调用
                          if called_tool_name == 'read_file':
                               return MockResponse(content=f"OK，文件内容已读到：{tool_result}")
                          elif called_tool_name == 'list_files':
                               return MockResponse(content=f"当前目录文件列表：{tool_result}")
                          elif called_tool_name == 'edit_file':
                               return MockResponse(content=f"文件操作完成：{tool_result}")


                # 模拟一个普通回复
                return MockResponse(content="好的，请继续。")

        return Completions()

class MockResponse:
     def __init__(self, content=None, tool_calls=None):
          self.choices = [MockChoice(content=content, tool_calls=tool_calls)]

class MockChoice:
     def __init__(self, content, tool_calls):
          self.message = MockMessage(content=content, tool_calls=tool_calls)

class MockMessage:
     def __init__(self, content, tool_calls):
          self.content = content
          self.tool_calls = tool_calls
     def model_dump(self):# 模拟pydantic的model_dump方法
          return {"content": self.content, "tool_calls": self.tool_calls}

class MockToolCall:
     def __init__(self, name, arguments):
          self.id = "call_" + str(hash(name + arguments)) # 简单的模拟ID
          self.type = "function"
          self.function = MockFunction(name, arguments)

class MockFunction:
     def __init__(self, name, arguments):
          self.name = name
          self.arguments = arguments

# 在实际使用时，请替换为你的LLM客户端初始化代码
# client = Together() # 示例 Together AI 客户端
client = MockLLMClient() # 使用Mock客户端进行演示

注意：上面的MockLLMClient是为了让代码可以直接运行而提供的模拟客户端。在实际应用中，你需要用真实的大模型SDK客户端替换它，并确保其支持工具调用功能。

接下来，定义我们的工具函数及其Schema：

# 定义文件读取工具
def read_file(path: str) -> str:
    """
    读取文件的内容并作为字符串返回。

    Args:
        path: 工作目录中的文件相对路径。

    Returns:
        文件的内容字符串。

    Raises:
        FileNotFoundError: 文件不存在。
        PermissionError: 没有权限读取文件。
    """
    print(f"Executing tool: read_file with path={path}")
    try:
        # 为了安全，可以增加路径校验，防止读取非工作目录文件
        # resolved_path = Path(path).resolve()
        # if not resolved_path.is_relative_to(Path(".").resolve()):
        #     raise PermissionError("Access denied: Path is outside working directory.")
        with open(path, 'r', encoding='utf-8') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        returnf"错误：文件 '{path}' 未找到。"
    except PermissionError:
        returnf"错误：没有权限读取文件 '{path}'。"
    except Exception as e:
        returnf"错误：读取文件 '{path}' 时发生异常: {str(e)}"

read_file_schema = {
    'type': 'function',
    'function': {'name': 'read_file',
                 'description': '读取指定路径文件的内容',
                 'parameters': {'type': 'object',
                                'properties': {'path': {'type': 'string',
                                                        'description': '要读取文件的相对路径'}},
                                'required': ['path']}}}


# 定义文件列表工具
def list_files(path: str = "."):
    """
    列出指定路径下的所有文件和目录。

    Args:
        path (str): 工作目录中的目录相对路径。默认为当前目录。

    Returns:
        str: 包含文件和目录列表的JSON字符串。
    """
    print(f"Executing tool: list_files with path={path}")
    result = []
    base_path = Path(path)

    ifnot base_path.exists():
        return json.dumps({"error": f"路径 '{path}' 不存在"})

    try:
        # 为了安全，可以增加路径校验
        # resolved_path = base_path.resolve()
        # if not resolved_path.is_relative_to(Path(".").resolve()):
        #      return json.dumps({"error": "Access denied: Path is outside working directory."})

        for entry in base_path.iterdir():
             result.append(str(entry)) # 使用str()避免Path对象序列化问题

        # 也可以使用 os.walk 更彻底，但这里简单起见用 iterdir()
        # for root, dirs, files in os.walk(path):
        #     # ... (类似参考文章的逻辑) ...
        #     pass # 这里简化处理，只列出当前目录

    except PermissionError:
         return json.dumps({"error": f"没有权限访问路径 '{path}'"})
    except Exception as e:
         return json.dumps({"error": f"列出文件时发生异常: {str(e)}"})

    return json.dumps(result)


list_files_schema = {
    "type": "function",
    "function": {
        "name": "list_files",
        "description": "列出指定路径下的所有文件和目录。",
        "parameters": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "要列出文件和目录的相对路径。默认为当前目录。"
                }
            }
        }
    }
}

# 定义文件编辑工具
def edit_file(path: str, old_str: str, new_str: str):
    """
    通过替换字符串来编辑文件。如果 old_str 为空且文件不存在，则创建新文件并写入 new_str。

    Args:
        path (str): 要编辑文件的相对路径。
        old_str (str): 要被替换的字符串。如果为空，表示创建新文件。
        new_str (str): 替换后的字符串。

    Returns:
        str: "OK" 表示成功，否则返回错误信息。
    """
    print(f"Executing tool: edit_file with path={path}, old_str='{old_str}', new_str='{new_str[:50]}...'") # 打印部分new_str避免过长日志

    # 为了安全，可以增加路径校验
    # resolved_path = Path(path).resolve()
    # if not resolved_path.is_relative_to(Path(".").resolve()):
    #      return "错误：拒绝访问：路径超出工作目录范围。"

    try:
        if old_str == ""andnot Path(path).exists():
             # 创建新文件
             with open(path, 'w', encoding='utf-8') as file:
                  file.write(new_str)
             return"OK: 新文件创建成功。"
        else:
             # 编辑现有文件
             with open(path, 'r', encoding='utf-8') as file:
                  old_content = file.read()

             if old_str == ""and Path(path).exists():
                  return"错误：文件已存在，不能用空 old_str 创建。"

             if old_str notin old_content and old_str != "":
                  # 如果指定了 old_str 但未找到，返回错误
                  returnf"错误：文件 '{path}' 中未找到字符串 '{old_str}'。"

             new_content = old_content.replace(old_str, new_str)

             # 检查是否真的有内容变化（避免无意义的写操作）
             if old_content == new_content and old_str != "":
                 # 如果 old_str 不为空但内容没变，说明 old_str 没找到，上面已经处理了这个情况，这里是额外的校验
                 pass# 应该已经在上面报ValueError了，这里保留是为了逻辑清晰

             with open(path, 'w', encoding='utf-8') as file:
                  file.write(new_content)
             return"OK: 文件编辑成功。"

    except FileNotFoundError:
        returnf"错误：文件未找到: {path}"
    except PermissionError:
        returnf"错误：没有权限编辑文件: {path}"
    except Exception as e:
        returnf"错误：编辑文件 '{path}' 时发生异常: {str(e)}"


edit_file_schema = {
    "type": "function",
    "function": {
        "name": "edit_file",
        "description": "通过替换字符串来编辑文件。如果 old_str 为空且文件不存在，则创建新文件并写入 new_str。",
        "parameters": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "要编辑文件的相对路径"
                },
                "old_str": {
                    "type": "string",
                    "description": "要被替换的字符串。如果为空且文件不存在，将创建新文件。"
                },
                "new_str": {
                    "type": "string",
                    "description": "替换后的字符串或新文件内容。"
                }
            },
            "required": ["path", "old_str", "new_str"]
        }
    }
}

# 将所有工具的Schema添加到列表中
available_tools = [read_file_schema, list_files_schema, edit_file_schema]

# 创建一个映射表，将工具名称映射到实际函数
tool_functions = {
    "read_file": read_file,
    "list_files": list_files,
    "edit_file": edit_file,
}

最后，构建我们的主循环，处理用户输入、调用大模型、执行工具并将结果反馈：

def chat_with_agent():
    messages_history = [{"role": "system", "content": "你是一个善于使用外部工具来帮助用户完成编程任务的AI助手。当你认为需要使用工具时，请按照规范发起工具调用。"}]

    print("AI编程智能体已启动！输入指令开始交互 (输入 'exit' 退出)")

    whileTrue:
        user_input = input("你: ")
        if user_input.lower() in ["exit", "quit", "q"]:
            break

        messages_history.append({"role": "user", "content": user_input})

        # 第一次调用大模型，让它决定是否需要工具
        try:
            response = client.chat.completions.create(
                model="Qwen/Qwen2.5-7B-Instruct-Turbo", # 替换为你选择的模型
                messages=messages_history,
                tools=available_tools, # 将工具Schema传递给模型
                tool_choice="auto", # 允许模型自动选择是否使用工具
            )
        except Exception as e:
            print(f"调用大模型API时发生错误: {e}")
            continue# 跳过当前循环，等待用户输入

        # 检查大模型是否发起了工具调用
        response_message = response.choices[0].message
        tool_calls = response_message.tool_calls

        if tool_calls:
            # 如果模型发起了工具调用，执行工具
            print("\n--- 接收到工具调用指令 ---")
            # 将模型的回复（包含工具调用信息）添加到历史中
            # 注意：某些API可能在tool_calls的同时有content，但通常role是assistant
            messages_history.append({"role": "assistant", "tool_calls": tool_calls})

            for tool_call in tool_calls:
                function_name = tool_call.function.name
                function_args = json.loads(tool_call.function.arguments)
                tool_call_id = tool_call.id

                if function_name in tool_functions:
                    # 查找并执行对应的工具函数
                    print(f"--> 执行工具: {function_name}，参数: {function_args}")
                    try:
                        # 调用实际函数
                        # 使用 **function_args 将字典解包作为函数参数
                        function_response = tool_functions[function_name](**function_args)
                        print(f"<-- 工具执行结果: {str(function_response)[:100]}...") # 打印部分结果
                    except Exception as e:
                        function_response = f"工具执行失败: {e}"
                        print(f"<-- 工具执行结果: {function_response}")

                    # 将工具执行结果添加到历史中，再次调用大模型
                    messages_history.append(
                        {
                            "tool_call_id": tool_call_id,
                            "role": "tool",
                            "name": function_name,
                            "content": str(function_response), # 工具结果通常作为字符串传回
                        }
                    )
                else:
                    # 模型调用了不存在的工具
                    error_message = f"大模型尝试调用未知工具: {function_name}"
                    print(error_message)
                    messages_history.append(
                         {
                            "tool_call_id": tool_call_id,
                            "role": "tool",
                            "name": function_name, # 反馈错误的工具名
                            "content": error_message, # 反馈错误信息
                         }
                    )


            # 第二次调用大模型，让它根据工具执行结果生成最终回复
            try:
                print("\n--- 将工具结果反馈给大模型，获取最终回复 ---")
                second_response = client.chat.completions.create(
                    model="Qwen/Qwen2.5-7B-Instruct-Turbo", # 替换为你选择的模型
                    messages=messages_history,
                )
                print("------------------------------------------")
                final_response_message = second_response.choices[0].message.content
                messages_history.append({"role": "assistant", "content": final_response_message})
                print(f"AI: {final_response_message}")

            except Exception as e:
                 print(f"将工具结果反馈给大模型时发生错误: {e}")
                 # 如果再次调用失败，本次交互就断了，可以考虑是否需要重试或报错

        else:
            # 如果模型没有调用工具，直接输出模型的回复
            assistant_response = response_message.content
            messages_history.append({"role": "assistant", "content": assistant_response})
            print(f"AI: {assistant_response}")

# 启动智能体
chat_with_agent()

**代码行数估算:**导入部分: ~10-20行 (取决于Mock客户端的复杂度) 工具函数和Schema定义: 3个工具，每个工具函数+Schema大约 30-50行。总共约 90-150行。工具映射表: ~10行主循环 chat_with_agent 函数: ~100-150行。总计：约 210 - 330行。

这个实现的核心逻辑（工具定义、映射、主循环解析调用、执行、反馈）确实可以控制在不到400行代码内，甚至更少，完全取决于工具函数的复杂度和错误处理的详尽程度。这证明了AI Agent的基本框架是相对简洁的。

4. 另一种视角：Anthropic 的 Model Context Protocol (MCP)

我们上面实现的工具调用机制，是目前业界常用的一种方式，特别是在OpenAI、Together AI以及国内部分大模型API中广泛采用，通常被称为 Function Calling (函数调用)。它的特点是模型通过输出结构化的 JSON 对象来表达工具调用意图，外部代码解析这个JSON并执行对应的函数。

但除了Function Calling，还有其他重要的Agent与外部世界交互的协议。其中一个由Anthropic公司提出的 Model Context Protocol (MCP) 协议，目前已成为Agent感知外部世界的最受欢迎的协议之一。

MCP 的核心在于利用上下文（Prompt）中的特定 XML 标签来构建 Agent 与环境的交互：

Agent 的“行动”： Agent 想要执行某个操作（比如运行一段代码，进行搜索），它会在输出中生成一段包含在特定标签（例如 <tool_code>...</tool_code> 或 <search_query>...</search_query>) 内的文本，这段文本就是给外部执行器的指令（比如要运行的代码）。
外部的“感知”： 外部系统捕捉到 Agent 输出的带标签指令后，执行相应的操作（比如运行 <tool_code> 中的代码，或执行 <search_query> 中的搜索）。
环境的“反馈”： 外部系统将执行的结果或获取到的信息，包裹在另一组标签（例如 <tool_results>...</tool_results> 或 <search_results>...</search_results>，或者 <file_contents>...</file_contents> 来表示文件内容）内，作为新的对话轮次添加回模型的输入上下文。

MCP 的优势在于其灵活性和对多模态、多类型信息的整合能力。 通过不同的标签，可以将代码执行结果、文件内容、网页搜索结果、数据库查询结果等多种形式的外部信息自然地融入到模型的上下文语境中，让模型能够“感知”并利用这些丰富的外部信息进行推理和决策。这种基于标签的协议，使得 Agent 能在一个统一的文本流中协调行动和感知，尤其适合需要处理和整合多种外部数据的复杂任务。

对比来看：

我们代码中实现的 Function Calling：模型输出结构化 JSON -> 外部解析 JSON -> 执行 -> 将结果（通常是字符串）作为 role: tool 的消息添加回历史。
Anthropic 的 MCP：模型输出带特定标签的文本 -> 外部解析标签内容 -> 执行 -> 将结果带特定标签的文本作为新的消息添加回历史。

虽然底层实现方式不同，但它们都殊途同归，都是为了让大模型能够突破自身的限制，与外部工具和环境进行互动，从而执行更复杂的任务。MCP以其在上下文整合上的优势，为 Agent 开启了感知更广阔外部世界的大门。

我们代码中实现的基于 Function Calling 的方式，是构建 Agent 的另一种简洁且广泛支持的途径，特别适合需要清晰定义和调用一系列函数的场景。未来的 Agent 开发，很可能会结合这些不同协议的优点，或者出现更高级的框架来抽象这些底层交互细节。

5. 运行你的智能体

要运行上面的代码，你需要：

确保安装了所选LLM提供商的Python SDK（例如 pip install together 或 pip install openai）。
将代码中的 MockLLMClient 替换为你实际使用的LLM客户端初始化代码，并配置好API Key和模型名称（例如上面的Qwen/Qwen2.5-7B-Instruct-Turbo 只是一个示例，请替换为你可用的模型）。
保存代码为一个.py文件，例如 simple_agent.py。
可以在代码同级目录下创建一个 secret.txt 文件，里面写点内容，比如 my secret message is: hello world。
在终端运行 python simple_agent.py。

现在，你可以和你的简单AI编程智能体交互了：

$ python simple_agent.py
AI编程智能体已启动！输入指令开始交互 (输入 'exit' 退出)
你: list files in the current directory
--- Calling Mock LLM ---
Messages: [{'role': 'system', 'content': '...'}, {'role': 'user', 'content': 'list files in the current directory'}]
Tools provided: ['read_file', 'list_files', 'edit_file']
-----------------------
--- 接收到工具调用指令 ---
--> 执行工具: list_files，参数: {}
<-- 工具执行结果: ["secret.txt", "simple_agent.py"]...
--- 将工具结果反馈给大模型，获取最终回复 ---
------------------------------------------
AI: 当前目录文件列表：["secret.txt", "simple_agent.py"] # 这个回复是模拟的，实际取决于你的LLM
你: read the file secret.txt
--- Calling Mock LLM ---
Messages: [{'role': 'system', 'content': '...'}, {'role': 'user', 'content': 'read the file secret.txt'}, {'role': 'assistant', 'tool_calls': [...]}] # 包含之前的工具调用信息
Tools provided: ['read_file', 'list_files', 'edit_file']
-----------------------
--- 接收到工具调用指令 ---
--> 执行工具: read_file，参数: {'path': 'secret.txt'}
<-- 工具执行结果: my secret message is: hello world...
--- 将工具结果反馈给大模型，获取最终回复 ---
------------------------------------------
AI: OK，文件内容已读到：my secret message is: hello world # 这个回复是模拟的，实际取决于你的LLM
你: exit

(注意：使用Mock客户端时，输出会包含Mock的调试信息，实际运行时不会有)

你可以尝试让它创建或编辑文件，比如输入：create a file named hello.py and put 'print("Hello, Agent!")' inside it。如果你的大模型能理解并正确调用edit_file工具，它就会帮你创建这个文件。

总结

通过这不到400行代码，我们成功地实现了一个具备基本文件操作能力的AI编程智能体。这个过程揭示了AI Agent并非遥不可及的黑魔法，它的核心在于：

LLM的决策能力: 能够理解指令并规划如何使用工具。
工具的定义: 赋予LLM感知和行动的能力。
调度层的编排: 负责解析LLM意图、执行工具并将结果反馈，形成智能体的循环。

我们重点讲解了基于 Function Calling 的工具调用机制，并通过不到400行代码的代码展示了如何实现这一机制来构建一个简单的AI编程智能体。同时，我们也简要介绍了 Anthropic 提出的基于标签的 Model Context Protocol (MCP)，这是另一种强大且流行的 Agent 与外部世界交互协议，尤其擅长整合丰富的上下文信息。

希望这篇文章能帮助你理解AI编程智能体的基本原理和实现方式，并激发你动手实践的热情。AI编程领域充满机遇，国内的开发者们完全可以基于大模型的能力，结合不同的协议思想，构建出服务于特定场景的创新工具。

赶紧试试这段代码吧，迈出构建你自己的AI Agent的第一步！