Allgemeinwissen zeigt, dass Multitasking so weit wie möglich vermieden werden sollte, da es Sie aus dem Fokus lenkt. Mit dem Aufkommen von Codierungsagenten ist paralleles Arbeiten jedoch zu einer Voraussetzung für Effizienz geworden. Wenn man bedenkt, dass Codierungsagenten über einen längeren Zeitraum ausgeführt werden können, möchten Sie keine Zeit damit verschwenden, darauf zu warten, dass sie fertig sind. Stattdessen möchten Sie einen Agenten auslösen und, während dieser Agent arbeitet, eine andere Aufgabe starten.

Allerdings ist es nicht einfach, Aufgaben parallel zu starten. Es gibt zahlreiche Überlegungen, die Sie anstellen müssen, wie z

• Wie führt man mehrere Codierungsagenten im selben Repository aus?
• Wie können Sie den Kontextwechsel dennoch so weit wie möglich minimieren?
• Wie behalten Sie den Überblick über alle laufenden Agenten?

Im heutigen Artikel werde ich auf alle diese Punkte eingehen und detailliert beschreiben, wie ich mit diesen Problemen umgehe und welche Lösung ich anwende.

Warum Agenten parallel ausführen?

Wie bei vielen anderen Artikeln, die ich geschrieben habe, liegt der Hauptgrund für die Techniken, die ich in dem Artikel beschreibe, darin, Zeit zu sparen und als Ingenieur effizienter zu sein. Wenn Sie Coding Brokers und die unglaubliche LLM-Entwicklung, die wir in den letzten Jahren erlebt haben, optimum nutzen möchten, müssen Sie Ihre Arbeit parallelisieren.

Um zu verstehen, warum, stellen wir uns das gegenteilige Beispiel vor. Stellen wir uns vor, dass wir nur sequentiell arbeiten, wie Sie es normalerweise beim Programmieren taten, bevor LLMs verfügbar wurden. Sequentielle Programmierung mit Codierungsagenten würde etwa so aussehen:

1. Finden Sie die Aufgabe, die Sie erledigen möchten
2. Beschreiben Sie es einem Agenten und erstellen Sie einen Plan
3. Starten Sie den Agenten und lassen Sie ihn laufen. Warten Sie, bis es fertig ist oder Sie um etwas bittet
4. Testen Sie die Implementierung und iterieren Sie

Wie lange jede dieser Aufgaben dauert, ist sehr unterschiedlich. Manchmal dauert es am meisten, einem Agenten die Aufgabe zu beschreiben und einen Plan zu erstellen, aber meiner Erfahrung nach ist der dritte Schritt oft ein zeitaufwändiger Schritt, insbesondere bei größeren Implementierungen wie der Implementierung einer neuen Funktion oder der Behebung eines komplexen Fehlers.

Um effizienter zu werden, wollen wir nun Engpässe beseitigen. Der dritte Schritt ist ein Engpass, den wir leicht minimieren oder beseitigen können. Es ist sehr schwierig, die Schritte eins und zwei effizienter zu gestalten. Sie müssen dies nacheinander tun und sich Zeit dafür nehmen. Schritt vier ist definitiv etwas, das Sie effizienter gestalten können, wie ich in anderen Artikeln beschrieben habe, beispielsweise in meinem Artikel über Claude bei One-Shot-Implementierungen verbessern. Daher konzentriere ich mich in diesem Artikel auf Schritt 3 und darauf, wie man ihn effizienter gestalten kann.

So führen Sie Agenten parallel aus

Die einfache Lösung, um Schritt 3 effizienter zu gestalten, besteht darin, Agenten parallel auszuführen. Das klingt in der Theorie einfach, ist aber in der Praxis tatsächlich schwieriger umzusetzen. Der Grund dafür ist, dass die parallele Ausführung von Aufgaben eine Reihe von Herausforderungen mit sich bringt.

