Erste Schritte mit Smolagents: Entwickeln Sie Ihren eigenen Code-Agenten in 15 Minuten

Ein AI-Wetteragent in 40 Zeilen Python erstellen, unter Verwendung der Smolagents-Bibliothek von Hugging Face. Lernen Sie, wie Sie Werkzeuge erstellen, LLMs verbinden und autonome Aufgaben ausführen.

Von Shittu Olumide, Technischer Content-Spezialist, am 26. März 2026 im Bereich Künstliche Intelligenz

Einleitung

Künstliche Intelligenz hat sich von einfachen Konversationen mit großen Sprachmodellen (LLMs) weiterentwickelt und ermöglicht es diesen, in der digitalen Welt aktiv zu werden. Diese Programme werden oft als Python-AI-Agenten bezeichnet – autonome Softwareprogramme, die von LLMs betrieben werden und in der Lage sind, ihre Umgebung wahrzunehmen, Entscheidungen zu treffen, externe Werkzeuge (wie APIs oder Codeausführungen) zu nutzen und Maßnahmen zu ergreifen, um spezifische Ziele zu erreichen, ohne ständige menschliche Intervention.

Wenn Sie schon immer mit dem Bau Ihres eigenen AI-Agenten experimentieren wollten, sich jedoch von komplexen Frameworks überwältigt fühlten, sind Sie hier genau richtig. Heute werfen wir einen Blick auf Smolagents, eine leistungsstarke und gleichzeitig äußerst einfache Bibliothek, die von Hugging Face entwickelt wurde.

Am Ende dieses Artikels werden Sie verstehen, was Smolagents einzigartig macht, und noch wichtiger, Sie werden einen funktionierenden Code-Agenten haben, der in der Lage ist, Live-Daten aus dem Internet abzurufen. Lassen Sie uns die Implementierung erkunden.

Verständnis von Code-Agenten

Bevor wir mit dem Programmieren beginnen, lassen Sie uns das Konzept verstehen. Ein Agent ist im Wesentlichen ein LLM, das mit Werkzeugen ausgestattet ist. Sie geben dem Modell ein Ziel (wie „Holen Sie sich das aktuelle Wetter in London“), und es entscheidet, welche Werkzeuge es verwenden muss, um dieses Ziel zu erreichen.

Was die Hugging Face-Agenten in der Smolagents-Bibliothek besonders macht, ist ihr Ansatz zur Argumentation. Im Gegensatz zu vielen Frameworks, die JSON oder Text generieren, um zu entscheiden, welches Werkzeug verwendet werden soll, sind Smolagents-Agenten Code-Agenten. Das bedeutet, dass sie Python-Code-Snippets schreiben, um ihre Werkzeuge und Logik miteinander zu verknüpfen.

Dies ist mächtig, da Code präzise ist. Es ist der natürlichste Weg, komplexe Anweisungen wie Schleifen, Bedingungen und Datenmanipulation auszudrücken. Anstatt dass das LLM rät, wie es Werkzeuge kombinieren soll, schreibt es einfach das Python-Skript, um dies zu tun. Als Open-Source-Agent-Framework ist Smolagents transparent, leichtgewichtig und perfekt, um die Grundlagen zu erlernen. Wenn Sie mehr über die Optimierung von KI-Agenten erfahren möchten, lesen Sie Fünf effektive Python-Dekoratoren zur Optimierung von KI-Agenten.

Voraussetzungen

Um mitzumachen, benötigen Sie:

• Kenntnisse in Python. Sie sollten mit Variablen, Funktionen und pip-Installationen vertraut sein.
• Ein Hugging Face-Token. Da wir das Hugging Face-Ökosystem nutzen, verwenden wir deren kostenlose Inferenz-API. Sie können ein Token erhalten, indem Sie sich auf huggingface.co anmelden und Ihre Einstellungen aufrufen.
• Ein Google-Konto ist optional. Wenn Sie nichts lokal installieren möchten, können Sie diesen Code in einem Google Colab-Notebook ausführen.

