Ich habe einen KI-Agenten von Grund auf neu erstellt, so geht’s.

Hey du, angehender Agent! Emma hier von agent101.net, und heute widmen wir uns einer Frage, die in letzter Zeit mehr als gewöhnlich in meinen DMs auftaucht: „Okay, Emma, ich verstehe den Hype, aber wie baue ich tatsächlich einen dieser AI-Agenten, von denen alle reden? Also, von Grund auf, ohne eine Promotion in Informatik zu brauchen?„

Glaub mir, ich habe das selbst durchgemacht. Noch nicht lange her, fühlte sich die Idee eines AI-Agenten wie etwas aus einem Science-Fiction-Film an – cool, futuristisch, aber völlig unerreichbar für eine normale Person wie mich, die einfach nur einige nervige Aufgaben automatisieren oder etwas wirklich Nützliches bauen möchte. Aber weißt du was? Es ist nicht so. Die Einstiegshürde ist drastisch gefallen, und mit ein wenig Anleitung (und vielleicht ein paar nächtlichen Kaffeepausen, wenn du wie ich bist) kannst du absolut deinen ersten AI-Agenten bauen. Und genau das machen wir heute.

Vergiss die allgemeinen Überblicke. Wir werden die praktischen Details erforschen, um einen bestimmten Typ von AI-Agent zu bauen: einen einfachen, auf Aufgaben orientierten Agenten, der mit einer Web-API interagieren kann, um Informationen abzurufen. Sieh ihn als deinen persönlichen Datenretriever, aber mit einem Gehirn (einem kleinen, vorerst!). Konkret werden wir einen Agenten bauen, der das aktuelle Wetter für eine gegebene Stadt anhand einer kostenlosen Wetter-API abruft. Warum Wetter? Weil es ein häufiger, leicht verständlicher Anwendungsfall mit leicht verfügbaren APIs ist, perfekt für unsere Anfängerreise.

Mein erster „Aha!“-Moment mit Agenten

Ich erinnere mich an meinen eigenen „Aha!“-Moment. Es war kein großes Projekt; es ging darum, den Prozess zu automatisieren, um herauszufinden, ob mein Lieblingscafé an einem Feiertag geöffnet hatte. Manuell auf deren Website nachzusehen, dann auf Instagram, dann in ihrem Google-Maps-Eintrag zu suchen, fühlte sich wie eine monumentale Anstrengung an. Ich dachte: „Es *muss* einen besseren Weg geben.“ Das war der Moment, als ich anfing, mit einfachem Skripting zu experimentieren und schließlich in die Welt der AI-Agenten stolperte. Die Idee eines autonomen Softwareteils, der meine Absicht *verstehen* konnte („Ist das Coffee Oasis offen?“) und *handeln* konnte (mehrere Quellen überprüfen, die Info zusammenfassen, mir die Antwort sagen) war überwältigend. Es ist ein grundlegender Wandel vom Schreiben eines Skripts hin zu einem Programm, das sinnvoll denken und entscheiden kann.

Lasst uns also dieses Gefühl nachahmen, auch wenn unser erster Agent etwas einfacher ist. Wir haben das Ziel, die Grundkomponenten zu verstehen, und nicht Skynet zu bauen.

Was meinen wir hier eigentlich mit „AI-Agent“?

Bevor wir mit dem Code loslegen, lass uns das klären. Wenn ich von einem „Anfänger-AI-Agenten“ spreche, meine ich ein Programm, das:

• **Wahrnimmt:** Es nimmt Eingaben (wie deine Anfrage: „Wie ist das Wetter in London?“) entgegen.
• **Denkt/Überlegt (einfach):** Es verarbeitet diese Eingabe, um zu verstehen, was zu tun ist.
• **Handelt:** Es führt eine Aktion basierend auf seiner Überlegung 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 früheren Interaktionen speichern oder sich anpassen.

Für unseren Wetteragenten wird der „denkende“ Teil einfach sein: den Städtenamen zu identifizieren. Der „handelnde“ Teil wird darin bestehen, eine API-Anfrage zu stellen. Einfach, aber effektiv!

Die Werkzeuge, die wir benötigen (Keine Panik, sie sind kostenlos!)

Du benötigst keine teure, ausgeklügelte Software. Hier ist unser minimales Werkzeugset:

• **Python:** Unsere Programmiersprache der Wahl. Sie ist anfängerfreundlich und hat hervorragende Bibliotheken für alles, was wir brauchen. Stelle sicher, dass du Python 3 installiert hast.
• **Ein Texteditor:** VS Code, Sublime Text, Atom oder sogar Notepad++ tun es.
• **Requests-Bibliothek:** Eine Python-Bibliothek für HTTP-Anfragen (so kommunizieren wir mit der Wetter-API).
• **Ein kostenloser Wetter-API-Schlüssel:** Wir verwenden OpenWeatherMap, weil es super einfach ist, damit zu starten.