Eine Herausforderung, mit der Sie umgehen müssen, besteht darin, dass Agenten einander Code schreiben. Sie möchten nicht, dass Agenten darum konkurrieren, eine bestimmte Datei zu bearbeiten oder ihre eigene Implementierung zu testen. Das ist additionally ein Drawback, mit dem Sie sich befassen müssen. Ein weiteres Drawback, mit dem Sie zu kämpfen haben, ist die Tatsache, dass Sie einen Kontextwechsel durchführen müssen. Wenn Sie additionally Aufgaben parallel ausführen, müssen Sie natürlich einen Kontextwechsel zwischen den verschiedenen Aufgaben durchführen. Ein Aspekt des Kontextwechsels besteht darin, dass Sie zuerst eine Aufgabe und deren Lösung beschreiben müssen und dann eine andere Aufgabe und deren Lösung beschreiben müssen. Ein weiterer Aspekt des Kontextwechsels besteht darin, dass der Agent um Suggestions bittet, z. B. indem er Ihnen Fragen zu einer Implementierung stellt oder Sie bittet, eine Implementierung zu testen. Daher ist die Minimierung des Kontextwechsels ein weiterer Aspekt, den ich in den letzten Abschnitten beschreiben werde.

Mehrere Agenten im selben Repository mithilfe von Arbeitsbäumen ausführen

Das erste Thema, das ich behandeln werde, ist die Ausführung mehrerer Agenten im selben Repository. Die einfache Antwort darauf ist die Verwendung von Arbeitsbäumen.

Sie können Ihren Agenten einfach anweisen, einen Worktree zu verwenden, eine Git-Funktion, die im Wesentlichen Ihr gesamtes Repository kopiert. So können verschiedene Agenten in völlig unterschiedlichen Repositories arbeiten. Nachdem ein Agent seine Implementierung abgeschlossen hat, kann er in den Hauptzweig des Haupt-Repositorys eingefügt werden. Auf diese Weise können mehrere Agenten ohne Konflikte im selben Repository arbeiten.

Manchmal gibt es jedoch einfachere Möglichkeiten, den Arbeitsbaum einzurichten. Aus meiner persönlichen Erfahrung hatte ich Probleme, als ich Claude Code verwendete und es aufforderte, einen Arbeitsbaum auszuprobieren. Claude vergaß oft, tatsächlich einen neuen Arbeitsbaum auszuchecken und dann mit der Arbeit im Haupt-Repository zu beginnen. Als dann mehrere Agenten dasselbe taten, kam es zu Konflikten. Glücklicherweise hat Claude Code a implementiert –worktree-Befehl, den Sie beim Hochfahren von Cloud-Code verwenden können, wie unten

claude --worktree

Wenn Sie diesen Befehl in einem GitHub-Repository verwenden, checkt Claude automatisch in einen neuen Arbeitsbaum aus, wenn das vorhandene Repository vorhanden ist, und speichert alle Arbeitsbäume in einem versteckten Claude-Ordner. Dies ist aus zwei Hauptgründen unglaublich nützlich:

1. Sie garantieren, dass Sie immer einen Arbeitsbaum verwenden und dass Ihre Agenten sich nicht gegenseitig stören.
2. Die Arbeitsbäume werden in einem versteckten Claude-Ordner und nicht in Ihrem Hauptordner gespeichert. Dadurch wird das Rauschen in Ihrer Ordnerstruktur erheblich reduziert, sodass Sie bei Bedarf einfacher manuell in der Ordnerstruktur navigieren können.

Wenn Sie einen anderen Codierungsagenten verwenden, können Sie herausfinden, wie dieser Arbeitsbäume eingerichtet hat, da Arbeitsbäume immer mehr zu einer erwarteten Funktion für jedes Codierungsagentenprogramm werden, beispielsweise eine IDE wie Cursor oder eine CLI wie Claude Code.

Kontextwechsel minimieren

Aspekt Nummer zwei, den Sie bei der parallelen Ausführung von Codierungsagenten berücksichtigen müssen, ist, dass Sie den Kontextwechsel minimieren müssen. Ich habe bereits erwähnt, dass dies vor allem in zwei Aspekten geschieht. Erstens beim Starten nach Aufgaben und zweitens bei der Interaktion mit dem Agenten während der Aufgabe, z. B. wenn der Agent Ihnen Fragen stellt oder seine Implementierung abschließt und Sie zum Testen auffordert.