Einrichten Ihrer Umgebung

Bereiten wir unseren Arbeitsbereich vor. Öffnen Sie Ihr Terminal oder ein neues Colab-Notebook und installieren Sie die Bibliothek.

mkdir demo-project
cd demo-project

Als Nächstes richten wir unser Sicherheitstoken ein. Es ist am besten, dies als Umgebungsvariable zu speichern. Wenn Sie Google Colab verwenden, können Sie die Registerkarte „Secrets“ im linken Bereich verwenden, um HF_TOKEN hinzuzufügen und dann über userdata.get(‚HF_TOKEN‘) darauf zuzugreifen.

Erstellen Ihres ersten Agenten: Der Wetterabrufer

Für unser erstes Projekt werden wir einen Agenten erstellen, der Wetterdaten für eine bestimmte Stadt abrufen kann. Dazu benötigt der Agent ein Werkzeug. Ein Werkzeug ist einfach eine Funktion, die das LLM aufrufen kann. Wir werden eine kostenlose, öffentliche API namens wttr.in verwenden, die Wetterdaten im JSON-Format bereitstellt.

Installation und Einrichtung

Erstellen Sie eine virtuelle Umgebung:

python -m venv env

Eine virtuelle Umgebung isoliert die Abhängigkeiten Ihres Projekts von Ihrem System. Aktivieren Sie nun die virtuelle Umgebung.

Windows:
env\Scripts\activate

macOS/Linux:
source env/bin/activate

Sie werden (env) in Ihrem Terminal sehen, wenn sie aktiv ist.

Installieren Sie die erforderlichen Pakete:

pip install smolagents requests python-dotenv

Wir installieren Smolagents, das leichtgewichtige Agenten-Framework von Hugging Face zum Erstellen von AI-Agenten mit Werkzeugnutzungsfähigkeiten; Requests, die HTTP-Bibliothek zum Durchführen von API-Aufrufen; und python-dotenv, das Umgebungsvariablen aus einer .env-Datei lädt.

Das war’s – alles mit nur einem Befehl. Diese Einfachheit ist ein zentraler Bestandteil der Philosophie von Smolagents.

Einrichten Ihres API-Tokens

Erstellen Sie eine .env-Datei im Stammverzeichnis Ihres Projekts und fügen Sie diesen Code ein. Bitte ersetzen Sie den Platzhalter durch Ihr tatsächliches Token:

HF_TOKEN=your_huggingface_token_here

Holen Sie sich Ihr Token von huggingface.co/settings/tokens. Ihre Projektstruktur sollte folgendermaßen aussehen:

Importieren von Bibliotheken

Öffnen Sie Ihre demo.py-Datei und fügen Sie den folgenden Code ein:

import requests
import os
from smolagents import tool, CodeAgent, InferenceClientModel

Requests: Für HTTP-Anfragen an die Wetter-API
Os: Um Umgebungsvariablen sicher zu lesen
Smolagents: Das leichtgewichtige Agenten-Framework von Hugging Face, das Folgendes bereitstellt:

• @tool: Ein Dekorator zur Definition von agentenaufrufbaren Funktionen.
• CodeAgent: Ein Agent, der Python-Code schreibt und ausführt.
• InferenceClientModel: Verbindet sich mit den gehosteten LLMs von Hugging Face.

In Smolagents ist die Definition eines Werkzeugs unkompliziert. Wir werden eine Funktion erstellen, die einen Stadtnamen als Eingabe erhält und die Wetterbedingungen zurückgibt. Fügen Sie den folgenden Code zu Ihrer demo.py-Datei hinzu:

@tool
def get_weather(city: str) -> str:
 """
 Gibt die aktuelle Wettervorhersage für eine bestimmte Stadt zurück.
 Args:
 city: Der Name der Stadt, für die das Wetter abgerufen werden soll.
 """
 # Verwendung von wttr.in, einem tollen kostenlosen Wetterdienst
 response = requests.get(f"https://wttr.in/{city}?format=%C+%t")
 if response.status_code == 200:
 # Die Antwort ist einfacher Text wie "Teilweise bewölkt +15°C"
 return f"Das Wetter in {city} ist: {response.text.strip()}"
 else:
 return "Entschuldigung, ich konnte die Wetterdaten nicht abrufen."