So bekommst du deinen OpenWeatherMap API-Schlüssel

Das ist wichtig. Gehe zur API-Seite von OpenWeatherMap. Du musst ein kostenloses Konto erstellen. Nachdem du dich angemeldet hast, gehe zum Tab „API-Schlüssel“. Dort siehst du deinen Standard-API-Schlüssel. Schreib ihn auf; wir brauchen ihn bald.

**Profi-Tipp:** API-Schlüssel sind wie Passwörter. Teile sie nicht öffentlich! Und für echte Projekte solltest du sie in Umgebungsvariablen speichern, nicht direkt im Code. Aber für dieses Anfänger-Tutorial ist es in Ordnung, sie für einen Moment direkt im Skript zu verwenden, solange du die Sicherheitsimplikationen verstehst.

Schritt-für-Schritt: Bau unseres Wetteragenten

Okay, lass uns anpacken!

1. Richte dein Projekt ein

Erstelle einen neuen Ordner für dein Projekt, sagen wir `my_weather_agent`. In diesem Ordner erstellst du eine neue Python-Datei, wie `weather_agent.py`.

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

pip install requests

2. Die Kernkomponenten: Funktionen!

Unser Agent benötigt ein paar wichtige Funktionen:

• Eine zum Abrufen der Wetterdaten von der API.
• Eine zum Verarbeiten der Benutzereingabe.
• Eine, um alles zusammenzufügen.

3. Schreiben der API-Interaktionsfunktion

Diese Funktion nimmt einen Städtenamen und deinen API-Schlüssel, macht die Anfrage an OpenWeatherMap und gibt die Rohdaten zurück.

import requests

# --- WICHTIG: Ersetze dies mit deinem 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 Rohwetterdaten für eine gegebene Stadt von OpenWeatherMap ab.
 """
 params = {
 "q": city_name,
 "appid": API_KEY,
 "units": "metric" # Du kannst zu "imperial" für Fahrenheit wechseln
 }
 try:
 response = requests.get(BASE_URL, params=params)
 response.raise_for_status() # Wirft einen HTTPError für fehlerhafte 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"Fehler bei der Verbindung: {errc}")
 return None
 except requests.exceptions.Timeout as errt:
 print(f"Zeitüberschreitungsfehler: {errt}")
 return None
 except requests.exceptions.RequestException as err:
 print(f"Ein unerwarteter Fehler ist aufgetreten: {err}")
 return None

**Denk daran, `YOUR_OPENWEATHERMAP_API_KEY` durch den tatsächlichen Schlüssel zu ersetzen, den du kopiert hast!**

4. Verarbeiten und Anzeigen des Wetters

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

def display_weather(weather_data):
 """
 Analysiert und zeigt relevante 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 (fühlt sich an wie {feels_like}°C)")
 print(f"Bedingungen: {description.capitalize()}")
 print(f"Luftfeuchtigkeit: {humidity}%")
 print(f"Windspeed: {wind_speed} m/s")
 print("-------------------------------\n")
 elif weather_data and weather_data.get("cod") == "404":
 print(f"Leider konnte das Wetter für diese Stadt nicht gefunden werden. Bitte überprüfe die Rechtschreibung.")
 else:
 print("Konnte keine Wetterinformationen abrufen. Bitte versuche es später noch einmal.")

5. Der „Verstand“ des Agenten – alles zusammenfügen

Hier kommt unser einfacher Agentenloop ins Spiel. Er wird den Benutzer auffordern, unsere Funktionen aufrufen und weitermachen, bis der Benutzer beschließt, aufzuhören.

def run_weather_agent():
 """
 Hauptschleife für unseren einfachen Wetteragenten.
 """
 print("Willkommen bei deinem einfachen Wetteragenten!")
 print("Gib 'quit' oder 'exit' ein, um jederzeit aufzuhören.")

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

 if user_input.lower() in ["quit", "exit"]:
 print("Auf Wiedersehen! Bleib wetterbewusst!")
 break

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

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

6. Führe deinen Agenten aus!

Zum Schluss müssen wir unsere `run_weather_agent()`-Funktion aufrufen, um zu starten. Füge diese Zeile ganz am Ende deiner `weather_agent.py`-Datei hinzu:

if __name__ == "__main__":
 run_weather_agent()

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

python weather_agent.py