Es gibt keine einfache Lösung, um das Schalten von Kontakten einfach zu eliminieren, da paralleles Arbeiten von Natur aus ein Schalten von Kontakten erfordert. Es gibt jedoch ein paar Dinge, die ich behalte, um meinen Kontaktwechsel zu minimieren.

Das Erste, woran ich denke, ist, immer meine aktuelle Aufgabe zu beenden, bevor ich zu einer anderen übergehe. Das erscheint mir sehr offensichtlich, wenn ich es beschreibe; Ich möchte jedoch ein konkretes Beispiel liefern. Das beschriebene Beispiel finden Sie im Textual content unten, aber ich zeige auch das Bild, um Ihnen das Konzept weiter unten leichter zu verstehen.

Nehmen wir an, Sie haben zwei Aufgaben, A und B, die Sie erledigen müssen. Für Aufgabe A ist eine fünfminütige Interaktion des Benutzers erforderlich, während für Aufgabe B eine zweiminütige Interaktion des Benutzers erforderlich ist. Nach dieser Interaktion wird der Agent zehn Minuten lang ausgeführt, um die Aufgabe abzuschließen. Außerdem haben Sie bereits mit Aufgabe A begonnen und Ihr geistiger Kontext befindet sich derzeit bei Aufgabe A.

In dieser Scenario ist es sehr verlockend, von Aufgabe A zu Aufgabe B zu wechseln und die zweiminütige Einrichtung von Aufgabe B durchzuführen, damit der Agent ausgeführt werden kann, während Sie Aufgabe A beenden. Ich charge Ihnen jedoch dringend, dies so weit wie möglich zu vermeiden und lieber zu versuchen, die Arbeit, die Sie gerade erledigen, zu beenden und dann mit der nächsten Aufgabe in der Reihe fortzufahren, auch wenn dies auf den ersten Blick möglicherweise nicht der optimale Ansatz ist.

Der Grund dafür ist, dass Sie natürlich sehen können, wie viele Minuten es dauert, jede Aufgabe zu erledigen. Aufgabe A dauert 5 Minuten, Aufgabe B benötigt 2 Minuten Interaktion und dann 10 Minuten für die Ausführung. Was Sie jedoch nicht sehen, sind die versteckten Kosten des Kontextwechsels, und ich würde behaupten, dass der Wechsel von Aufgabe A zu Aufgabe B und der anschließende Wechsel zurück zu Aufgabe A Sie mehr Zeit kostet, als einfach Aufgabe A und dann Aufgabe B abzuschließen.

Die zweite Möglichkeit, Kontaktwechsel zu minimieren, besteht darin, Ablenkungen auf meinem Laptop zu minimieren. Es gibt zahlreiche Möglichkeiten, dies zu tun, aber generell charge ich Ihnen dringend, alle Benachrichtigungen zu deaktivieren. Ich habe zum Beispiel die Slack-Benachrichtigungen auf meinem Laptop deaktiviert und auch die in der Slack-Anwendung angezeigte Nummer, die Sie darüber informiert, wenn eine Nachricht auf Sie wartet. Ich finde das sehr ablenkend und lenke meinen Fokus und Kontext von der Arbeit ab, die ich gerade mache.

Darüber hinaus versuche ich, in meinem Terminal-Setup für jedes Repository, an dem ich arbeite, eine Registerkarte beizubehalten. Und wenn ich an mehreren Aufgaben in einem einzigen Repository arbeite, teile ich die Registerkarte. Ich werde mein Terminal-Setup im nächsten Abschnitt ausführlicher besprechen.

Behalten Sie den Überblick über alle Ihre Agenten

Wenn Sie mehrere Agenten betreiben, ist es unglaublich wichtig, den Überblick über alle Ihre Agenten zu behalten. Dies ist jedoch nicht unbedingt selbstverständlich und Sie müssen aktive Entscheidungen treffen, um es so einfach wie möglich zu machen, sich einen Überblick zu verschaffen.

