Ich habe einen KI-Agenten von Grund auf neu gebaut, hier ist wie.

Hallo, angehender Agent! Emma hier von agent101.net, und heute werden wir eine Frage behandeln, die in meinen privaten Nachrichten mehr Lärm macht als gewöhnlich: „Okay, Emma, ich verstehe die Aufregung, aber wie *baue* ich tatsächlich einen von diesen KI-Agenten, von denen alle sprechen? Wie, von Anfang an, ohne einen Doktortitel in Informatik zu brauchen?“

Vertrau mir, ich habe das durchgemacht. Noch vor nicht allzu langer Zeit schien die Idee eines KI-Agenten direkt aus einem Science-Fiction-Film zu stammen – cool, futuristisch, aber völlig unerreichbar für eine gewöhnliche Person wie mich, die nur ein paar langweilige Aufgaben automatisieren oder etwas wirklich Nützliches aufbauen möchte. Aber rate mal? Das ist nicht der Fall. Die Eintrittsbarriere ist erheblich gesunken, und mit ein wenig Anleitung (und vielleicht ein paar nächtlichen Kaffeepausen, wenn du wie ich bist) kannst du absolut deinen ersten KI-Agenten bauen. Und genau das werden wir heute tun.

Vergiss die allgemeinen Anblicke. Wir werden die praktische Seite des Bauens einer spezifischen Art von KI-Agenten erkunden: einen einfachen und auf Aufgaben orientierten Agenten, der mit einer Web-API interagieren kann, um Informationen abzurufen. Denk daran als deinen persönlichen Datenabruf-Agenten, aber mit einem Gehirn (ein kleines, vorerst!). Genauer gesagt werden wir einen Agenten erstellen, der das aktuelle Wetter einer bestimmten Stadt mit einer kostenlosen Wetter-API abruft. Warum das Wetter? Weil es ein gemeinsames und leicht verständliches Anwendungsbeispiel mit bereits verfügbaren APIs ist, perfekt für unseren Anfängerweg.

Mein Erster „Aha!“-Moment mit Agenten

Ich erinnere mich an meinen eigenen „Aha!“-Moment. Es war nicht ein großes Projekt; es war der Versuch, den Prozess zu automatisieren, um zu überprüfen, ob mein Lieblingskaffee an einem Feiertag geöffnet hatte. Manuell ihre Website, dann ihr Instagram, dann ihr Google Maps-Eintrag zu überprüfen, schien ein monumentaler Aufwand zu sein. Ich dachte: „Es *muss* einen besseren Weg geben.“ Das war der Moment, als ich anfing, mit einfachen Skripten zu experimentieren, und schließlich in die Welt der KI-Agenten eindrang. Die Vorstellung von einem autonomen Softwarestück, das *verstehen* konnte, was ich wollte („Ist das Coffee Oasis geöffnet?“) und *entsprechend handelt* (mehrere Quellen überprüft, die Informationen synthetisiert und mir die Antwort gegeben), war unglaublich. Es ist ein grundlegender Wechsel von einfach nur ein Skript zu schreiben zu einem Programm, das in der Lage ist, zu denken und Entscheidungen zu treffen.

Also, lass uns dieses Gefühl nachahmen, auch wenn unser erster Agent ein bisschen einfacher ist. Wir streben an, die wesentlichen Komponenten zu verstehen, nicht Skynet zu bauen.

Was Verstehen Wir Unter einem „KI-Agenten“ Hier?

Bevor wir in den Code eintauchen, lass uns klarstellen. Wenn ich von einem „Einsteiger-KI-Agenten“ spreche, meine ich ein Programm, das:

• **Wahrnimmt:** Es nimmt eine Eingabe entgegen (wie deine Anfrage „Wie ist das Wetter in London?“).
• **Denkt/Schlussfolgt (einfach):** Es verarbeitet diese Eingabe, um zu verstehen, was zu tun ist.
• **Handelt:** Es führt eine Aktion basierend auf seinem Schlussfolgerungsprozess aus (wie das Aufrufen einer Wetter-API).
• **Lernt (optional für dieses Anfängerprojekt, aber wichtig für die Zukunft):** Es könnte basierend auf vergangenen Interaktionen speichern oder sich anpassen.

