Python-Implementierung eines KI-Agenten
Bevor wir in den Code eintauchen, wollen wir ein klares Verständnis schaffen: Stellen Sie sich einen KI-Agenten als einintelligentes Programm mit einem Gehirn sowie Händen und Füßen vor.。
- Gehirn (Kern): a, das verstehen, schlussfolgern und Entscheidungen treffen kannModell (z. B. großes Sprachmodell LLM). Es ist für die Verarbeitung von Informationen und die Erstellung von Plänen verantwortlich.
- Wahrnehmung (Eingabe): Der Agent erhält externe Informationen über Sinne, wie Benutzeranweisungen, Datenbankabfrageergebnisse, Webinhalte, Sensordaten usw.
- Aktion (Ausgabe): Der Agent beeinflusst die Außenwelt durch Hände und Füße, zum Beispiel durch Aufrufen einer Funktion, Senden einer E-Mail, Ausgeben von Text auf einem Bildschirm, Steuern eines Roboterarms usw.
- Ziel: Alle Verhaltensweisen des Agenten drehen sich um ein klaresZiel, das sich entfaltet, zum Beispiel: Hilf mir, das morgige Wetter in Peking zu prüfen.
Sein Kern-Workflow ist eine klassischeWahrnehmung-Denken-Aktion-Schleife, wie in der Abbildung unten dargestellt:

Einfacher Testfall
agent-demo/ agent.py # 主实现(下面给出) tools.py # 工具实现(可单独文件) memory.py # 简单记忆实现(可单独文件) README.md
Beispiel
agent.py – Minimaler KI-Agent-Prototyp (kann direkt ausgeführt werden)
Erklärung:
- Der LLM-Teil wird durch einen sehr einfachen "regelbasierten Responder" simuliert; beim tatsächlichen Verbinden mit einem LLM ersetzen Sie LLMInterface.generate(...)
- Komponenten: LLM-Abstraktion, Gehirn (Parsing/Entscheidungsfindung), Planer, Werkzeugregister, Gedächtnis, Executor
"""
from typing import Any, Dict, List, Callable
import time
# -----------------------------
# Gedächtnis (sehr leichtgewichtig)
# -----------------------------
class Memory:
def __init__(self):
self.short = {} # Aktueller Gesprächskontext
self.long = {} # Langfristige Präferenzen/Kontakte usw.
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
# -----------------------------
# LLM-Abstraktion (Ersetzungspunkt)
# -----------------------------
class LLMInterface:
def generate(self, prompt: str) -> str:
"""
Hier stellen wir einen sehr einfachen regelbasierten simulierten Responder bereit.
Im echten Einsatz: Ersetzen Sie dies durch OpenAI-/anderen Modellaufrufcode und geben Sie den Modelltext zurück.
"""
# Minimales Parsing-Beispiel: Feststellen, ob wir "Regen" ermitteln müssen
if "ob es regnet" in prompt or "Regen" in prompt:
return "Bitte fragen Sie zuerst das Wetter ab; wenn es regnen soll, erzeugen Sie eine Erinnerung und senden Sie sie an den Zielkontakt."
if "Erinnerung erzeugen" in prompt:
return "Bitte erinnern Sie Xiao Wang: Morgen wird es in Peking regnen, bitte bringen Sie einen Regenschirm mit."
return "Ich verstehe."
# -----------------------------
# Werkzeugregistrierung und simulierte Werkzeuge
# -----------------------------
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"Werkzeug nicht registriert: {name}")
return self.tools[name](*args, **kwargs)
# Simuliertes Werkzeug: Wetterabfrage (in echten Situationen würde eine Wetter-API aufgerufen werden)
def mock_weather_api(city: str, date: str) -> Dict[str, Any]:
# Einfache Regel: Wenn die Stadt "Peking" enthält und das Datum "morgen" enthält, ein Regenbeispiel zurückgeben
if "Peking" in city and "morgen" in date:
return {"city": city, "date": date, "cond": "Regen", "precip_mm": 5}
return {"city": city, "date": date, "cond": "sunny", "precip_mm": 0}
# Simuliertes Tool: Nachricht senden (in realen Situationen würden SMS/E-Mail/WeCom usw. aufgerufen)
def mock_send_message(contact: str, message: str) -> bool:
print(f"[Nachricht senden] an={contact} Nachricht={message}")
return True
# Simuliertes Tool: einfache Suche (illustrativ)
def mock_search(query: str) -> str:
return f"Simuliertes Suchergebnis: Informationszusammenfassung über `{query}`."
# -----------------------------
# Planer / Ausführer
# -----------------------------
class SimplePlanner:
def plan(self, goal: str) -> List[Dict[str, Any]]:
"""
Zerlege das Ziel in eine Liste von Schritten (eine sehr vereinfachte Implementierung)
Jeder Schritt enthält: action (Tool-Name oder interne Aktion), params
"""
steps = []
# Beispiel: Wenn die Eingabeaufforderung "weather" enthält, generiere zwei Schritte: Wetter abfragen, entscheiden, ob eine Erinnerung gesendet werden soll
if "weather" in goal or "rain" in goal:
steps.append({"action": "query_weather", "params": {"city": "Beijing", "date": "tomorrow"}})
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", {})
# Einfache Regelentscheidung
if weather.get("cond") == "rain":
# Lass das LLM den Erinnerungstext generieren (Beispiel)
prompt = f"Basierend auf Wetterinformationen: {weather}, generiere eine Erinnerung an {params['contact_name']}."
reminder = self.llm.generate(prompt)
# Kontaktinformationen aus dem Langzeitgedächtnis abrufen
contact = self.memory.get_long(params["contact_name"]) oder "13800000000"
ok = self.tools.call("send_message", contact, reminder)
return {"notified": ok, "message": reminder}
else:
return {"notified": False, "reason": "sonniges Wetter"}
if action == "search":
return self.tools.call("search", params["query"])
raise ValueError(f"Unbekannte Aktion: {action}")
# -----------------------------
# Agenten-Kern
# -----------------------------
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)
# Standardwerkzeuge registrieren
self.tools.register("weather", mock_weather_api)
self.tools.register("send_message", mock_send_message)
self.tools.register("search", mock_search)
# Angenommen, Xiao Wangs Kontaktinformationen sind im Langzeitgedächtnis gespeichert
self.memory.set_long("Xiao Wang", "13911112222")
def handle(self, user_prompt: str):
# 1) Gehirn-Parsing (mit LLM abstrahiert)
intent = self.llm.generate(user_prompt)
# 2) Planung
steps = self.planner.plan(user_prompt)
# 3) Schrittweise Ausführung
results = []
for step in steps:
r = self.executor.run_step(step)
results.append({"step": step, "result": r})
# 4) Ausgabe zusammenführen
return {"intent": intent, "steps": results}
# -----------------------------
# Beispiel ausführen
# -----------------------------
if __name__ == "__main__":
agent = SimpleAgent()
task = Prüfe das Wetter von morgen in Peking; wenn es regnet, schreibe eine Erinnerung für mich und sende sie an Xiao Wang.
out = agent.handle(task)
import json
print(json.dumps(out, ensure_ascii=False, indent=2))
Beschreibung:
- LLM-Abstraktion:
LLMInterface.generate()Es ist ein ersetzbarer Punkt. Ersetzen Sie dies einfach durch Code, der eine Verbindung zu OpenAI, Claude oder einem lokalen LLM herstellt. - PlannerVerantwortlich dafür, Ziele in natürlicher Sprache in geordnete Schritte zu zerlegen. Für Anfänger können Sie Regeln oder Vorlagen verwenden; für fortgeschrittene Nutzung können Sie ein LLM Schritte ausgeben lassen und sie in Aktionen parsen.
- Tool-SchichtJedes Tool ist eine unabhängige Funktion, einheitlich registriert unter
ToolRegistryIn echten Projekten können dies HTTP-Anfragen, SDK-Aufrufe, Datenbank-Lese-/Schreibvorgänge usw. sein. - Speicher: Unterscheiden Sie zwischen Kurzzeit- und Langzeitgedächtnis. Kurzzeit wird für Zwischenergebnisse der aktuellen Aufgabe verwendet, Langzeit für Kontakte, Präferenzen usw.
- ExecutorOrdnet Schritte Tool-Aufrufen zu und behandelt Rückgabewerte, Fehler und Wiederholungslogik.
Baue deinen ersten KI-Agenten: Aufgabenplanungs-Assistent
Wir werden einenAufgabenplanungsassistenten bauen.Sein Ziel ist: Basierend auf einer komplexen Aufgabe, die vom Benutzer vorgegeben wird (z. B. Ich möchte reisen), sie automatisch in eine Reihe geordneter, ausführbarer konkreter Schritte zu zerlegen.
Die Verzeichnisstruktur ist wie folgt:

Schritt 1: Das intelligente Gehirn bauen
Das Gehirn des Agenten benötigt Denkfähigkeit. Wir werden OpenAIs GPT-Modell (über API-Aufrufe) als Gehirn unseres Agenten verwenden.
Sie müssen einen OpenAI-API-Schlüssel vorbereiten. Sie können auch den API-Schlüssel von DeepSeek verwenden; er ist kompatibel.
Die Testbeispiele dieses Kapitels verwenden den API-Schlüssel von DeepSeek. Wir können zuerst zuhttps://platform.deepseek.com/api_keysgehen und ihn beantragen.
Sie können auch direkt die Coding-Plan-Pakete von Bailian und Ark verwenden:https://www.example.com/claude-code/coding-plan.html。
Installieren Sie zuerst die erforderlichen Bibliotheken:
pip3 install openai
Sie können den folgenden Code verwenden, um zu testen, ob er erfolgreich ausgeführt wird:
Beispiel
from openai import OpenAI
DEEPSEEK_API_KEY = "sk-xxxxxxx" # Setzen Sie hier den Schlüssel ein, den Sie beantragt haben
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": "Du bist ein hilfreicher Assistent"},
{"role": "user", "content": "Hallo"},
],
stream=False
)
print(response.choices[0].message.content)
Wenn Installation und Konfiguration erfolgreich sind, wird etwa Folgendes ausgegeben:
Hello! How can I assist you today?
Dann erstellen wir das einfachste Gehirnmodul:
Code der Datei brain.py
from openai import OpenAI
import os
DEEPSEEK_API_KEY = "sk-xxxxxxx" # Setzen Sie hier den Schlüssel ein, den Sie beantragt haben
DEEPSEEK_API_URL = "https://api.deepseek.com/v1"
client = OpenAI(
api_key = DEEPSEEK_API_KEY,
base_url = DEEPSEEK_API_URL)
class AgentBrain:
Das Gehirn des Agenten, verantwortlich für Denken und Entscheidungsfindung
def __init__(self, model="deepseek-v4-flash"):
self.model = model
def think(self, prompt):
Kernfunktion des Denkens: empfängt einen Prompt und gibt das Denkergebnis des Modells zurück
try:
# Aufrufen der Chat Completions API mit dem Client (Syntax der Version v1.x)
response = client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.5, # Kreativität steuern, je niedriger, desto fokussierter
max_tokens=500 # Antwortlänge steuern
)
# Extrahiere den vom Modell zurückgegebenen Textinhalt (Attributpfadänderung in Version v1.x)
reasoning = response.choices[0].message.content
return reasoning.strip()
except Exception as e:
return f"Fehler im Denkprozess: {e}"
# Schneller Test, um zu sehen, ob das Gehirn funktioniert
if __name__ == "__main__":
brain = AgentBrain()
test_prompt = "Hallo, bitte stelle dich kurz vor."
print("Testfrage:", test_prompt)
print("Antwort des Gehirns:", brain.think(test_prompt))
Wenn man den obigen Code ausführt, sieht die Ausgabe ungefähr so aus:
测试提问: 你好,请简单介绍一下你自己。 大脑回复: 你好!我是DeepSeek,由深度求索公司创造的AI助手,很高兴认识你!😊 让我简单介绍一下自己: **我的特点:** **完全免费**:目前没有任何收费计划,你可以放心使用 **知识丰富**:知识截止到2024年7月,涵盖各个领域 **对话能力强**:支持128K上下文,可以进行长篇深入对话
Code-Erklärung:
- Wir haben eine
AgentBrainKlasse, die die Interaktion mit dem LLM kapselt. thinkDie Methode ist der Kern; sie empfängt einen Stringprompt(prompt) und sendet ihn an die GPT-API.temperatureDer Parameter ist sehr wichtig: Wenn man ihn auf 0.5 setzt, kann der Agent ein Gleichgewicht zwischen Kreativität und Stabilität finden, was für Planungsaufgaben geeignet ist.- Schließlich gibt sie den vom Modell generierten Text zurück, der das Ergebnis des Denkens des Agenten ist.
Schritt 2: Hände und Füße definieren: Werkzeuge und Aktionen
Der Agent benötigt Ausführungsfähigkeit. Wir definieren ein paar einfache Werkzeuge (Funktionen) für ihn, damit er handeln kann.
Code der Datei tools.py
import datetime
class AgentTools:
"""Eine Sammlung von Werkzeugen, die der Agent verwenden kann"""
@staticmethod
def search_web(query):
"""Simuliertes Web-Suchwerkzeug (hier simuliert)"""
mock_results = {
"Reiseziel-Empfehlung": "Paris, Tokyo, Malediven, Lijiang, Yunnan...",
"Wetter in Peking": "Morgen sonnig, Temperatur 15-25°C, leichte Brise.",
"Python-Tutorial": "Empfehle Websites wie Rookie Tutorial."
}
for key, value in mock_results.items():
if key in query:
return f"[Websuche] Ergebnisse für '{query}': {value}"
return f"[Websuche] Keine klaren Informationen für '{query}' gefunden."
@staticmethod
def make_schedule(steps):
"""Werkzeug zur Zeitplanung"""
schedule = "Generierter Zeitplan:\n"
for i, step in enumerate(steps, 1):
schedule += f"{i}. {step}"\n"
return schedule
@staticmethod
def get_current_time():
"""Werkzeug zum Abrufen der aktuellen Zeit"""
now = datetime.datetime.now()
return f"[Systemzeit] Aktuelle Zeit: {now.strftime('%Y-%m-%d %H:%M:%S')}"
@staticmethod
def calculate(expression):
"""Einfaches Taschenrechner-Werkzeug (sichere Version, behebt Kompatibilitätsprobleme)"""
try:
# 1. Illegale Zeichen streng filtern (nur Ziffern, grundlegende Operatoren, Klammern, Leerzeichen erlauben)
allowed_chars = set("0123456789+-*/(). ")
if not all(c in allowed_chars for c in expression):
return "[Taschenrechner] Der Ausdruck enthält illegale Zeichen, Berechnung wird verweigert."
# 2. Sicherheitsvalidierung vereinfachen: fehleranfällige ast.walk-Logik entfernen, stattdessen grundlegende Syntaxprüfung verwenden
# Zuerst Leerzeichen ersetzen, um leere Ausdrücke zu vermeiden
clean_expr = expression.strip().replace(" ", "")
if not clean_expr:
return "[Taschenrechner] Der Ausdruck darf nicht leer sein."
# 3. Die Berechnung sicher ausführen (integrierte Funktionen einschränken, nur grundlegende Operationen beibehalten)
# Eine benutzerdefinierte sichere globale Umgebung definieren, nur grundlegende mathematische Operationen erlauben
safe_globals = {
'__builtins__': {},
'pow': pow,
'abs': abs
}
# Verwendung von eval, aber die Umgebung wird streng eingeschränkt und illegale Zeichen werden gefiltert, wodurch das Risiko stark reduziert wird
result = eval(clean_expr, safe_globals)
return f"[Rechner] {expression} = {result}"
except ZeroDivisionError:
return "[Rechner] Fehler: Divisor darf nicht null sein."
except SyntaxError:
return "[Rechner] Syntaxfehler im Ausdruck (z. B. nicht übereinstimmende Klammern, Operatorfehler)."
except Exception as e:
return f"[Rechner] Berechnungsfehler: {str(e)}"
# Werkzeug testen
if __name__ == "__main__":
print(AgentTools.search_web("Wetter in Peking"))
print(AgentTools.get_current_time())
print(AgentTools.calculate("3 + 5 * 2")) # Normale Berechnung
print(AgentTools.calculate("10 / 0")) # Fehler bei Division durch null
print(AgentTools.calculate("__import__('os').system('ls')")) # Filterung illegaler Zeichen
Codeanalyse:
- Jedes
@staticmethoddefiniert ein Tool, das der Agent aufrufen kann. search_webDerzeit simuliert; in realen Szenarien muss eine echte Such-API integriert werden.make_scheduleWird verwendet, um eine Aufgabenliste in einen Plan zu formatieren.- Wichtiger Sicherheitshinweis:
calculateIm Tooleval()ist die Funktion extrem gefährlich in realen Produkten und muss durch einen sichereren Ansatz ersetzt werden (wie zum Beispielast.literal_eval), um sie zu ersetzen oder vollständig zu entfernen. Dies dient nur dazu, zu zeigen, wie der Agent Funktionen aufruft.
Schritt 3: Den Agenten zusammensetzen: Die Kernschleife implementieren
Jetzt setzen wir das Gehirn und die Tools zusammen und implementieren die zentrale Entscheidungsschleife. Wir entwerfen eine einfache Regel: Das Gehirn entscheidet anhand der Aufgabe, welches Tool verwendet werden soll.
Beispiel
from brain import AgentBrain
from tools import AgentTools
class SimpleAgent:
"""Ein einfacher KI-Agent zur Aufgabenplanung"""
def __init__(self):
self.brain = AgentBrain()
# Statische Tool-Klasse benötigt keine Instanziierung
self.tools = AgentTools
# Definiere die Liste der Tools, die der Agent kennt, und ihre Beschreibungen, mit denen das Gehirn angesteuert wird
self.tool_descriptions = """
Sie können die folgenden Tools verwenden:
1. Suchtool: Verwenden, wenn Sie die neuesten, unbekannten Informationen abrufen müssen, z. B. 'search Wetter in Peking'.
2. Planungstool: Verwenden, wenn Sie mehrere Schritte zu einem Plan organisieren müssen, z. B. 'make plan [step1, step2]'.
3. Zeittool: Verwenden, wenn Sie die aktuelle Zeit wissen müssen; der Befehl lautet 'get time'.
4. Berechnungstool: Verwenden, wenn Sie mathematische Berechnungen durchführen müssen, z. B. 'calculate 3+5*2'.
"""
def run(self, user_task):
"""Führt die Hauptschleife des Agenten aus"""
print(f"🎯 Benutzeraufgabe: {user_task}")
print("=" * 40)
# Schritt 1: Wahrnehmung und vorläufiges Denken
initial_prompt = f"""
Deine Rolle ist die eines Assistenten für Aufgabenplanung.
{self.tool_descriptions}
Die Aufgabe des Benutzers ist: {user_task}
Bitte antworte strikt im folgenden festen Format, füge keine zusätzlichen Inhalte hinzu:
Thought: [kurz analysieren, was die Aufgabe erfordert]
Tool: [Name des zu verwendenden Tools auswählen; wenn keines geeignet ist, 'None' schreiben]
Instruction: [den spezifischen Anweisungsinhalt, der an das Tool gesendet wird]
"""
initial_response = self.brain.think(initial_prompt)
print("🧠 Erstes Denkergebnis:")
print(initial_response)
print("-" * 20)
# Schritt 2: Das Denkergebnis analysieren, Tools und Anweisungen extrahieren (Robustheitsoptimierung)
lines = [line.strip() for line in initial_response.split('\n') if line.strip()]
tool_to_use = None
tool_instruction = ""
for line in lines:
if line.startswith(Thinking:):
continue # Die Denkzeile überspringen
elif line.startswith(Tool:):
tool_to_use = line.replace(Tool:, "").strip()
elif line.startswith(Instruction:):
tool_instruction = line.replace(Instruction:, "").strip()
# Schritt 3: Die Aktion ausführen
result = self._use_tool(tool_to_use, tool_instruction)
print(🛠️ Ausführungsergebnis:)
print(result)
print("=" * 40)
# Schritt 4: Die Ergebnisse integrieren und dem Benutzer Feedback geben
final_prompt = f"""
Ursprüngliche Aufgabe des Benutzers: {user_task}
Du hast bereits nachgedacht und Tools verwendet.
Denkprozess: {initial_response}
Tool-Ausführungsergebnis: {result}
Bitte generiere nun eine vollständige abschließende Antwort an den Benutzer, die direkt eine hilfreiche Antwort oder einen Plan in natürlicher und freundlicher Sprache liefert.
"""
final_response = self.brain.think(final_prompt)
print(💡 Abschließende Antwort an den Benutzer:)
print(final_response)
return final_response
def _use_tool(self, tool_name, instruction):
"""Ruft die spezifische Tool-Funktion anhand des Tool-Namens auf"""
# Einheitliches Tool-Namensmatching (Groß-/Kleinschreibung wird nicht beachtet / zusätzliche Leerzeichen werden toleriert)
tool_name = tool_name.strip()
if tool_name == Search tool:
return self.tools.search_web(instruction)
elif tool_name == Planning tool:
# Kompatibel mit chinesischen/englischen Kommas und Klammern, behandelt leere Anweisungen
if not instruction:
return [Planning tool] Es wurden keine Planungsschritte angegeben, es kann kein Zeitplan erstellt werden.
# Klammern entfernen und Schritte aufteilen (kompatibel mit []/()/{}-Klammern)
clean_instr = instruction.strip('[](){}').strip()
# Unterstützt auch die Aufteilung durch chinesische und englische Kommas
steps = [s.strip() for s in clean_instr.replace(',', ',').split(',') if s.strip()]
return self.tools.make_schedule(steps)
elif tool_name == Time tool:
return self.tools.get_current_time()
elif tool_name == Calculation tool:
return self.tools.calculate(instruction)
elif tool_name == None:
return [System] Es ist nicht nötig, Tools zu verwenden, antworte dem Benutzer einfach direkt.
else:
return f[System] Unbekanntes Tool: {tool_name}, kann nicht ausgeführt werden.
# Unseren Agenten ausführen!
if __name__ == "__main__":
print(🤖 SimpleAgent wird gestartet...)
my_agent = SimpleAgent()
# Mehrere verschiedene Aufgaben testen
test_tasks = [
Ich möchte reisen, hilf mir zu planen, was ich vorbereiten muss,
Wie spät ist es jetzt?,
Berechne 15 zum Quadrat plus ein Drittel von 20,
]
for task in test_tasks:
my_agent.run(task)
print("\n" + "#" * 50 + "\n")
Führe den Code aus, die Ausgabe sieht etwa wie folgt aus:
启动 SimpleAgent... 用户任务: 我想去旅行,帮我规划一下需要准备什么 ======================================== 初始思考结果: 思考:用户需要规划旅行前的准备工作。这是一个通用任务,不需要最新信息或计算,但需要将多个准备步骤整理成一个清晰的计划。 工具:计划工具 指令:制定计划 [1. 确定目的地和旅行时间,2. 预订交通票(机票/火车票)和住宿,3. 准备旅行证件(身份证、护照、签证等),4. 安排行程和景点门票,5. 打包行李(衣物、洗漱用品、药品、充电器等),6. 安排家中事务(宠物、植物、邮件等),7. 兑换货币或准备支付方式,8. 购买旅行保险] -------------------- 执行结果: ...
Code-Parsing- und Ausführungsablauf:
- Initialisierung: Der Agent hat sein eigenes Gehirn erstellt (
AgentBrain) und Toolbox (AgentTools)。 - Aufgabe empfangen:
runMethode startet, empfängtuser_task(z. B. "Ich möchte reisen"). - Denkphase: Kombiniere die Aufgaben- und Toolbeschreibungen zu
initial_prompt, sende es an das Gehirn. Der vom Gehirn zurückgegebene Text enthält das "Tool", das es ausgewählt hat, und die "Anweisungen", die dem Tool gegeben wurden. - Aktionsphase:
_use_toolDie Funktion ruft basierend auf der Wahl des Gehirns die entsprechende Tool-Funktion auf und gibt das Ergebnis zurück. - Feedback und Zusammenfassung: Sende die ursprüngliche Aufgabe, den Denkprozess und die Aktionsergebnisse erneut an das Gehirn, damit es eine benutzerfreundliche endgültige Antwort erzeugen kann.
Führe dieses Programm aus, und du wirst sehen, wie der Agent Aufgaben Schritt für Schritt analysiert, Tools auswählt, ausführt und Antworten liefert.
Übungsaufgabe: Rüste deinen Agenten auf
Du hast bereits einen funktionierenden KI-Agenten! Aber das ist nur der Anfang. Versuche die folgenden Übungen abzuschließen, um ihn leistungsfähiger zu machen:
Übung 1: Gedächtnisfunktion hinzufügen
- Ziel: Lass den Agenten sich den Gesprächsverlauf merken.
- Hinweis: In der
SimpleAgentKlasse, füge eineself.conversation_history = []Liste. Jedes Mal, wenn du aufrufstbrain.think, sende nicht nur den aktuellen Prompt, sondern auch den bisherigen Gesprächsverlauf als Kontext. Füge nach der Ausführung den neuen Gesprächsdurchgang (Benutzereingabe, KI-Denken, Tool-Ergebnisse) zur Verlaufsliste hinzu.
Übung 2: Automatische Tool-Auswahl implementieren
- Ziel: Die Antwort des Gehirns in ein standardmäßiges JSON-Format bringen, damit das Programm sie leicht automatisch parsen kann, statt sich auf Textextraktion zu verlassen.
- Hinweis: Ändere den Prompt so, dass das Gehirn eine
{"thought": "…", "tool": "…", "instruction": "…"}JSON-Zeichenkette. Verwende dann im Codejson.loads()zum Parsen, wodurch Stabilität und Genauigkeit verbessert werden.
Übung 3: Ein neues Tool hinzufügen
- Ziel: Lass den Agenten To-do-Einträge verarbeiten.
- Hinweis: In der
AgentToolsKlasse, fügetodo_list = []und zwei neue Methoden hinzu:add_todo(item)undshow_todos(). Informiere das Gehirn in der Tool-Beschreibung über dieses neue Tool und aktualisiere die_use_toolMethode, um es aufzurufen.
Zusammenfassung und Ausblick
Herzlichen Glückwunsch! Du hast erfolgreich einen grundlegenden KI-Agenten mit einemWahrnehmen-Denken-Handeln-Zyklus erstellt. Lass uns die wichtigsten Punkte wiederholen:
- Kernkonzepte: KI-Agent = Gehirn (LLM) + Wahrnehmung + Handlung + Ziel.
- Schlüsselaspekte der Implementierung:
- Gehirn: Rufe das LLM (z. B. GPT) über die API auf, um Schlussfolgerungen zu ziehen.
- Tools: Kapsele spezifische Fähigkeiten in Funktionen, die der Agent aufrufen kann.
- Schleife: Verwende Codelogik, um Denken, Entscheidungsfindung und Ausführung zu verbinden.
Dies ist nur die Spitze des Eisbergs in der Welt der KI-Agenten. Industrietaugliche Frameworks wieLangChain、AutoGenbieten leistungsfähigere Tool-Integration, Speicherverwaltung, Multi-Agenten-Zusammenarbeit und weitere Funktionen. Um weiter zu erkunden, wird empfohlen, dass du:
Weitere Erweiterungen