Du solltest ein Eingabeaufforderung sehen, die nach einem Städtenamen fragt! Probiere „London“, „Tokyo“, „New York“ oder sogar einen Tippfehler, um zu sehen, wie die Fehlerbehandlung funktioniert. Das ist es – dein erster AI-Agent, der eine Aufgabe autonom ausführt!

Über die Grundlagen hinaus: Wie dies mit komplexeren Agenten verbunden ist

Du denkst vielleicht: „Okay, Emma, das ist cool, aber das ist nicht gerade Jarvis, oder?“ Und damit hättest du recht! Aber dieser einfache Wetteragent demonstriert die grundlegende Schleife, der sogar die komplexesten AI-Agenten folgen:

• **Wahrnehmung:** Unser Agent nimmt Ihre Eingabe (den Städtenamen) wahr. In fortgeschritteneren Agenten könnte dies die Interpretation natürlicher Sprache, das Auslesen von Daten von Sensoren oder die Analyse großer Datensätze umfassen.
• **Schlussfolgerung/Planung:** Die „Schlussfolgerung“ unseres Agents ist einfach: „Wenn ich einen Städtenamen bekomme, rufe die Wetter-API auf.“ Komplexere Agenten verwenden ausgefeilte Modelle (wie große Sprachmodelle – LLMs), um Absichten zu verstehen, komplexe Aufgaben in Unteraufgaben zu zerlegen und geeignete Werkzeuge auszuwählen.
• **Aktion:** Die Aktion unseres Agents besteht darin, eine HTTP-Anfrage an eine API zu senden. Fortgeschrittene Agenten könnten mit Datenbanken interagieren, E-Mails senden, Roboter steuern oder kreative Inhalte generieren.
• **Feedback/Lernen (implizit hier):** Wenn der Städtename falsch ist, gibt unsere `display_weather`-Funktion Feedback. Bei fortgeschrittenen Agenten ist diese Feedback-Schleife explizit, was dem Agenten ermöglicht, seine Strategien im Laufe der Zeit zu verfeinern oder neue Fähigkeiten zu erlernen.

Meine eigene Reise begann mit diesen kleinen, funktionalen Skripten. Erst als ich verstand, wie man diese Bausteine verbindet, konnte ich mir ambitioniertere Projekte vorstellen. Dieser Wetteragent ist Ihr erster Schritt auf diesem Weg!

Umsetzbare Erkenntnisse für Ihre Agentenreise

Also, Sie haben Ihren ersten Agenten gebaut. Was kommt als Nächstes?

1. **Experimentieren!** Ändern Sie den Parameter `units` in `get_weather_data` auf „imperial“. Fügen Sie der Anzeige mehr Wetterdetails hinzu. Was passiert, wenn Sie versuchen, Wetter für eine nicht existierende Stadt abzurufen?
2. **Andere APIs erkunden:** Das Web ist voll von kostenlosen APIs! Denken Sie an einen einfachen Agenten, der Filminformationen von OMDB, Nachrichtenüberschriften von NewsAPI oder sogar Witze von einer Witze-API abruft. Jede neue API ist ein neues „Werkzeug“, das Ihr Agent lernen kann zu verwenden.
3. **Über Absichten nachdenken:** Unser Agent versteht nur „Städtename“. Wie würden Sie ihn ändern, um etwas wie „Wie ist das Wetter für meine Reise nach Paris nächste Woche?“ zu verstehen? Hier kommt das Parsen natürlicher Sprache und die Integration mit einem LLM ins Spiel – ein großer Sprung, aber einen, den Sie jetzt zu konzipieren beginnen können.
4. **Fehlerbehandlung ist Ihr Freund:** Bemerkten Sie all diese `try…except`-Blöcke? Sie sind entscheidend. Systeme in der realen Welt fallen aus, und ein guter Agent antizipiert diese Fehler und geht elegant damit um.
5. **Haben Sie keine Angst, Dinge zu zerbrechen:** Ernsthaft, so lernen Sie. Ändern Sie etwas, sehen Sie, was passiert, beheben Sie es. Wiederholen.

Das Erstellen von KI-Agenten mag anfangs entmutigend erscheinen, aber indem Sie mit praktischen, kleinen Projekten wie diesem Wetteragenten beginnen, legen Sie ein solides Fundament. Sie lernen den grundlegenden Zyklus Wahrnehmen-Schlussfolgern-Handeln, der allen intelligenten Systemen zugrunde liegt. Und vertrauen Sie mir, sobald Sie diesen ersten Agenten zum Laufen bringen, werden Sie überall Möglichkeiten sehen. Viel Spaß beim Agentenbauen!

🕒 Published: March 29, 2026