Lasst uns das aufschlüsseln:

• Wir importieren den Tool-Dekorator von Smolagents. Dieser Dekorator verwandelt unsere reguläre Python-Funktion in ein Werkzeug, das der Agent verstehen und verwenden kann.
• Die Docstring („““ … „““) in der Funktion get_weather ist entscheidend. Der Agent liest diese Beschreibung, um zu verstehen, was das Werkzeug tut und wie es verwendet wird.
• Innerhalb der Funktion führen wir eine einfache HTTP-Anfrage an wttr.in durch, einen kostenlosen Wetterdienst, der einfache Textvorhersagen zurückgibt.
• Typanmerkungen (city: str) geben dem Agenten an, welche Eingaben bereitgestellt werden sollen.

Dies ist ein perfektes Beispiel für das Werkzeugaufrufen in Aktion. Wir geben dem Agenten eine neue Fähigkeit.

Konfigurieren des LLM

hf_token = os.getenv("HF_TOKEN")
if hf_token is None:
 raise ValueError("Bitte setzen Sie die Umgebungsvariable HF_TOKEN")
model = InferenceClientModel(
 model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
 token=hf_token
)

Der Agent benötigt ein Gehirn – ein großes Sprachmodell (LLM), das in der Lage ist, über Aufgaben nachzudenken. Hier verwenden wir:

• Qwen2.5-Coder-32B-Instruct: Ein leistungsstarkes, auf Code fokussiertes Modell, das auf Hugging Face gehostet wird.
• HF_TOKEN: Ihr Hugging Face-API-Token, das in einer .env-Datei zur Sicherheit gespeichert ist.

Jetzt müssen wir den Agenten selbst erstellen.

agent = CodeAgent(
 tools=[get_weather],
 model=model,
 add_base_tools=False
)

CodeAgent ist ein spezieller Agent-Typ, der:

• Python-Code schreibt, um Probleme zu lösen.
• Diesen Code in einer isolierten Umgebung ausführt.
• Mehrere Werkzeugaufrufe miteinander verknüpfen kann.

Hier instanziieren wir einen CodeAgent. Wir übergeben ihm eine Liste, die unser get_weather-Werkzeug und das Modellobjekt enthält. Das Argument add_base_tools=False sagt ihm, dass keine Standardwerkzeuge einbezogen werden sollen, um unseren Agenten vorerst einfach zu halten.

Ausführen des Agenten

Dies ist der spannende Teil. Lassen Sie uns unserem Agenten eine Aufgabe geben. Führen Sie den Agenten mit einem spezifischen Prompt aus:

response = agent.run(
 "Kannst du mir das Wetter in Paris und auch in Tokio sagen?"
)
print(response)

Wenn Sie agent.run() aufrufen, führt der Agent folgende Schritte aus:

• Er liest Ihren Prompt.
• Er überlegt, welche Werkzeuge er benötigt.
• Er generiert Code, der get_weather(„Paris“) und get_weather(„Tokio“) aufruft.
• Er führt den Code aus und gibt die Ergebnisse zurück.

Wenn Sie diesen Code ausführen, werden Sie die Magie eines Hugging Face-Agenten erleben. Der Agent erhält Ihre Anfrage. Er sieht, dass er ein Werkzeug namens get_weather hat. Dann schreibt er ein kleines Python-Skript in seinem „Geist“ (unter Verwendung des LLM), das ungefähr so aussieht:

weather_paris = get_weather(city="Paris")
weather_tokyo = get_weather(city="Tokio")
final_answer(f"Hier ist das Wetter: {weather_paris} und {weather_tokyo}")

Er führt diesen Code aus, ruft die Daten ab und gibt eine freundliche Antwort zurück. Sie haben gerade einen Code-Agenten erstellt, der über APIs im Internet browsen kann.

