Implementación de AI Agent en Python

Antes de profundizar en el código, establezcamos una comprensión clara: podemos imaginar un AI Agent como unprograma inteligente con cerebro, manos y pies.。

Cerebro (núcleo): capaz decomprender, razonar y decidirun modelo (como un modelo de lenguaje grande, LLM). Es responsable de procesar información y formular planes.
Percepción (entrada): El Agent obtiene información externa a través de sentidos, como instrucciones del usuario, resultados de consultas a bases de datos, contenido web, datos de sensores, etc.
Acción (salida): El Agent influye en el mundo exterior mediante manos y pies, por ejemplo, llamando a una función, enviando un correo, mostrando texto en pantalla, controlando un brazo robótico, etc.
Objetivo: Todas las acciones del Agent giran en torno a unobjetivoclaro, por ejemplo: ayúdame a consultar el clima de mañana en Beijing.

Su flujo de trabajo central es un clásicobucle de percibir-pensar-actuarbucle, como se muestra a continuación:

Un caso de prueba sencillo

agent-demo/
  agent.py        # 主实现（下面给出）
  tools.py        # 工具实现（可单独文件）
  memory.py       # 简单记忆实现（可单独文件）
  README.md

Ejemplo

"""
agent.py - prototipo minimalista de AI Agent (se puede ejecutar directamente)
Explicación:
- La parte del LLM se simula con un "respondedor por reglas" muy sencillo; al conectar un LLM real, reemplaza LLMInterface.generate(...)
- Componentes incluidos: abstracción del LLM, cerebro (análisis/decisión), planificador, registrador de herramientas, memoria, ejecutor
"""

from typing import Any, Dict, List, Callable
import time

# -----------------------------
# Memoria (muy ligera)
# -----------------------------
class Memory:
def __init__(self):
self.short = {} # Contexto de la sesión actual
self.long = {} # Preferencias/contactos a largo plazo, etc.

def get_short(self, k, default=None):
return self.short.get(k, default)

def set_short(self, k, v):
self.short[k] = v

def get_long(self, k, default=None):
return self.long.get(k, default)

def set_long(self, k, v):
self.long[k] = v

# -----------------------------
# Abstracción del LLM (punto de reemplazo)
# -----------------------------
class LLMInterface:
def generate(self, prompt: str) -> str:
"""
Aquí se proporciona un respondedor simulado muy simple basado en reglas.
En uso real: reemplázalo por el código de llamada de OpenAI/otros modelos, que devuelve el texto del modelo.
"""
# Ejemplo de análisis minimalista: identificar si se necesita juzgar "lluvia"
if "si llueve" in prompt or "llueve" in prompt:
return "Por favor, consulta primero el clima; si llueve, genera un recordatorio y envíalo al contacto objetivo."
if "Generar recordatorio" in prompt:
return "Por favor, recuerda a Xiao Wang: mañana lloverá en Beijing, lleva paraguas."
return "Entiendo."

# -----------------------------
# Registro de herramientas y herramientas simuladas
# -----------------------------
class ToolRegistry:
def __init__(self):
self.tools: Dict[str, Callable[..., Any]] = {}

def register(self, name: str, fn: Callable[..., Any]):
self.tools[name] = fn

def call(self, name: str, *args, **kwargs):
if name not in self.tools:
raise ValueError(f"Herramienta no registrada: {name}")
return self.tools[name](*args, **kwargs)

# Herramienta simulada: consulta del clima (en un caso real se llamaría a la API del clima)
def mock_weather_api(city: str, date: str) -> Dict[str, Any]:
# Regla simple: si city contiene "Beijing" y date contiene "mañana", devuelve el ejemplo de lluvia
if "Beijing" in city and "mañana" in date:
return {"city": city, "date": date, "cond": "lluvia", "precip_mm": 5}
return {"city": city, "date": date, "cond": "despejado", "precip_mm": 0}

# Herramienta simulada: enviar mensaje (en un caso real se llamaría a SMS/correo/WeChat corporativo, etc.)
def mock_send_message(contact: str, message: str) -> bool:
print(f"[Enviar mensaje] to={contact} message={message}")
return True

# Herramienta simulada: búsqueda simple (ilustrativa)
def mock_search(query: str) -> str:
return f"Resultado de búsqueda simulado: resumen de información sobre `{query}`."