Für unseren Wetteragenten wird der Teil „Denken“ einfach sein: den Namen der Stadt identifizieren. Der Teil „Handeln“ wird das Senden einer Anfrage an die API beinhalten. Einfach, aber effektiv!

Die Werkzeuge, Die Wir Benötigen (Keine Sorge, Sie Sind Kostenlos!)

Du brauchst keine teure und fancy Software. Hier ist unser minimales Werkzeugset:

• **Python:** Unsere Programmiersprache der Wahl. Sie ist Einsteigern zugänglich und hat großartige Bibliotheken für alles, was wir brauchen. Stelle sicher, dass Python 3 installiert ist.
• **Ein Texteditor:** VS Code, Sublime Text, Atom oder sogar Notepad++ werden ausreichen.
• **Requests-Bibliothek:** Eine Python-Bibliothek, um HTTP-Anfragen durchzuführen (so kommunizieren wir mit der Wetter-API).
• **Ein Kostenloser Wetter-API-Schlüssel:** Wir werden OpenWeatherMap verwenden, da es super einfach ist, damit zu beginnen.

So Holst Du Dir Deinen OpenWeatherMap API-Schlüssel

Das ist entscheidend. Gehe zu der API-Seite von OpenWeatherMap. Du musst ein kostenloses Konto erstellen. Sobald du eingeloggt bist, navigiere zum Tab „API-Schlüssel“. Dort wirst du deinen Standard-API-Schlüssel sehen. Notiere ihn dir; wir werden ihn bald brauchen.

**Pro-Tipp:** API-Schlüssel sind wie Passwörter. Teile sie nicht öffentlich! Und für echte Projekte würdest du sie in Umgebungsvariablen speichern, nicht direkt in deinem Code. Aber für dieses Anfänger-Tutorial ist es in Ordnung, sie eine Zeit lang direkt im Skript zu haben, solange du die Sicherheitsimplikationen verstehst.

Schritt-für-Schritt: Baue Deinen Wetteragenten

Okay, lass uns an die Arbeit gehen!

1. Richte Dein Projekt Ein

Erstelle einen neuen Ordner für dein Projekt, nennen wir ihn `mein_wetter_agent`. In diesem Ordner erstelle eine neue Python-Datei, z.B. `wetter_agent.py`.

Öffne dein Terminal oder die Eingabeaufforderung, navigiere zu deinem Projektordner und installiere die `requests`-Bibliothek:

pip install requests

2. Die Wesentlichen Komponenten: Funktionen!

Unser Agent benötigt einige zentrale Funktionen:

• Eine für das Abrufen der Wetterdaten von der API.
• Eine für die Verarbeitung der Benutzereingabe.
• Eine um alles zusammenzubringen.

3. Schreibe die Funktion für die Interaktion mit der API

Diese Funktion wird einen Städtenamen und deinen API-Schlüssel entgegennehmen, dann die Anfrage an OpenWeatherMap machen und die rohen Daten zurückgeben.

import requests

# --- WICHTIG: Ersetze dies durch deinen echten API-Schlüssel ---
API_KEY = "YOUR_OPENWEATHERMAP_API_KEY" 
BASE_URL = "http://api.openweathermap.org/data/2.5/weather"

def get_weather_data(city_name):
 """
 Ruft die rohen Wetterdaten für eine gegebene Stadt von OpenWeatherMap ab.
 """
 params = {
 "q": city_name,
 "appid": API_KEY,
 "units": "metric" # Du kannst "imperial" für Fahrenheit ändern
 }
 try:
 response = requests.get(BASE_URL, params=params)
 response.raise_for_status() # Wirft eine HTTPError für schlechte Antworten (4xx oder 5xx)
 return response.json()
 except requests.exceptions.HTTPError as errh:
 print(f"HTTP Fehler: {errh}")
 return None
 except requests.exceptions.ConnectionError as errc:
 print(f"Verbindungsfehler: {errc}")
 return None
 except requests.exceptions.Timeout as errt:
 print(f"Timeout-Fehler: {errt}")
 return None
 except requests.exceptions.RequestException as err:
 print(f"Ein unerwarteter Fehler ist aufgetreten: {err}")
 return None

