Erste Schritte mit Smolagents: Erstellen Sie Ihren ersten Code-Agenten in 15 Minuten

Bild vom Autor

# Einführung

Die KI ist vom bloßen Chatten übergegangen große Sprachmodelle (LLMs) dazu, ihnen Arme und Beine zu geben, die es ihnen ermöglichen, Aktionen in der digitalen Welt auszuführen. Diese werden oft als Python-KI-Agenten bezeichnet – autonome Softwareprogramme, die auf LLMs basieren und ihre Umgebung wahrnehmen, Entscheidungen treffen, externe Instruments (wie APIs oder Codeausführung) verwenden und Maßnahmen ergreifen können, um bestimmte Ziele zu erreichen, ohne dass ständiges menschliches Eingreifen erforderlich ist.

Wenn Sie mit der Entwicklung Ihres eigenen KI-Agenten experimentieren wollten, sich aber durch komplexe Frameworks überfordert fühlten, sind Sie hier richtig. Heute schauen wir uns das an Smolagenzieneine leistungsstarke und dennoch unglaublich einfache Bibliothek, entwickelt von Umarmendes Gesicht.

Am Ende dieses Artikels werden Sie verstehen, was Smolagents einzigartig macht, und was noch wichtiger ist, Sie werden über einen funktionierenden Code-Agenten verfügen, der Reside-Daten aus dem Web abrufen kann. Lassen Sie uns die Implementierung untersuchen.

# Code-Agenten verstehen

Bevor wir mit dem Codieren beginnen, wollen wir das Konzept verstehen. Ein Agent ist im Wesentlichen ein LLM, der mit Werkzeugen ausgestattet ist. Sie geben dem Modell ein Ziel (z. B. „Ermitteln Sie das aktuelle Wetter in London“) und es entscheidet, welche Instruments zum Erreichen dieses Ziels verwendet werden sollen.

Was die Hugging Face-Agenten in der Smolagents-Bibliothek besonders macht, ist ihre Herangehensweise an die Argumentation. Im Gegensatz zu vielen Frameworks, die JSON oder Textual content generieren, um zu entscheiden, welches Device verwendet werden soll, sind Smolagents-Agenten Code-Agenten. Das bedeutet, dass sie Python-Codefragmente schreiben, um ihre Instruments und Logik miteinander zu verketten.

Das ist leistungsstark, weil der Code präzise ist. Dies ist die natürlichste Artwork, komplexe Anweisungen wie Schleifen, Bedingungen und Datenmanipulation auszudrücken. Anstatt zu erraten, wie die Instruments zu kombinieren sind, schreibt der LLM einfach das entsprechende Python-Skript. Als Open-Supply-Agenten-Framework ist smolagents clear, leichtgewichtig und perfekt zum Erlernen der Grundlagen.

// Voraussetzungen

Um mitzumachen, benötigen Sie:

• Python-Kenntnisse. Sie sollten mit Variablen, Funktionen und Pip-Installationen vertraut sein.
• Ein Umarmungsgesicht-Token. Da wir das Hugging Face-Ökosystem nutzen, werden wir deren kostenlose Inferenz-API verwenden. Sie können einen Token erhalten, indem Sie sich anmelden unter Huggingface.co und besuchen Sie Ihre Einstellungen.
• Ein Google-Konto ist elective. Wenn Sie nichts lokal installieren möchten, können Sie diesen Code in a ausführen Google Colab Notizbuch.

# Einrichten Ihrer Umgebung

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

mkdir demo-project
cd demo-project

Als nächstes richten wir unser Sicherheitstoken ein. Am besten speichern Sie dies als Umgebungsvariable. Wenn Sie Google Colab verwenden, können Sie zum Hinzufügen die Registerkarte „Geheimnisse“ im linken Bereich verwenden HF_TOKEN und dann über darauf zugreifen userdata.get('HF_TOKEN').

# Erstellen Sie Ihren ersten Agenten: The Climate Fetcher

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 Device ist lediglich eine Funktion, die das LLM aufrufen kann. Wir werden eine kostenlose, öffentliche API namens verwenden wttr.indas Wetterdaten im JSON-Format bereitstellt.

// Installieren und Einrichten

Erstellen Sie eine virtuelle Umgebung:

Eine virtuelle Umgebung isoliert die Abhängigkeiten Ihres Projekts von Ihrem System. Jetzt aktivieren wir die virtuelle Umgebung.

Home windows:

macOS/Linux:

Du wirst sehen (env) in Ihrem Terminal, wenn aktiv.

Installieren Sie die erforderlichen Pakete:

pip set up smolagents requests python-dotenv

Wir installieren Smolagents, das leichte Agenten-Framework von Hugging Face zum Erstellen von KI-Agenten mit Werkzeugnutzungsfunktionen; Anfragendie HTTP-Bibliothek zum Durchführen von API-Aufrufen; Und python-dotenvwodurch Umgebungsvariablen von a geladen werden .env Datei.

Das ist alles – alles mit nur einem Befehl. Diese Einfachheit ist ein zentraler Bestandteil der Smolagents-Philosophie.

Abbildung 1: Set up von Smolagenten

// Einrichten Ihres API-Tokens

Erstellen Sie eine .env Datei in Ihrem Projektstammverzeichnis 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 Ihren Token von Huggingface.co/settings/tokens. Ihre Projektstruktur sollte wie folgt aussehen:

Abbildung 2: Projektstruktur

// Bibliotheken importieren

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

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

• requests: Für HTTP-Aufrufe an die Wetter-API
• os: Um Umgebungsvariablen sicher zu lesen
• smolagents: Das leichte Agenten-Framework von Hugging Face bietet:
  • @software: Ein Dekorator zum Definieren von durch Agenten aufrufbaren Funktionen.
  • CodeAgent: Ein Agent, der Python-Code schreibt und ausführt.
  • InferenceClientModel: Stellt eine Verbindung zu den gehosteten LLMs von Hugging Face her.

Bei Smolagenzien ist die Definition eines Werkzeugs unkompliziert. Wir erstellen eine Funktion, die den Namen einer Stadt als Eingabe verwendet und die Wetterbedingungen zurückgibt. Fügen Sie den folgenden Code zu Ihrem hinzu demo.py Datei:

@software
def get_weather(metropolis: str) -> str:
    """
    Returns the present climate forecast for a specified metropolis.
    Args:
        metropolis: The identify of town to get the climate for.
    """
    # Utilizing wttr.by which is a beautiful free climate service
    response = requests.get(f"https://wttr.in/{metropolis}?format=%C+%t")
    if response.status_code == 200:
        # The response is obvious textual content like "Partly cloudy +15°C"
        return f"The climate in {metropolis} is: {response.textual content.strip()}"
    else:
        return "Sorry, I could not fetch the climate knowledge."

Lassen Sie uns das aufschlüsseln:

• Wir importieren die software Dekorateur aus Smolagenten. Dieser Dekorator verwandelt unsere reguläre Python-Funktion in ein Werkzeug, das der Agent verstehen und verwenden kann.
• Der Dokumentstring (""" ... """) im get_weather Funktion ist entscheidend. Der Agent liest diese Beschreibung, um zu verstehen, was das Device tut und wie es verwendet wird.
• Innerhalb der Funktion stellen wir eine einfache HTTP-Anfrage an wttr.inein kostenloser Wetterdienst, der Klartextvorhersagen zurückgibt.
• Geben Sie Hinweise ein (metropolis: str) Teilen Sie dem Agenten mit, welche Eingaben er bereitstellen soll.

Dies ist ein perfektes Beispiel für den Device-Name in Aktion. Wir geben dem Agenten eine neue Fähigkeit.

// Konfigurieren des LLM

hf_token = os.getenv("HF_TOKEN")
if hf_token is None:
    elevate ValueError("Please set the HF_TOKEN atmosphere variable")

mannequin = InferenceClientModel(
    model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
    token=hf_token
)

Der Agent braucht ein Gehirn – ein großes Sprachmodell (LLM), das über Aufgaben nachdenken kann. Hier verwenden wir:

• Qwen2.5-Coder-32B-Instruct: Ein leistungsstarkes Code-fokussiertes Modell, das auf Hugging Face gehostet wird
• HF_TOKEN: Ihr Hugging Face API-Token, gespeichert in einem .env Datei aus Sicherheitsgründen