# -----------------------------
# Planner / Executor
# -----------------------------
class SimplePlanner:
def plan(self, goal: str) -> List[Dict[str, Any]]:
"""
Descompone el objetivo en una lista de pasos (implementación muy simplificada)
Cada paso incluye: action (nombre de la herramienta o acción interna), params
"""
steps = []
# Ejemplo: si la entrada contiene "clima", genera dos pasos: consultar el clima, evaluar y posiblemente enviar un recordatorio
if "clima" in goal or "lluvia" in goal:
steps.append({"action": "query_weather", "params": {"city": "Beijing", "date": "mañana"}})
steps.append({"action": "decide_and_notify", "params": {"contact_name": "Xiao Wang"}})
else:
steps.append({"action": "search", "params": {"query": goal}})
return steps

class Executor:
def __init__(self, tools: ToolRegistry, memory: Memory, llm: LLMInterface):
self.tools = tools
self.memory = memory
self.llm = llm

def run_step(self, step: Dict[str, Any]):
action = step["action"]
params = step.get("params", {})
if action == "query_weather":
res = self.tools.call("weather", params["city"], params["date"])
self.memory.set_short("last_weather", res)
return res
if action == "decide_and_notify":
weather = self.memory.get_short("last_weather", {})
# Decisión por reglas simples
if weather.get("cond") == "lluvia":
# Hacer que el LLM genere el texto del recordatorio (ejemplo)
prompt = f"Basado en la información del clima: {weather}, genera un recordatorio para enviar a {params['contact_name']}."
reminder = self.llm.generate(prompt)
# Obtener el contacto de la memoria a largo plazo
contact = self.memory.get_long(params["contact_name"]) or "13800000000"
ok = self.tools.call("send_message", contact, reminder)
return {"notified": ok, "message": reminder}
else:
return {"notified": False, "reason": "Clima soleado"}
if action == "search":
return self.tools.call("search", params["query"])
raise ValueError(f"Acción desconocida: {action}")

# -----------------------------
# Cuerpo principal del Agent
# -----------------------------
class SimpleAgent:
def __init__(self):
self.memory = Memory()
self.tools = ToolRegistry()
self.llm = LLMInterface()
self.planner = SimplePlanner()
self.executor = Executor(self.tools, self.memory, self.llm)
# Registrar herramientas predeterminadas
self.tools.register("weather", mock_weather_api)
self.tools.register("send_message", mock_send_message)
self.tools.register("search", mock_search)
# Supongamos que en la memoria a largo plazo está guardado el contacto de Xiao Wang
self.memory.set_long("Xiao Wang", "13911112222")

def handle(self, user_prompt: str):
# 1) Análisis del cerebro (con la abstracción del LLM)
intent = self.llm.generate(user_prompt)
# 2) Planificación
steps = self.planner.plan(user_prompt)
# 3) Ejecución paso a paso
results = []
for step in steps:
r = self.executor.run_step(step)
results.append({"step": step, "result": r})
# 4) Combinación de salidas
return {"intent": intent, "steps": results}

# -----------------------------
# Ejemplo de ejecución
# -----------------------------
if __name__ == "__main__":
agent = SimpleAgent()
task = "Consulta el clima de mañana en Beijing; si llueve, escríbeme un recordatorio y envíalo a Xiao Wang."
out = agent.handle(task)
import json
print(json.dumps(out, ensure_ascii=False, indent=2))

Explicación:

Abstracción del LLM：LLMInterface.generate()es un punto reemplazable. Solo hay que cambiarlo por el código que se conecta a OpenAI, Claude o un LLM local.
Planificador (Planner): se encarga de dividir el objetivo en lenguaje natural en pasos ordenados. Para empezar, puedes usar reglas o plantillas; en un nivel avanzado, puedes usar el LLM para generar los pasos y analizarlos como acciones.
Capa de herramientas (Tools): cada herramienta es una función independiente, registrada uniformemente enToolRegistry. En proyectos reales, pueden ser solicitudes HTTP, llamadas SDK, lectura/escritura de bases de datos, etc.
Memoria (Memory): distingue entre corto y largo plazo. La memoria a corto plazo se usa para resultados intermedios de la tarea actual; la de largo plazo, para contactos, preferencias, etc.
Ejecutor (Executor): asigna los pasos a llamadas de herramientas y gestiona los valores de retorno, fallos y lógica de reintentos.

Construye tu primer AI Agent: asistente de planificación de tareas

Construiremos unasistente de planificación de tareas. Su objetivo es: a partir de una tarea compleja dada por el usuario (por ejemplo: quiero viajar), descomponerla automáticamente en una serie de pasos concretos, ordenados y ejecutables.

