Einen KI-Agenten erstellen
Erstellen Sie autonome KI-Agenten, die eigenständig denken, planen, Werkzeuge nutzen und komplexe mehrstufige Aufgaben erledigen können.
Einführung
KI-Agenten stellen die nächste Entwicklungsstufe jenseits von Chatbots und Assistenten dar. Während ein Assistent auf einzelne Anfragen reagiert, kann ein Agent autonom mehrstufige Aufgaben planen und ausführen – mit minimaler menschlicher Aufsicht.
In diesem fortgeschrittenen Leitfaden erstellen Sie einen KI-Agenten von Grund auf, der über Probleme nachdenken, Pläne erstellen, Werkzeuge nutzen und komplexe Ziele eigenständig erreichen kann.
Was ist ein KI-Agent?
Ein KI-Agent ist ein System mit vier Kernfähigkeiten:
- Autonomie — Er arbeitet eigenständig und trifft Entscheidungen, ohne dass jeder Schritt vorgegeben wird.
- Wahrnehmung — Er beobachtet seine Umgebung und versteht den aktuellen Zustand der Dinge.
- Denken — Er denkt über Probleme nach, bewertet Optionen und erstellt Pläne.
- Handlung — Er führt konkrete Aktionen mit Werkzeugen aus – Suchen, Schreiben, Berechnen, APIs aufrufen.
💡 Agent vs. Assistent
Ein Assistent wartet auf Ihre Anweisungen und führt eine Aufgabe nach der anderen aus. Ein Agent erhält ein Ziel und findet eigenständig die notwendigen Schritte heraus, wobei er iteriert, bis das Ziel erreicht ist.
Die Agenten-Schleife
Jeder KI-Agent läuft in einer kontinuierlichen Schleife aus vier Phasen:
Beobachten
Der Agent sammelt Informationen aus seiner Umgebung – die Anfrage des Benutzers, Werkzeugausgaben, Fehlermeldungen oder neue Daten.
Denken
Der Agent überlegt, was er beobachtet hat. Er berücksichtigt das aktuelle Ziel, was bereits erreicht wurde und was der beste nächste Schritt wäre.
Handeln
Der Agent führt seine gewählte Aktion aus – ein Werkzeug aufrufen, eine Datei schreiben, Code ausführen oder eine Anfrage senden.
Reflektieren
Der Agent bewertet das Ergebnis. Hat die Aktion funktioniert? Ist er dem Ziel näher? Sollte er einen anderen Ansatz versuchen?
Werkzeuge und Umgebung
Werkzeuge geben Agenten ihre Stärke. Ohne Werkzeuge ist ein Agent nur ein Sprachmodell. Mit Werkzeugen kann er mit der realen Welt interagieren:
class Tool:
"""Base class for agent tools."""
def __init__(self, name, description):
self.name = name
self.description = description
def execute(self, **kwargs):
raise NotImplementedError
class WebSearchTool(Tool):
def __init__(self):
super().__init__(
"web_search",
"Search the internet for current information"
)
def execute(self, query):
# In production, use a real search API
return f"Search results for: {query}"
class FileWriteTool(Tool):
def __init__(self):
super().__init__(
"write_file",
"Write content to a file on disk"
)
def execute(self, filename, content):
with open(filename, 'w') as f:
f.write(content)
return f"Written to {filename}"
class CodeExecutionTool(Tool):
def __init__(self):
super().__init__(
"run_code",
"Execute Python code and return the output"
)
def execute(self, code):
# WARNING: In production, use sandboxed execution!
import subprocess
result = subprocess.run(
["python", "-c", code],
capture_output=True, text=True, timeout=30
)
return result.stdout or result.stderrEinen Agenten erstellen
Lassen Sie uns einen vollständigen KI-Agenten mit der Beobachten-Denken-Handeln-Schleife erstellen:
from openai import OpenAI
import json
class AIAgent:
def __init__(self, name, goal, tools):
self.name = name
self.goal = goal
self.tools = {tool.name: tool for tool in tools}
self.client = OpenAI()
self.memory = []
self.max_iterations = 10
def _get_tool_descriptions(self):
return [
{
"type": "function",
"function": {
"name": t.name,
"description": t.description,
"parameters": {"type": "object", "properties": {}}
}
}
for t in self.tools.values()
]
def think(self, observation):
"""The agent's reasoning step."""
self.memory.append({"role": "user", "content": observation})
response = self.client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": f"""You are {self.name},
an autonomous AI agent. Your goal: {self.goal}
Available tools: {list(self.tools.keys())}
Think step by step:
1. What have I learned so far?
2. What should I do next?
3. Which tool should I use?
4. Am I done with my goal?
Respond with JSON:
{{"thought": "your reasoning",
"action": "tool_name or DONE",
"action_input": {{"param": "value"}}}}"""},
*self.memory
],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
def run(self, initial_task):
"""Main agent loop."""
print(f"Agent '{self.name}' starting: {initial_task}")
observation = initial_task
for i in range(self.max_iterations):
print(f"\n--- Iteration {i+1} ---")
# Think
result = self.think(observation)
print(f"Thought: {result['thought']}")
# Check if done
if result["action"] == "DONE":
print(f"\nAgent completed: {result['thought']}")
return result["thought"]
# Act
tool = self.tools.get(result["action"])
if tool:
try:
output = tool.execute(**result.get("action_input", {}))
observation = f"Tool '{tool.name}' returned: {output}"
print(f"Action: {tool.name} -> {output[:200]}")
except Exception as e:
observation = f"Error: {str(e)}"
else:
observation = f"Unknown tool: {result['action']}"
self.memory.append(
{"role": "assistant", "content": json.dumps(result)}
)
return "Max iterations reached."
# Create and run the agent
agent = AIAgent(
name="Research Assistant",
goal="Research a topic and write a summary report",
tools=[WebSearchTool(), FileWriteTool(), CodeExecutionTool()]
)
agent.run("Research the latest trends in AI agents for 2025")Mehrstufige Planung
Für komplexe Ziele profitieren Agenten davon, einen expliziten Plan vor der Ausführung zu erstellen:
class PlanningAgent(AIAgent):
"""Agent that creates a plan before executing."""
def create_plan(self, task):
response = self.client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": f"""Create a step-by-step
plan to accomplish this task. Available tools: {list(self.tools.keys())}
Return JSON: {{"steps": ["step 1", "step 2", ...]}}"""},
{"role": "user", "content": task}
],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
def run(self, task):
# First, create a plan
plan = self.create_plan(task)
print(f"Plan: {plan['steps']}")
# Then execute each step
results = []
for step in plan["steps"]:
result = super().run(step)
results.append(result)
return results✅ Planungsstrategie
Lassen Sie den Agenten zuerst einen Plan erstellen, dann führen Sie ihn Schritt für Schritt aus. Wenn ein Schritt fehlschlägt, lassen Sie den Agenten vom aktuellen Zustand aus neu planen, anstatt von vorne zu beginnen. Dies ist effizienter und spiegelt wider, wie Menschen komplexe Aufgaben bewältigen.
Sicherheit und Leitplanken
Autonome Agenten brauchen Sicherheitsmaßnahmen. Hier sind kritische Leitplanken:
- Sandboxed Ausführung — Führen Sie Agentencode in isolierten Umgebungen aus. Geben Sie Agenten niemals uneingeschränkten Zugriff auf Ihr Dateisystem oder Netzwerk.
- Iterationslimits — Setzen Sie maximale Iterationszähler, um Endlosschleifen zu verhindern. Die meisten Aufgaben sollten in unter 10 Schritten abgeschlossen sein.
- Menschliche Freigabe — Für kritische Aktionen (Dateien löschen, E-Mails senden, Einkäufe tätigen) ist eine menschliche Bestätigung erforderlich.
- Umfassende Protokollierung — Protokollieren Sie jeden Gedanken, jede Aktion und jedes Ergebnis. Dies ist unerlässlich für Debugging und Auditing des Agentenverhaltens.
⚠️ Kritische Sicherheitswarnung
Geben Sie einem KI-Agenten niemals uneingeschränkten Zugriff auf Codeausführung, Dateiverwaltung oder Finanztransaktionen ohne menschliche Aufsicht. Beginnen Sie mit Nur-Lese-Werkzeugen und erweitern Sie die Fähigkeiten schrittweise, wenn Sie Vertrauen aufbauen.
Zusammenfassung
Sie haben einen autonomen KI-Agenten erstellt. Wichtigste Erkenntnisse:
- KI-Agenten arbeiten in einer kontinuierlichen Beobachten-Denken-Handeln-Reflektieren-Schleife.
- Werkzeuge geben Agenten die Fähigkeit, mit der realen Welt zu interagieren.
- Planung vor Ausführung verbessert die Erfolgsraten bei komplexen Aufgaben.
- Sicherheitsleitplanken (Sandbox, Limits, menschliche Freigabe) sind nicht optional – sie sind essentiell.