Wie es im Hintergrund funktioniert

Die inneren Abläufe eines AI-Code-Agenten

Den Agenten erweitern: Weitere Werkzeuge hinzufügen

Die Kraft von Agenten wächst mit ihrem Werkzeugkasten. Was wäre, wenn wir den Wetterbericht in einer Datei speichern wollten? Wir können ein weiteres Werkzeug erstellen.

@tool
def save_to_file(content: str, filename: str = "weather_report.txt") -> str:
 """
 Speichert den bereitgestellten Textinhalt in einer Datei.
 Args:
 content: Der Textinhalt, der gespeichert werden soll.
 filename: Der Name der Datei, in die gespeichert werden soll (Standard: weather_report.txt).
 """
 with open(filename, "w") as f:
 f.write(content)
 return f"Inhalt erfolgreich in {filename} gespeichert"

Jetzt initialisieren wir den Agenten mit beiden Werkzeugen:

agent = CodeAgent(
 tools=[get_weather, save_to_file],
 model=model,
)

Führen Sie den Agenten mit folgendem Befehl aus:

agent.run("Holen Sie das Wetter für London und speichern Sie den Bericht in einer Datei namens london_weather.txt")

Jetzt kann Ihr Agent Daten abrufen und mit Ihrem lokalen Dateisystem interagieren. Diese Kombination von Fähigkeiten macht Python-AI-Agenten so vielseitig. Wenn Sie mehr über die besten AI-Agenten-Frameworks erfahren möchten, schauen Sie sich Top 7 AI Agent Orchestration Frameworks an.

Fazit

In nur wenigen Minuten und mit weniger als 20 Zeilen Kernlogik haben Sie einen funktionalen AI-Agenten erstellt. Wir haben gesehen, wie Smolagents den Prozess der Erstellung von Code-Agenten vereinfacht, die Python schreiben und ausführen, um Probleme zu lösen.

Die Schönheit dieses Open-Source-Agenten-Frameworks liegt darin, dass es den Boilerplate-Code entfernt, sodass Sie sich auf den spaßigen Teil konzentrieren können: das Erstellen der Werkzeuge und das Definieren der Aufgaben. Sie führen nicht mehr nur Gespräche mit einer KI; Sie arbeiten mit einer zusammen, die handeln kann. Dies ist erst der Anfang. Sie können nun erkunden, wie Sie Ihrem Agenten Zugriff auf das Internet über Such-APIs geben, ihn mit einer Datenbank verbinden oder ihm erlauben, einen Webbrowser zu steuern. Wenn Sie mehr über die Optimierung von OpenAI Codex erfahren möchten, lesen Sie Fünf Strategien zur Optimierung von OpenAI Codex als effektiven Programmieragenten.

Referenzen und Lernressourcen

• Offizielle Dokumentation: Der beste Ort, um alle Fähigkeiten zu verstehen, ist die Hugging Face Smolagents-Dokumentation.
• Quellcode: Für Neugierige ist die gesamte Bibliothek Open Source. Sie können die internen Abläufe im Hugging Face Smolagents GitHub-Repository einsehen.
• Gemeinschaft: Besuchen Sie die Hugging Face-Foren, um zu sehen, was andere entwickeln.

Shittu Olumide ist Software-Ingenieur und technischer Autor, der leidenschaftlich daran interessiert ist, modernste Technologien zu nutzen, um fesselnde Erzählungen zu gestalten, mit einem scharfen Blick für Details und einem Talent dafür, komplexe Konzepte zu vereinfachen. Sie können Shittu auch auf Twitter finden.

Erhalten Sie das KOSTENLOSE E-Book ‚KDnuggets Artificial Intelligence Pocket Dictionary‘ zusammen mit dem führenden Newsletter zu Data Science, Machine Learning, AI & Analytics direkt in Ihr Postfach.

Durch das Abonnieren akzeptieren Sie die Datenschutzrichtlinie von KDnuggets.

„`

Bildquelle: ai-generated-gemini