La estructura de directorios es la siguiente:

Paso 1: Construir el cerebro inteligente

El cerebro del Agent necesita capacidad de razonamiento. Usaremos el modelo GPT de OpenAI (mediante llamadas a la API) como cerebro de nuestro Agent.

Necesitas preparar una clave de API de OpenAI; también puedes usar la API key de DeepSeek, que es compatible.

Los ejemplos de prueba de este capítulo usan la API key de DeepSeek; primero podemos ir ahttps://platform.deepseek.com/api_keyssolicitarla.

También puedes usar directamente el plan Coding Plan de Bailian y Ark:https://www.example.com/claude-code/coding-plan.html。

Primero, instala las bibliotecas necesarias:

pip3 install openai

Puedes usar el siguiente código para probar que la ejecución fue exitosa:

Ejemplo

import os
from openai import OpenAI

DEEPSEEK_API_KEY = "sk-xxxxxxx" # Aquí configura la key que solicitaste
DEEPSEEK_API_URL = "https://api.deepseek.com/v1"

client = OpenAI(
api_key = DEEPSEEK_API_KEY,
base_url = DEEPSEEK_API_URL)

response = client.chat.completions.create(
model="deepseek-v4-flash",
messages=[
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "Hello"},
],
stream=False
)

print(response.choices[0].message.content)

Si la instalación y configuración son exitosas, se mostrará un resultado similar al siguiente:

Hello! How can I assist you today?

Luego, creemos el módulo de cerebro más simple:

Código del archivo brain.py

# brain.py
from openai import OpenAI
import os

DEEPSEEK_API_KEY = "sk-xxxxxxx" # Aquí configura la key que solicitaste
DEEPSEEK_API_URL = "https://api.deepseek.com/v1"

client = OpenAI(
api_key = DEEPSEEK_API_KEY,
base_url = DEEPSEEK_API_URL)

class AgentBrain:
"""El cerebro del Agent, responsable de pensar y decidir"""

def __init__(self, model="deepseek-v4-flash"):
self.model = model

def think(self, prompt):
"""Función de pensamiento principal: recibe un prompt y devuelve el resultado del razonamiento del modelo"""
try:
# Usa el cliente para llamar a la API de Chat Completions (escritura de la versión v1.x)
response = client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.5, # Controla la creatividad; cuanto más bajo, más enfocado
max_tokens=500 # Controla la longitud de la respuesta
)
# Extrae el contenido de texto devuelto por el modelo (la ruta de atributos cambió en la versión v1.x)
reasoning = response.choices[0].message.content
return reasoning.strip()
except Exception as e:
return f"Error en el proceso de pensamiento: {e}"

# Prueba rápida para ver si el cerebro funciona
if __name__ == "__main__":
brain = AgentBrain()
test_prompt = "Hola, preséntate brevemente."
print("Pregunta de prueba:", test_prompt)
print("Respuesta del cerebro:", brain.think(test_prompt))

Al ejecutar el código anterior, el resultado será aproximadamente el siguiente:

测试提问： 你好，请简单介绍一下你自己。
大脑回复： 你好！我是DeepSeek，由深度求索公司创造的AI助手，很高兴认识你！&#x1f60a;

让我简单介绍一下自己：

**我的特点：**
**完全免费**：目前没有任何收费计划，你可以放心使用
**知识丰富**：知识截止到2024年7月，涵盖各个领域
**对话能力强**：支持128K上下文，可以进行长篇深入对话

Análisis del código：

Hemos creado unaAgentBrainclase para encapsular la interacción con el LLM.
thinkEl método es el núcleo; recibe una cadenaprompt(prompt) y la envía a la API de GPT.
temperatureEl parámetro es muy importante: configurarlo en 0.5 permite que el Agent logre un equilibrio entre creatividad y estabilidad, adecuado para tareas de planificación.
Finalmente, devuelve el texto generado por el modelo; este es el resultado del razonamiento del Agent.

Paso 2: Definir manos y pies: herramientas y acciones

El Agent necesita capacidad de ejecución. Le definimos algunas herramientas simples (funciones) para que pueda actuar.

Código del archivo tools.py

# tools.py
import datetime

class AgentTools:
"""Colección de herramientas que el Agent puede usar"""