Jetzt müssen wir den Agenten selbst erstellen.

agent = CodeAgent(
    instruments=(get_weather),
    mannequin=mannequin,
    add_base_tools=False
)

CodeAgent ist ein spezieller Agententyp, der:

• Schreibt Python-Code, um Probleme zu lösen
• Führt diesen Code in einer Sandbox-Umgebung aus
• Kann mehrere Werkzeugaufrufe miteinander verketten

Hier instanziieren wir a CodeAgent. Wir übergeben ihm eine Liste mit unseren get_weather Werkzeug und Modellobjekt. Der add_base_tools=False Das Argument weist es an, keine Standardtools einzuschließen, sodass unser Agent vorerst einfach bleibt.

// Ausführen des Agenten

Das ist der spannende Teil. Geben wir unserem Agenten eine Aufgabe. Führen Sie den Agenten mit einer bestimmten Eingabeaufforderung aus:

response = agent.run(
    "Are you able to inform me the climate in Paris and likewise in Tokyo?"
)
print(response)

Wenn Sie anrufen agent.run()der Agent:

1. Liest Ihre Eingabeaufforderung.
2. Gründe dafür, welche Werkzeuge benötigt werden.
3. Erzeugt Code, der aufruft get_weather("Paris") Und get_weather("Tokyo").
4. Führt den Code aus und gibt die Ergebnisse zurück.

Abbildung 3: Smolagent-Reaktion

Wenn Sie diesen Code ausführen, werden Sie Zeuge der Magie eines Hugging Face-Agenten. Der Agent erhält Ihre Anfrage. Es sieht, dass es ein Device namens hat get_weather. Anschließend schreibt es in seinem „Geist“ (unter Verwendung des LLM) ein kleines Python-Skript, das etwa so aussieht:

Das denkt der Agent, nicht der Code, den Sie schreiben.

weather_paris = get_weather(metropolis="Paris")
weather_tokyo = get_weather(metropolis="Tokyo")
final_answer(f"Right here is the climate: {weather_paris} and {weather_tokyo}")

Abbildung 4: Endgültige Reaktion der Smolagenzien

Es 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 Web surfen kann.

// Wie es hinter den Kulissen funktioniert

Abbildung 5: Das Innenleben eines KI-Code-Agenten

// Noch weiter gehen: Weitere Instruments hinzufügen

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

@software
def save_to_file(content material: str, filename: str = "weather_report.txt") -> str:
    """
    Saves the supplied textual content content material to a file.
    Args:
        content material: The textual content content material to save lots of.
        filename: The identify of the file to save lots of to (default: weather_report.txt).
    """
    with open(filename, "w") as f:
        f.write(content material)
    return f"Content material efficiently saved to {filename}"

# Re-initialize the agent with each instruments
agent = CodeAgent(
    instruments=(get_weather, save_to_file),
    mannequin=mannequin,
)

agent.run("Get the climate for London and save the report back to a file known as london_weather.txt")

Jetzt kann Ihr Agent Daten abrufen und mit Ihrem lokalen Dateisystem interagieren. Diese Kombination von Fähigkeiten macht Python-KI-Agenten so vielseitig.

# Abschluss

In nur wenigen Minuten und mit weniger als 20 Zeilen Kernlogik haben Sie einen funktionsfähigen KI-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.

Das Schöne an diesem Open-Supply-Agenten-Framework ist, dass es den Grundbaustein entfernt, sodass Sie sich auf den unterhaltsamen Teil konzentrieren können: das Erstellen der Instruments und das Definieren der Aufgaben. Sie chatten nicht mehr nur mit einer KI; Sie arbeiten mit jemandem zusammen, der handeln kann. Das ist erst der Anfang. Sie können Ihrem Agenten nun über Such-APIs Zugriff auf das Web gewähren, ihn an eine Datenbank anschließen oder ihm die Steuerung eines Webbrowsers überlassen.

// Referenzen und Lernressourcen

Shittu Olumid ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich dafür einsetzt, modernste Technologien zu nutzen, um fesselnde Erzählungen zu erschaffen, mit einem scharfen Blick fürs Element und einem Gespür für die Vereinfachung komplexer Konzepte. Sie können Shittu auch auf finden Twitter.