Im Inneren eines KI-Agenten: Modelle, Tools, Speicher und Schlussfolgerungsvermögen erläutert
Er erklärt die grundlegende Architektur von KI-Agenten – Ziele, Modelle, Werkzeuge, Speicher und Reasoning – und zeigt anhand eines praktischen Beispiels für einen auf Python basierenden Forschungsagenten, wie diese Struktur funktioniert.
In der ersten Folge von AI Agents with Python 2026 haben wir uns einer grundlegenden Frage gewidmet:
Was ist eigentlich ein KI-Agent?
Wir haben untersucht, wie sich herkömmliche Software von Chatbots, generativen KI-Systemen sowie Agenten unterscheidet, die eigene Ziele verfolgen. Außerdem haben wir die wesentlichen Bestandteile aufgeführt, aus denen ein Agent besteht – Modelle, Tools, Speicher, Wissen, Aktionen und Sicherheitsmechanismen.
Dieses Mal werden wir den „Deckel öffnen“ und uns die internen Mechanismen ansehen.
Was geschieht eigentlich, wenn ein Agent läuft?
Wie wählt er seine nächste Aktion aus?
Wie findet er das richtige Tool für die Aufgabe?
Wie behält er Informationen über verschiedene Schritte hinweg bei?
Und wie erkennt er, dass eine Aufgabe abgeschlossen ist?
Willkommen zur zweiten Folge dieser Reihe – vom einfachen Automatisieren hin zu wirklich autonomen Systemen.
Die Architektur eines KI-Agenten
Auf konzeptioneller Ebene verbindet ein KI-Agent mehrere Komponenten in einem wiederkehrenden Zyklus:
Ziel → Modell → Entscheidung → Werkzeug → Beobachtung → Nächste Entscheidung → Ergebnis
Eine vereinfachte Version dieser Architektur könnte wie folgt aussehen:
USER / APPLICATION
│
▼
┌──────────────┐
│ GOAL │
└──────┬───────┘
│
▼
┌──────────────┐
│ AI MODEL │
│ LLM / Model │
└──────┬───────┘
│
▼
┌──────────────┐
│ DECISION │
│ / PLANNING │
└──────┬───────┘
│
┌─────────┼─────────┐
▼ ▼ ▼
TOOL 1 TOOL 2 TOOL 3
│ │ │
└─────────┼─────────┘
│
▼
OBSERVATION
│
▼
┌──────────────┐
│ NEXT ACTION? │
└──────┬───────┘
│
┌──────┴──────┐
│ │
YES NO
│ │
▼ ▼
Continue Result
Denken Sie daran, dass dies ein vereinfachtes Bild ist.
Produktionsreife Agentensysteme sind in der Regel weitaus komplexer, doch das Verständnis dieses Kernzyklus bietet einen soliden Ausgangspunkt für alles Weitere.
1. Das Ziel
Das Verhalten jedes Agenten beginnt mit einem Ziel.
Das System benötigt ein konkretes Verständnis dafür, was es erreichen soll.
Betrachten Sie folgendes Beispiel:
"Analysieren Sie die Verkaufszahlen dieses Monats und identifizieren Sie die drei Produkte mit dem größten Rückgang."
Ein Ziel gibt der gesamten Prozessrichtung vor.
Wenn das Ziel nicht klar formuliert ist, läuft der Agent Gefahr, fehlerhafte Antworten zu liefern oder Maßnahmen zu ergreifen, die tatsächlich nicht helfen.
Ein gut formuliertes Ziel legt in der Regel Folgendes fest:
- Die zu erledigende Aufgabe
- Die relevanten Daten oder Informationen
- Die erwartete Form der Ausgabe
- Jegliche einzuhaltenden Grenzen oder Beschränkungen
Nehmen wir diese beiden Versionen:
Schwaches Ziel:
"Analysieren Sie die Daten."
Stärkeres Ziel:
"Prüfen Sie das Verkaufsdatensatz, markieren Sie alle Produkte, deren monatlicher Umsatz um mehr als 10 Prozent gesunken ist, und erstellen Sie eine Tabelle, die die Ergebnisse zusammenfasst."
Verglichen mit der vagen Version gibt diese Formulierung dem Agenten ein deutlich klareres Ziel, an dem er arbeiten kann.
2. Das KI-Modell
Das Modell fungiert als Denk- und Sprachmotor im Kern der meisten modernen Agenten.
Große Sprachmodelle (LLMs) haben hier ihren Platz, weil sie in der Lage sind:
- Natürlichsprachige Eingaben zu analysieren
- Anweisungen zu verstehen
- Kontextuelle Informationen abzuwägen
- Gut strukturierte Ausgaben zu erzeugen
- Zwischen möglichen Aktionen zu wählen
- Die Argumente zu erstellen, die ein Tool benötigt
Trotzdem ist das Modell nur ein Teil des Puzzles.
Bilden Sie es sich als Gehirn innerhalb eines größeren Organismus vor.
Ein Gehirn, das von Augen, Händen, Gedächtnis und der Außenwelt isoliert ist, kann allein nicht viel ausrichten.
Dasselbe gilt für ein LLM – seine Nützlichkeit steigt, sobald es mit relevanten Tools und Datensätzen verbunden wird.
3. Anweisungen und Kontext
Das Modell muss seine Rolle sowie die Besonderheiten der aktuellen Aufgabe kennen.
Dazu gehören in der Regel:
- Anweisungen auf Systemebene
- Anweisungen vom Benutzer
- Eine Liste der Tools, die aufgerufen werden können
- Frühere Konversationen
- Daten, die durch Abfragen eingeholt werden
- Der aktuelle Zustand der Aufgabe
- Jegliche Regeln oder Grenzen, die eingehalten werden müssen
Zum Verständnis: Ein Agent, der dazu dient, einen IT-Support zu unterstützen, könnte mit etwas wie folgendem konfiguriert werden:
You are an IT support assistant.
Your responsibilities:
1. Diagnose common technical issues.
2. Search the approved knowledge base.
3. Provide troubleshooting instructions.
4. Escalate high-risk issues to a human technician.
Do not modify production systems without authorization.
Solche Anweisungen bestimmen, wie sich der Agent verhalten soll.
4. Tools
Während ein Modell Text und Schlussfolgerungen erzeugen kann, ermöglichen Tools es einem Agenten, tatsächlich auf externe Systeme zuzugreifen.
Häufige Kategorien von Tools sind:
- Websuche
- Externe APIs
- Datenbanken
- Dateisysteme
- Rechner
- Custom-Python-Funktionen
Betrachten Sie einen Assistenten, der für die Berichterstattung über das aktuelle Wetter zuständig ist.
Das eingebaute Wissen des Modells umfasst keine Echtzeitdaten.
Deshalb wendet sich der Assistent stattdessen über einen Tool-Aufruf an eine Wetter-API.
Der Ablauf sieht ungefähr so aus:
User Request
↓
AI Model
↓
Weather Tool
↓
Current Weather Data
↓
AI Model
↓
Response
Das Tool liefert Daten, die das Modell nicht zuverlässig selbst erzeugen kann.
Toolaufruf
Eine zentrale Idee in agierenden Systemen ist das sogenannte Toolaufruf.
Anstatt nur eine Textantwort zu generieren, kann das Modell angeben, dass ein bestimmtes Tool ausgeführt werden muss.
Zum Beispiel:
tools = [
"search_database",
"calculate",
"get_weather"
]
Nehmen wir an, ein Benutzer fragt:
"Wie ist das Wetter in Accra?"
Das Modell könnte erkennen, dass get_weather das richtige Werkzeug für diese Anfrage ist.
Die umgebende Anwendung ruft dann diese Funktion auf und gibt das Ergebnis zurück an das Modell.
In Python könnte dies einfach wie folgt dargestellt werden:
def get_weather(city):
# Call an approved weather service
return weather_data
Die wesentliche Regel hier ist, dass das Modell vorschlägt, was es benötigt, aber die Anwendung die Kontrolle darüber behält, was tatsächlich ausgeführt wird.
Diese Trennung ist aus Sicherheitsgründen von großer Bedeutung.
Modelle sollten keinen unbegrenzten Zugriff haben
Stellen Sie sich vor, man überlässt einem KI-Modell uneingeschränkte Kontrolle über:
- Ihre Datenbank
- Ihre E-Mail-Konten
- Ihr Dateisystem
- Ihre Finanzsysteme
- Ihr Betriebssystem
Eine solche Offenlegung würde ernsthafte Risiken mit sich bringen.
Agenten sollten stattdessen nur den Zugriff erhalten, den sie tatsächlich zur Ausführung ihrer Arbeit benötigen.
Dies spiegelt eine bekannte Idee aus der Sicherheitstechnik wider:
Prinzip der geringsten Befugnisse
Weisen Sie einem System nur die Berechtigungen zu, die es wirklich zum Ausführen seiner Aufgabe benötigt – nichts mehr.
Zum Beispiel:
Ein Kundenservice-Agent könnte berechtigt sein, Kundendaten zu lesen.
Aber er hat vermutlich keinen Grund, diese Datensätze zu löschen.
Diese Idee wird später in dieser Serie bei der Behandlung der Agentensicherheit ausführlicher behandelt.
5. Speicher
Der Speicher ermöglicht es einem Agenten, wichtige Informationen über einen gesamten Dialog oder eine Aufgabe hinweg beizubehalten.
Ohne ihn würde jeder Austausch vom vorherigen getrennt erscheinen.
Stellen Sie sich einen persönlichen KI-Assistenten vor.
Sie erwähnen:
"Meine bevorzugte Programmiersprache ist Python."
Dann fragt man später:
"Empfehlen Sie mir ein Programmierprojekt."
Falls der Assistent über Arbeitsgedächtnis verfügt, kann er diese beiden Situationen miteinander verknüpfen und seine Antwort anhand dessen anpassen, was man ihm zuvor mitgeteilt hat.
Gedächtnis ist kein einheitliches Konzept – es wirkt in verschiedenen Bereichen.
Kurzfristiges Gedächtnis
Das Kurzfristige Gedächtnis umfasst Details, die nur innerhalb der aktuellen Sitzung oder Aufgabe relevant sind.
User:
My budget is GHS 5,000.
User:
Show me laptops.
Agent:
I'll focus on options around your GHS 5,000 budget.
Ohne das zuvor erwähnte Budget im Hinterkopf zu behalten, wüsste der Assistent nicht, wie er seine Empfehlungen für Laptops angemessen einordnen soll.
Langfristiges Gedächtnis
Das Langfristige Gedächtnis bleibt über mehrere Gespräche hinaus bestehen.
User Preference:
Prefers Python tutorials.
Previous Project:
Built an AI study assistant.
Current Goal:
Learning AI agents.
Eine Anwendung speichert in der Regel diese Art von Daten in einer dedizierten Datenbank oder einem Speichersystem.
Trotzdem wirft das Speichern persönlicher Daten Privatsphärenfragen auf, die nicht ignoriert werden sollten.
Man muss folgende Punkte durchdenken:
- Welche Informationen sollten gespeichert werden
- Wie lange sollen sie aufbewahrt werden
- Wo werden sie gespeichert
- Wer hat Zugriff darauf
- Wie kann ein Benutzer sie löschen
Der Speicher sollte niemals nachträglich berücksichtigt werden – er erfordert eine bewusste Gestaltung.
6. Wissen
Speicher und Wissen klingen ähnlich, dienen aber unterschiedlichen Zwecken.
Speicher protokolliert in der Regel Details über den Benutzer, das Gespräch oder den aktuellen Zustand einer Aufgabe.
Wissensabruf hingegen bedeutet, relevante Fakten aus externen Quellen abzurufen.
Betrachten Sie einen Unternehmens-AI-Agenten, der möglicherweise auf Folgendes verweisen muss:
- Mitarbeiterrichtlinien
- Produktdokumentation
- Technische Handbücher
- Interne Verfahren
- Häufig gestellte Fragen
Anstatt alle Dokumente in die Anfrage aufzunehmen, kann das System nur das Heranziehen, was zum jeweiligen Zeitpunkt benötigt wird.
Dies bildet die Grundlage eines wichtigen Musters in der AI-Architektur:
Retrieval-Augmented Generation (RAG)
Auf höherer Ebene sieht ein RAG-Pipeline so aus:
User Question
↓
Retrieve Relevant Information
↓
Knowledge Source
↓
Relevant Context
↓
AI Model
↓
Answer
RAG wird besonders wertvoll, wenn es mit Agenten kombiniert wird.
Ein Agent kann erkennen, dass ihm bestimmte Informationen fehlen, den relevanten Inhalt abrufen und anschließend die Aufgabe mit dem gefundenen Material fortsetzen.
In Teil 6 werden wir dieses Muster genauer untersuchen.
7. Reasoning und Planning
Eine der überzeugendsten Fähigkeiten von KI-Agenten besteht darin, eine große Aufgabe in eine Abfolge kleinerer, handhabbarer Schritte aufzuteilen.
Nehmen wir an, ein Benutzer bittet den Agenten, einen Vergleich von drei Cloud-Anbietern für ein kleines Unternehmen zusammenzustellen.
Dafür könnten folgende Schritte erforderlich sein:
- Die Plattformen identifizieren
- Preisinformationen sammeln
- Die Funktionen vergleichen
- Vorteile und Nachteile abwägen
- Die Erkenntnisse strukturieren
- Den endgültigen Bericht erstellen
Der Agent muss möglicherweise dynamisch herausfinden, welcher Schritt anhand dessen, was er derzeit weiß, als Nächstes sinnvoll ist.
Darin besteht die Rolle der Planung.
Planung bedeutet nicht immer komplexe Logik
Gehen Sie nicht davon aus, dass jeder Agent einen aufwendigen, vollständig autonomen Planungsmechanismus benötigt.
Einige Arbeitsabläufe können einfach bleiben:
Input
↓
Call API
↓
Format Result
↓
Return Response
Andere fordern tatsächlich etwas Komplexeres:
Goal
↓
Plan
↓
Research
↓
Analyze
↓
Verify
↓
Generate
↓
Review
↓
Complete
Welche Variante geeignet ist, hängt vollständig vom zu lösenden Problem ab.
Es lohnt sich, dies nochmals zu wiederholen:
Wählen Sie die einfachste Architektur, die das Problem zuverlässig lösen kann.
8. Beobachtung
Sobald ein Agent eine Aktion ausführt, benötigt er Rückmeldung darüber, was tatsächlich erreicht wurde.
Das ist der Beobachtungsschritt.
Agent:
Search for information about Python.
Tool:
Returns 20 search results.
Agent:
Analyze the results and determine which are relevant.
Die zurückkehrenden Daten werden zur Beobachtung, die der Agent in seine nächste Aktion einbezieht.
Zusammen bilden sie einen sich wiederholenden Kreislauf:
Denken → Handeln → Beobachten → Entscheiden → Wieder handeln
Der Agentenzyklus
Sobald alle Komponenten vorhanden sind, sieht das Zusammenspiel so aus:
┌──────────────┐
│ GOAL │
└──────┬───────┘
↓
┌──────────────┐
│ CONTEXT │
└──────┬───────┘
↓
┌──────────────┐
│ AI MODEL │
└──────┬───────┘
↓
┌──────────────┐
│ DECISION │
└──────┬───────┘
↓
┌──────────────┐
│ TOOL │
└──────┬───────┘
↓
┌──────────────┐
│ OBSERVATION │
└──────┬───────┘
↓
┌──────────────┐
│ COMPLETE? │
└───┬──────┬───┘
│ │
NO YES
│ │
↓ ↓
Continue Result
Das Verständnis dieser Schleife ist entscheidend, um zu verstehen, wie agierende Systeme funktionieren.
Ein praktisches Beispiel: Forschungsagent
Lassen Sie uns einen einfachen Entwurf für einen Forschungsagenten durchgehen.
Stellen Sie sich eine Anfrage vor, bei der der Assistent beauftragt wird, herauszufinden, wie kleine Unternehmen in Ghana von der Nutzung von Solarenergie profitieren könnten, und die Ergebnisse in eine kurze Zusammenfassung zu fassen.
Die Bearbeitung dieser Anfrage lässt sich in die folgenden Schritte unterteilen.
Schritt 1 – Verstehen
Klären Sie Folgendes:
- Das Thema
- Der geografische Fokus
- Die Zielgruppe
- Wie das Endergebnis aussehen sollte
Schritt 2 – Planen
Ermitteln Sie, welche Informationen tatsächlich benötigt werden.
Schritt 3 – Abrufen
Holen Sie Daten aus zugelassenen Quellen ab.
Schritt 4 – Analysieren
Prüfen Sie, was abgerufen wurde.
Schritt 5 – Organisieren
Ordnen Sie die Erkenntnisse in logische Kategorien ein.
Schritt 6 – Erstellen
Entwerfen Sie den angeforderten Überblick.
Schritt 7 – Überprüfen
Stellen Sie sicher, dass die Ausgabe tatsächlich auf die ursprüngliche Anfrage eingeht.
Schritt 8 – Zurückgeben
Liefern Sie die endgültige Antwort.
Dies veranschaulicht einen zielorientierten Agenten-Arbeitsablauf in der Praxis.
Was passiert, wenn ein Tool versagt?
In der realen Welt gehen Dinge kaputt.
APIs sind nicht verfügbar.
Datenbanken erreichen ihre Zeitbegrenzung.
Suchanfragen liefern irrelevante Ergebnisse.
Tools senden manchmal fehlerhafte Daten zurück.
Ein gut konstruierter Agent muss auf solche Szenarien Rücksicht nehmen.
Zum Beispiel:
try:
result = get_data()
except Exception as error:
print("Tool failed:", error)
Produktionsreife Systeme benötigen in der Regel eine weitaus robustere Handhabung als dies.
Je nach Situation kann der Agent:
- Den fehlgeschlagenen Schritt erneut versuchen
- Auf ein anderes genehmigtes Tool umsteigen
Eine angemessene Handhabung von Fehlern ist ein zentraler Bestandteil der Agentenentwicklung, kein Randfall.
Mensch im Entscheidungsprozess
Automatisierung sollte nicht auf jede Entscheidung angewandt werden.
Manche Aktionen erfordern tatsächlich zunächst die Genehmigung eines Menschen.
Zum Beispiel:
AI Agent
↓
Prepare financial transaction
↓
Human Approval
↓
Execute Transaction
Dieses Muster wird als Mensch im Entscheidungsprozess (HITL) bezeichnet.
Es ist besonders wertvoll, wenn ein Agent in der Lage ist, hochriskante Aktionen durchzuführen, wie zum Beispiel:
- Finanzielle Transaktionen
- Löschung von Daten
- Sendung sensibler Nachrichten
- Änderung von Produktionsystemen
- Genehmigung wichtiger Entscheidungen
Durch Hinzufügen einer menschlichen Kontrollstelle kann der Schaden durch Fehler eines Agents erheblich eingeschränkt werden.
Deterministische vs. agentebasierte Workflows
Es gibt noch eine weitere Unterscheidung, die verstanden werden sollte.
Ein deterministischer Workflow folgt einer festen Abfolge von Schritten:
Step 1 → Step 2 → Step 3 → Step 4
Ein agiler Workflow hingegen entscheidet im Lauf der Zeit spontan, was als Nächstes getan werden soll:
Goal
↓
Decision
↓
Action
↓
Observation
↓
Next Decision
Keiner der Ansätze ist von Natur aus die bessere Wahl.
Für vorhersehbare und gut verstandene Aufgaben ist ein deterministischer Workflow in der Regel einfacher zu testen, zu überwachen und sicher abzusichern.
Wenn die Bedingungen ungewiss sind und die Anforderungen ständig ändern, funktioniert es in der Regel besser, dem Agenten Freiraum zu geben, seinen eigenen Weg zu bestimmen.
Keines der Muster ist in jeder Situation überlegen. Die Wahl zwischen ihnen ist einfach Teil guter Ingenieursarbeit.
Wo Python passt
Python eignet sich hervorragend, um die Komponenten eines Agents miteinander zu verbinden.
Eine vereinfachte Architektur könnte wie folgt aussehen:
Python Application
│
├── AI Model
│
├── Tools
│
├── APIs
│
├── Database
│
├── Memory
│
└── RAG / Knowledge Base
Python übernimmt die Koordination zwischen diesen Komponenten und enthält die zugehörige Geschäftslogik.
Dies ist ein Grund dafür, warum Python so gut geeignet ist für den Aufbau von KI-Systemen.
Eine einfache Python-Agent-Architektur
Hier ist ein konzeptioneller Entwurf eines minimalen Agents:
class SimpleAgent:
def __init__(self, model, tools):
self.model = model
self.tools = tools
def run(self, goal):
context = goal
while True:
decision = self.model.decide(
context,
self.tools
)
if decision["action"] == "finish":
return decision["result"]
tool = self.tools[decision["tool"]]
result = tool(**decision["arguments"])
context = {
"goal": goal,
"previous_result": result
}
Dieses Beispiel ist absichtlich sehr einfach gehalten.
Ein echter, produktreifer Agent benötigt viel mehr unterstützende Infrastruktur, wie zum Beispiel:
- Prüfungen der eingehenden Daten
- Eine Möglichkeit, herauszufinden, wer das System aufruft
- Bearbeitung von Fehlern im Laufe des Vorgangs
- Eine Aufzeichnung dessen, was passiert ist und wann
- Richtlinien darüber, welche Tools verwendet werden dürfen
- Aufzeichnung des aktuellen Zustands des Agents
Trotzdem fasst dieser Auszug den wesentlichen Ablauf zusammen:
Ziel festlegen → Entscheidung treffen → Tool aufrufen → Ergebnis beobachten → fortfahren oder stoppen.
Warum Agenten-Schleifen Grenzen benötigen
Stellen Sie sich einen Agenten vor, der ständig zu dem Schluss kommt, dass er nur noch eine Aktion ausführen muss.
Ohne Obergrenze könnte er ewig laufen.
Wenn das unkontrolliert bleibt, können Folgen entstehen:
- Ausufernde API-Kosten
- Schleppende Reaktionszeiten
- Übermäßiger Ressourcenverbrauch
- Wiederholte, überflüssige Aktionen
- Unerwartetes Verhalten
Um dem entgegenzuwirken, sollten Entwickler Kontrollmechanismen wie folgende einbauen:
- Eine Obergrenze für die Anzahl der Iterationen
- Zeitlimits für die Ausführung
- Obergrenzen für Tool-Aufrufe
- Ausgabengrenzen
- Pflichtige Genehmigungsverfahren
Zum Beispiel:
MAX_STEPS = 10
Das System kann den Agenten stoppen, sobald die zulässige Anzahl an Schritten überschritten wird.
Eine solch einfache Sicherheitsmaßnahme reicht oft aus, um zu verhindern, dass Workflows außer Kontrolle geraten.
Sicherheit ist Teil der Architektur
Sicherheit für einen Agenten ist nichts, was man später hinzufügt.
Sie muss von Anfang an integriert werden.
Wichtige Aspekte, die berücksichtigt werden müssen, sind:
Authentifizierung
Wer darf mit dem Agenten interagieren?
Berechtigungen
Welche Ressourcen darf der Agent nutzen?
Eingabenvalidierung
Welche Arten von Eingaben dürfen Benutzer übermitteln?
Tool-Berechtigungen
Welche Funktionen kann der Agent tatsächlich ausführen?
Datenschutz
Welche sensiblen Daten könnte der Agent ausgesetzt sein?
Protokollierung
Was hat der Agent eigentlich Schritt für Schritt getan?
Menschliche Freigabe
Welche Aktionen benötigen eine Genehmigung durch einen Menschen, bevor sie ausgeführt werden?
Diese Bedenken werden umso wichtiger, je mehr Fähigkeiten die Agenten erlangen.
Der Agent-Stack
Einen KI-Agenten kann man auch als schichtbasierten Technologiestack betrachten:
┌──────────────────────────────┐
│ USER / GOAL │
├──────────────────────────────┤
│ AGENT LOGIC │
├──────────────────────────────┤
│ AI MODEL / LLM │
├──────────────────────────────┤
│ TOOLS & FUNCTIONS │
├──────────────────────────────┤
│ MEMORY & STATE │
├──────────────────────────────┤
│ KNOWLEDGE / RAG │
├──────────────────────────────┤
│ APIs & DATABASES │
├──────────────────────────────┤
│ SECURITY / GUARDRAILS / LOGS │
└──────────────────────────────┘
Jede Schicht erfüllt ihre eigene Funktion.
Ein Verständnis für diese Schichten macht das Entwerfen und Debuggen von Agenten deutlich übersichtlicher.
Das Denkmodell für Anfänger
Wenn Sie mit Agenten beginnen, behalten Sie diese sechs Fragen im Hinterkopf:
1. Was ist das Ziel?
Welches Ergebnis soll das System liefern?
2. Was muss das Modell verstehen?
Welche Anweisungen und welchen Kontext benötigt es, um die Aufgabe zu erledigen?
3. Welche Tools stehen zur Verfügung?
Welche externen Ressourcen kann es nutzen?
4. Welche Informationen benötigt es?
Woher stammt eigentlich sein Wissen?
5. Welche Aktionen kann es durchführen?
Was ist ihm tatsächlich erlaubt?
6. Was passiert, wenn etwas schiefgeht?
Wie reagiert das System, wenn etwas nicht funktioniert?
Fähig zu sein, diese sechs Fragen zu beantworten, bedeutet bereits, dass man wie jemand denkt, der Agenten entwickelt.
Ihre praktische Übung
Vor dem Weitermachen versuchen Sie, ein Entwurf für einen Agenten auf Papier zu skizzieren.
Wählen Sie ein Szenario, zum Beispiel:
KI-Lernassistent
Dann erarbeiten Sie:
Ziel:
Schüler bei der Verständnis ihrer Lernmaterialien zu unterstützen.
Modell:
Ein Sprachmodell.
Tools:
Ein Dokumentenleser und ein Rechner.
Wissen:
Die Kursmaterialien selbst.
Gedächtnis:
Die aktuelle Lernsitzung.
Aktionen:
Erstellung von Erklärungen und Generierung von Übungsaufgaben.
Richtlinien:
Fabrizieren Sie niemals Fakten, wenn die entsprechenden Kursmaterialien nicht verfügbar sind.
Menschliche Überwachung:
Der Student überprüft alles, was der Agent erzeugt.
An diesem Punkt haben Sie eine funktionierende Agent-Architektur skizziert.
Was kommt in Teil 3?
Sobald die Architektur vorliegt, besteht der nächste Schritt darin, sie in funktionierenden Code umzuwandeln.
Teil 3 behandelt den Aufbau Ihres ersten einfachen KI-Agenten mit Python.
Sie wechseln von Diagrammen und Theorie zur tatsächlichen Umsetzung und lernen, wie man ein Agentenprojekt in Betrieb nimmt, Python mit einem Sprachmodell verbindet, ein klares Ziel für den Agenten festlegt, ein grundlegendes Werkzeug dafür erstellt, es vom Agenten aufrufen lässt, mit dem Ergebnis des Werkzeugs arbeitet und schließlich eine fertige Antwort erzeugt.
Die erste Version wird absichtlich minimal gehalten.
Ziel in dieser Phase ist es, zu verstehen wie die einzelnen Komponenten zusammenpassen, nicht sofort ein voll ausgereiftes Produktionsystem zu liefern.
Zusammenfassung
Ein KI-Agent ist mehr als nur ein Chatbot mit neuem Etikett.
Es handelt sich um ein System, das um ein Ziel herum aufgebaut ist und über die Mittel verfügt, mit Informationen zu arbeiten und durch Werkzeuge zu handeln.
In seinem Kern lässt sich die Architektur auf Folgendes reduzieren:
Ziel → Modell → Entscheidung → Werkzeug → Beobachtung → Nächste Aktion → Ergebnis
Rund um diesen Kern fügen Sie hinzu:
Gedächtnis + Wissen + Sicherheit + Schutzmechanismen + Menschliche Überwachung
Sobald all diese Elemente zusammenpassen, wirkt künstliche Intelligenz in agierender Form nicht mehr wie Magie.
Dann wird es zu einer gewöhnlichen Herausforderung im Softwareengineering.
Und genau diese Art von Herausforderung kann Python hervorragend bewältigen.
Nun wissen Sie, was KI-Agenten sind und wie sie funktionieren.
Der nächste Schritt ist es, selbst einen zu erstellen.
Verwandte Artikel
- Verständnis von KI-Agenten: Ziele, Werkzeuge, Gedächtnis und der Agent-Zyklus — Eine für Anfänger geeignete Erklärung, wie sich KI-Agenten von Chatbots unterscheiden, mit Informationen zu den Kernkomponenten, dem Entscheidungszyklus, den Autonomiegraden und praktischen Anwendungsfällen.