@staticmethod
def search_web(query):
"""Herramienta simulada de búsqueda web (simulación aquí)"""
mock_results = {
"Recomendación de destinos de viaje": "París, Tokio, Maldivas, Lijiang en Yunnan...",
"Clima en Pekín": "Mañana despejado, temperatura 15-25°C, viento suave.",
"Tutorial de Python": "Se recomiendan sitios como Tutorial para novatos (Ejemplo)."
}
for key, value in mock_results.items():
if key in query:
return f"[Búsqueda web] Resultados sobre '{query}': {value}"
return f"[Búsqueda web] No se encontró información clara sobre '{query}'."

@staticmethod
def make_schedule(steps):
"""Herramienta para crear planes de agenda"""
schedule = "Plan de agenda generado:\n"
for i, step in enumerate(steps, 1):
schedule += f"{i}. {step}\n"
return schedule

@staticmethod
def get_current_time():
"""Herramienta para obtener la hora actual"""
now = datetime.datetime.now()
return f"[Hora del sistema] Ahora es: {now.strftime('%Y-%m-%d %H:%M:%S')}"

@staticmethod
def calculate(expression):
"""Herramienta de calculadora simple (versión segura, problemas de compatibilidad corregidos)"""
try:
# 1. Filtrado estricto de caracteres no válidos (solo se permiten dígitos, operadores básicos, paréntesis, espacios)
allowed_chars = set("0123456789+-*/(). ")
if not all(c in allowed_chars for c in expression):
return "[Calculadora] La expresión contiene caracteres no válidos, se rechaza el cálculo."

# 2. Validación de seguridad simplificada: se elimina la lógica propensa a errores de ast.walk, se usa una comprobación básica de sintaxis
# Primero se eliminan espacios para evitar expresiones vacías
clean_expr = expression.strip().replace(" ", "")
if not clean_expr:
return "[Calculadora] La expresión no puede estar vacía."

# 3. Ejecución segura del cálculo (restringir funciones integradas, solo operaciones básicas)
# Entorno global seguro personalizado, solo se permiten operaciones matemáticas básicas
safe_globals = {
'__builtins__': {},
'pow': pow,
'abs': abs
}
# Se usa eval pero con entorno estrictamente limitado, y se han filtrado caracteres no válidos, lo que reduce mucho el riesgo
result = eval(clean_expr, safe_globals)
return f"[Calculadora] {expression} = {result}"

except ZeroDivisionError:
return "[Calculadora] Error: el divisor no puede ser cero."
except SyntaxError:
return "[Calculadora] Error de sintaxis en la expresión (por ejemplo, paréntesis desequilibrados, operadores incorrectos)."
except Exception as e:
return f"[Calculadora] Error de cálculo: {str(e)}"

# Prueba de herramientas
if __name__ == "__main__":
print(AgentTools.search_web("Clima en Pekín"))
print(AgentTools.get_current_time())
print(AgentTools.calculate("3 + 5 * 2")) # Cálculo normal
print(AgentTools.calculate("10 / 0")) # Error de división por cero
print(AgentTools.calculate("__import__('os').system('ls')")) # Filtrado de caracteres no válidos

Análisis del código：

Cada@staticmethoddefine una herramienta que el Agent puede llamar.
search_webPor ahora es una simulación; en un escenario real se necesita conectar una API de búsqueda real.
make_scheduleSe usa para formatear una lista de tareas como un plan.
Advertencia de seguridad importante：calculateEn las herramientas,eval()la función es extremadamente peligrosa en productos reales; debe usarse un método más seguro (comoast.literal_eval) o eliminarse por completo. Esto es solo para demostrar cómo el Agent llama a las funciones.

Paso 3: Ensamblar el Agent: implementar el bucle principal

Ahora, ensamblamos el cerebro y las herramientas, e implementamos el bucle de decisión principal. Diseñaremos una regla simple: dejar que el cerebro decida qué herramienta usar según la tarea.

Ejemplo

# agent.py
from brain import AgentBrain
from tools import AgentTools

class SimpleAgent:
"""Un Agent de IA simple para planificación de tareas"""

def __init__(self):
self.brain = AgentBrain()
# La clase de herramienta estática no necesita instanciarse
self.tools = AgentTools
# Se define la lista de herramientas que conoce el Agent y sus descripciones, para guiar al cerebro
self.tool_descriptions = """
Puedes usar las siguientes herramientas:
1. Herramienta de búsqueda: úsala cuando necesites obtener información reciente o desconocida, por ejemplo 'buscar clima en Pekín'.
2. Herramienta de planificación: úsala cuando necesites organizar varios pasos en un plan, por ejemplo 'hacer plan [paso1, paso2]'.
3. Herramienta de hora: úsala cuando necesites saber la hora actual, la instrucción es 'obtener hora'.
4. Herramienta de cálculo: úsala cuando necesites realizar cálculos matemáticos, por ejemplo 'calcular 3+5*2'.
"""