**Vergiss nicht, `”YOUR_OPENWEATHERMAP_API_KEY”` durch den echten Schlüssel zu ersetzen, den du kopiert hast!**

4. Wetterdaten Verarbeiten und Anzeigen

Die rohen JSON-Daten von der API können etwas komplex sein. Lass uns eine Funktion erstellen, um die nützlichen Elemente zu extrahieren und sie schön darzustellen.

def display_weather(weather_data):
 """
 Analysiert und zeigt die relevanten Wetterinformationen an.
 """
 if weather_data and weather_data.get("cod") == 200: # Überprüft, ob die Anfrage erfolgreich war
 city = weather_data["name"]
 country = weather_data["sys"]["country"]
 temp = weather_data["main"]["temp"]
 feels_like = weather_data["main"]["feels_like"]
 description = weather_data["weather"][0]["description"]
 humidity = weather_data["main"]["humidity"]
 wind_speed = weather_data["wind"]["speed"]

 print(f"\n--- Wetter in {city}, {country} ---")
 print(f"Temperatur: {temp}°C (gefühlte Temperatur: {feels_like}°C)")
 print(f"Bedingungen: {description.capitalize()}")
 print(f"Luftfeuchtigkeit: {humidity}%")
 print(f"Windgeschwindigkeit: {wind_speed} m/s")
 print("-------------------------------\n")
 elif weather_data and weather_data.get("cod") == "404":
 print(f"Entschuldigung, die Wetterdaten für diese Stadt konnten nicht gefunden werden. Überprüfe die Schreibweise.")
 else:
 print("Es konnten keine Wetterinformationen abgerufen werden. Bitte versuche es später noch einmal.")

5. Das „Gehirn“ des Agenten – Alles Zusammenbringen

Hier kommt unsere einfache Agentenschleife ins Spiel. Sie fragt den Benutzer, ruft unsere Funktionen auf und läuft weiter, bis der Benutzer beschließt, das Programm zu beenden.

def run_weather_agent():
 """
 Hauptschleife unseres einfachen Wetteragenten.
 """
 print("Willkommen bei deinem einfachen Wetteragenten!")
 print("Gib 'quit' oder 'exit' ein, um jederzeit zu stoppen.")

 while True:
 user_input = input("Gib einen Städtenamen ein, um die Wetterdaten zu erhalten: ").strip()

 if user_input.lower() in ["quit", "exit"]:
 print("Auf Wiedersehen! Bleib auf dem Laufenden über das Wetter!")
 break

 if not user_input:
 print("Bitte gib einen Städtenamen ein.")
 continue

 print(f"Wetterdaten für {user_input} werden abgerufen...")
 weather_data = get_weather_data(user_input)
 display_weather(weather_data)

6. Deinen Agenten Ausführen!

Zum Schluss müssen wir unsere Funktion `run_weather_agent()` aufrufen, um die Dinge ins Rollen zu bringen. Füge diese Zeile ganz am Ende deiner Datei `wetter_agent.py` hinzu:

if __name__ == "__main__":
 run_weather_agent()

Jetzt speichere deine Datei und führe sie von deinem Terminal aus:

python agent_meteo.py

Du solltest eine Eingabeaufforderung sehen, die nach einem Stadtnamen fragt! Versuche es mit “London”, “Tokio”, “New York” oder sogar einem Schreibfehler, um die Fehlerbehandlung zu sehen. Das ist es – dein erster KI-Agent, der eine Aufgabe eigenständig erfüllt!

Über die Grundlagen hinaus: Wie Alles Mit Komplexeren Agenten Verknüpft Ist

Du denkst vielleicht: “Okay, Emma, das ist cool, aber es ist nicht gerade Jarvis, oder?” Und du hättest recht! Aber dieser einfache Wetteragent demonstriert die grundlegende Schleife, die selbst die komplexesten KI-Agenten befolgen:

• **Wahrnehmung:** Unser Agent nimmt deine Eingabe (den Stadtnamen) wahr. Bei fortgeschritteneren Agenten könnte dies die Interpretation natürlicher Sprache, das Auslesen von Daten aus Sensoren oder die Analyse großer Datensätze beinhalten.
• **Rasionsfindung/Planung:** Die „Rasionsfindung“ unseres Agents ist einfach: „Wenn ich einen Stadtnamen bekomme, rufe ich die Wetter-API auf.“ Komplexere Agenten nutzen ausgeklügelte Modelle (wie große Sprachmodelle – LLM), um die Absicht zu verstehen, komplexe Aufgaben in Unteraufgaben zu zerlegen und die passenden Werkzeuge auszuwählen.
• **Aktion:** Die Aktion unseres Agents besteht darin, eine HTTP-Anfrage an eine API zu senden. Fortgeschrittene Agenten können mit Datenbanken interagieren, E-Mails senden, Roboter steuern oder kreative Inhalte generieren.
• **Rückmeldung/Lernen (implizit hier):** Wenn der Stadtnamen falsch ist, gibt unsere Funktion `display_weather` Rückmeldung. Bei fortgeschrittenen Agenten ist diese Rückkopplung explizit und ermöglicht es dem Agenten, seine Strategien zu verfeinern oder über die Zeit neue Fähigkeiten zu erlernen.

Mein eigener Weg begann mit diesen kleinen funktionalen Skripten. Erst nachdem ich verstanden hatte, wie ich diese Bausteine verbinden konnte, konnte ich anfangen, ambitioniertere Projekte zu planen. Dieser Wetteragent ist dein erster Schritt auf diesem Weg!

Praktische Tipps für Deinen Agenten-Weg

Also, du hast deinen ersten Agenten gebaut. Was kommt als Nächstes?

1. **Experimentiere!** Ändere den Parameter `units` in `get_weather_data` auf „imperial“. Füge mehr Wetterdetails zur Anzeige hinzu. Was passiert, wenn du versuchst, das Wetter für eine nicht existierende Stadt abzurufen?
2. **Entdecke andere APIs:** Das Web ist voll von kostenlosen APIs! Denk an einen einfachen Agenten, der Informationen zu Filmen von OMDB abruft, Nachrichtenüberschriften von NewsAPI oder sogar Witze von einer Witz-API. Jede neue API ist ein neues „Werkzeug“, das dein Agent lernen kann zu nutzen.
3. **Denke über die Absicht nach:** Unser Agent versteht nur „Stadtnamen.“ Wie würdest du ihn ändern, um etwas wie „Wie wird das Wetter für meine Reise nach Paris nächste Woche?“ zu verstehen? Hier kommt die Verarbeitung natürlicher Sprache ins Spiel und die Integration mit einem LLM – ein großer Schritt, den du aber schon jetzt anfangen kannst zu konzipieren.
4. **Fehlerbehandlung ist dein Freund:** Siehst du all diese Blöcke `try…except`? Sie sind unerlässlich. Systeme in der realen Welt schlagen fehl, und ein guter Agent antizipiert diese Fehler und geht elegant damit um.
5. **Hab keine Angst, alles kaputt zu machen:** Ehrlich gesagt, so lernst du. Ändere etwas, schau was passiert, behebe es. Spüle und wiederhole.

Die Konstruktion von KI-Agenten kann zu Beginn einschüchternd erscheinen, aber indem du mit praktischen und kleinen Projekten wie diesem Wetteragenten beginnst, legst du ein solides Fundament. Du lernst den grundlegenden Zyklus von Wahrnehmen-Überlegen-Handeln, der allen intelligenten Systemen zugrunde liegt. Und glaub mir, sobald du es geschafft hast, diesen ersten Agenten zum Laufen zu bringen, wirst du überall Möglichkeiten sehen. Viel Spaß beim Entwickeln von Agenten!

🕒 Published: March 29, 2026