Hier kommt mein Terminal-Setup ins Spiel. Wenn 5 bis 10 Agenten parallel laufen, kann es leicht sehr verwirrend sein, welcher Agent was tut und mit wem man interagieren muss.

Für mein Terminal-Setup verwende ich Warp. Ich denke, Warp ist ein gutes KI-Terminal mit guter automatischer Vervollständigung, mit dem ich problemlos interagieren kann, um Claude Code effektiv zu nutzen. Ich verwende eine Registerkarte in Warp professional Repository, in dem ich arbeite. Dies könnte beispielsweise ein Codierungs-Repository sein, das das Frontend oder die Anwendung enthält, aber es könnte auch ein Vertriebs-Repository sein, in dem ich die gesamte Vertriebsarbeit erledige.

Wenn ich dann mehrere Agenten in einem Repository ausführe, was häufig der Fall ist, teile ich die Registerkarten einfach mit CMD + D auf dem Mac. Daher erhalte ich für jede meiner Hauptregisterkarten mehrere geteilte Unterregisterkarten. Dies hilft mir, nur eine einzige Hauptregisterkarte für jedes Repository zu behalten und gleichzeitig mehrere Agenten innerhalb des Repositorys auszuführen.

Darüber hinaus benenne ich meine Tabs in Warp gerne in den Repository-Namen um, damit ich einfach zum richtigen Tab navigieren kann. Und verwenden Sie CMD 1/2/3 usw., um schnell zwischen den verschiedenen Registerkarten zu navigieren. Und ich erhalte Benachrichtigungen von Warp, wann immer ein Agent eine Interaktion benötigt.

Ich möchte auch darauf hinweisen, dass es viele andere Setups gibt, die Sie für Ihre Codierungsagenten verwenden können. Zunächst einmal können Sie ein anderes Terminal verwenden, was wahrscheinlich auch ganz intestine funktionieren wird, obwohl ich lieber heat bleibe. Eine weitere gute Various, die ich kenne, ist die Verwendung der Claude-Anwendung oder einer Anwendung namens Conductor, die es einfach macht, einen Überblick über Ihre verschiedenen Repositorys und Codierungsagenten zu geben, die Sie ausführen.

Alles in allem kommt es jedoch bei der Konfiguration auf Ihre Vorlieben an. Wenn Sie ein Setup finden, das für Sie intestine funktioniert, empfehle ich dringend, dieses Setup zu verwenden und einfach dabei zu bleiben.

Abschluss

In diesem Artikel habe ich besprochen, wie Sie Ihre Programmieraufgaben effizient parallelisieren können. Der Hauptgrund, warum Sie dies tun sollten, besteht einfach darin, als Ingenieur effizienter zu sein. Wenn Sie Aufgaben parallel ausführen, sind Sie weitaus effektiver als ein ähnlicher Ingenieur, der Aufgaben nacheinander ausführt. Das parallele Ausführen von Aufgaben ist jedoch nicht einfach, und Sie müssen bestimmte Techniken anwenden, um den Überblick über alle Ihre Agenten zu behalten, Kontextwechsel zu minimieren und sicherzustellen, dass Ihre Agenten nicht miteinander kollidieren. Ich glaube, dass das Konzept, das ich in diesem Artikel beschrieben habe, die Zukunft der Arbeit mit KI ist. Menschen werden zu Koordinatoren von KI-Agenten, und Sie müssen in der Lage sein, Ihre Arbeit effizient zu parallelisieren und Agenten abzufeuern, um bestimmte Aufgaben zu erledigen, während Sie nur bei Bedarf mit den Agenten interagieren.

Mein kostenloses E-E book und Webinar:

Verzehnfachen Sie Ihr Engineering mit LLMs (kostenloser 3-tägiger E-Mail-Kurs)

Holen Sie sich mein kostenloses E-E book „Imaginative and prescient Language Fashions“.

Mein Webinar zum Thema Imaginative and prescient Language Fashions

Finden Sie mich in den sozialen Netzwerken:

Unterstapel

LinkedIn

X / Twitter

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.