def run(self, user_task):
"""Bucle principal para ejecutar el Agent"""
print(f"🎯 Tarea del usuario: {user_task}")
print("=" * 40)

# Primer paso: percepción y pensamiento inicial
initial_prompt = f"""
Tu rol es un asistente de planificación de tareas.
{self.tool_descriptions}

La tarea del usuario es: {user_task}

Responde estrictamente con el siguiente formato fijo, no añadas contenido extra:
Pensamiento: [analiza brevemente qué necesita la tarea]
Herramienta: [elige el nombre de la herramienta a usar; si no hay una adecuada, escribe 'ninguna']
Instrucción: [contenido específico de la instrucción enviada a la herramienta]
"""

initial_response = self.brain.think(initial_prompt)
print("🧠 Resultado del pensamiento inicial:")
print(initial_response)
print("-" * 20)

# Segundo paso: analizar el resultado del pensamiento, extraer herramienta e instrucción (optimización de robustez)
lines = [line.strip() for line in initial_response.split('\n') if line.strip()]
tool_to_use = "ninguna"
tool_instruction = ""

for line in lines:
if line.startswith("Pensamiento:"):
continue # Omitir la línea de pensamiento
elif line.startswith("Herramienta:"):
tool_to_use = line.replace("Herramienta:", "").strip()
elif line.startswith("Instrucción:"):
tool_instruction = line.replace("Instrucción:", "").strip()

# Tercer paso: ejecutar la acción
result = self._use_tool(tool_to_use, tool_instruction)
print("🛠️ Resultado de la ejecución:")
print(result)
print("=" * 40)

# Cuarto paso: integrar el resultado y darlo al usuario
final_prompt = f"""
Tarea original del usuario: {user_task}
Has pensado y has usado una herramienta.
Proceso de pensamiento: {initial_response}
Resultado de la ejecución de la herramienta: {result}

Ahora, genera una respuesta final completa para el usuario, dando directamente una respuesta o un plan útil, con un lenguaje natural y amable.
"""

final_response = self.brain.think(final_prompt)
print("💡 Respuesta final al usuario:")
print(final_response)

return final_response

def _use_tool(self, tool_name, instruction):
"""Llama a la función de herramienta específica según el nombre de la herramienta"""
# Unificación de la coincidencia de nombres de herramientas (compatible con mayúsculas/minúsculas y espacios extra)
tool_name = tool_name.strip()

if tool_name == "herramienta de búsqueda":
return self.tools.search_web(instruction)
elif tool_name == "herramienta de planificación":
# Compatibilidad con comas chinas/inglesas, paréntesis; manejo de instrucciones vacías
if not instruction:
return "[Herramienta de planificación] No se proporcionaron pasos del plan, no se puede generar la agenda."
# Se eliminan los paréntesis y se dividen los pasos (compatible con corchetes []/()/{})
clean_instr = instruction.strip('[](){}').strip()
# También compatible con división por comas chinas e inglesas
steps = [s.strip() for s in clean_instr.replace('，', ',').split(',') if s.strip()]
return self.tools.make_schedule(steps)
elif tool_name == "herramienta de hora":
return self.tools.get_current_time()
elif tool_name == "herramienta de cálculo":
return self.tools.calculate(instruction)
elif tool_name == "ninguna":
return "[Sistema] No es necesario usar ninguna herramienta, responde directamente al usuario."
else:
return f"[Sistema] Herramienta desconocida: {tool_name}, no se puede ejecutar."

# ¡Ejecutemos nuestro Agent!
if __name__ == "__main__":
print("🤖 Iniciando SimpleAgent...")
my_agent = SimpleAgent()

# Probar varias tareas diferentes
test_tasks = [
"Quiero viajar, ayúdame a planear qué debo preparar",
"¿Qué hora es?",
"Calcula cuánto es 15 al cuadrado más un tercio de 20",
]

for task in test_tasks:
my_agent.run(task)
print("\n" + "#" * 50 + "\n")

Ejecuta el código, la salida será similar a:

启动 SimpleAgent...
用户任务: 我想去旅行，帮我规划一下需要准备什么
========================================
初始思考结果：
思考：用户需要规划旅行前的准备工作。这是一个通用任务，不需要最新信息或计算，但需要将多个准备步骤整理成一个清晰的计划。

工具：计划工具

指令：制定计划 [1. 确定目的地和旅行时间，2. 预订交通票（机票/火车票）和住宿，3. 准备旅行证件（身份证、护照、签证等），4. 安排行程和景点门票，5. 打包行李（衣物、洗漱用品、药品、充电器等），6. 安排家中事务（宠物、植物、邮件等），7. 兑换货币或准备支付方式，8. 购买旅行保险]
--------------------
执行结果：
...

Análisis del código y flujo de ejecución：

Inicialización: el Agent creó su propio cerebro (AgentBrain) y caja de herramientas (AgentTools).
Recepción de tareas：runMétodo inicia, recibeuser_task(por ejemplo, "Quiero viajar").
Fase de pensamiento: combina la tarea y las descripciones de herramientas eninitial_prompt, lo envía al cerebro. El texto devuelto por el cerebro contiene la "herramienta" elegida y la "instrucción" para la herramienta.
Fase de acción：_use_toolLa función, según la elección del cerebro, llama a la función de herramienta correspondiente y devuelve el resultado.
Retroalimentación y resumen: envía de nuevo la tarea original, el proceso de pensamiento y el resultado de la acción al cerebro, para que genere una respuesta final amigable para el usuario.

Al ejecutar este programa, verás cómo el Agent analiza la tarea paso a paso, elige la herramienta, ejecuta y da la respuesta.

Práctica: Mejora tu Agent

¡Ya tienes un AI Agent que funciona! Pero esto es solo el comienzo. Intenta completar los siguientes ejercicios para hacerlo más potente:

Ejercicio 1: Añadir memoria
- Objetivo: que el Agent pueda recordar el historial de conversación.
- Pista: en laSimpleAgentclase, añade unaself.conversation_history = []lista. Cada vez que llames abrain.think, además del prompt actual, envía también el historial de conversación anterior como contexto. Después de ejecutar, añade el nuevo turno de diálogo (entrada del usuario, pensamiento de la IA, resultado de la herramienta) a la lista de historial.
Ejercicio 2: Implementar la selección automática de herramientas
- Objetivo: que la respuesta del cerebro esté en formato JSON estándar, para que el programa la analice automáticamente en lugar de depender de la extracción de texto.
- Pista: modifica el prompt para que el cerebro devuelva una cadena JSON como{"thought": "…"， "tool": "…"， "instruction": "…"}. Luego, en el código, usajson.loads()para analizarlo, mejorando la estabilidad y la precisión.
Ejercicio 3: Añadir una nueva herramienta
- Objetivo: que el Agent pueda gestionar tareas pendientes.
- Pista: en laAgentToolsclase, añadetodo_list = []y dos nuevos métodos:add_todo(item)yshow_todos(). En la descripción de herramientas, informa al cerebro de la existencia de esta nueva herramienta y actualiza_use_toolmétodo para llamarlo.

Resumen y perspectivas

¡Felicidades! Has construido con éxito uno que posee lo básicopercepción-pensamiento-acciónAI Agent con bucle. Repasemos los puntos clave:

Concepto central: AI Agent = Cerebro (LLM) + Percepción + Acción + Objetivo.
Clave de implementación：
1. Cerebro: Realizar razonamiento llamando al LLM (como GPT) a través de la API.
2. Herramientas: Encapsular capacidades concretas en funciones para que el AI Agent las invoque.
3. Bucle: Encadenar el pensamiento, la decisión y la ejecución con lógica de código.

Esto es solo la punta del iceberg en el mundo de los AI Agents. Frameworks de nivel industrial comoLangChain、AutoGenofrecen funciones más potentes como integración de herramientas, gestión de memoria y colaboración entre múltiples AI Agents, etc. Para explorar en profundidad, te sugiero:

Otras extensiones

Herramientas de agentes

Implementación de agentes inteligentes en Python

Implementación de AI Agent en Python

Un caso de prueba sencillo

Ejemplo

Construye tu primer AI Agent: asistente de planificación de tareas

Paso 1: Construir el cerebro inteligente

Ejemplo

Código del archivo brain.py

Paso 2: Definir manos y pies: herramientas y acciones

Código del archivo tools.py

Paso 3: Ensamblar el Agent: implementar el bucle principal

Ejemplo

Práctica: Mejora tu Agent

Resumen y perspectivas