Smolagents AI Agent Framework

 HuggingFace's NEUES Agenten-Framework ,Erstellen Sie leistungsstarke KI-Agenten mit minimalem Aufwand

SmolAgents - Leistungsstarke KI-Agenten, minimaler Code, auf Hugging Face Framework | Product Hunt

Deep Research build By Smolagents FREE

Powered By Smolagents

Ai code Smolagents | FAST&FREE

Angetrieben von Together AI und LlamaCoder

smolagents and tools gallery

best smolagents in huggingface

 Was sind Agenten?

AI-Agenten sind Programme, bei denen LLM-Ausgaben den Arbeitsablauf steuern.

Die Tabelle veranschaulicht, wie die Agenturen in den verschiedenen Systemen variieren:

Ebene der AgenturBeschreibungWie das genannt wirdBeispiel-Muster
☆☆☆LLM-Ausgabe hat keinen Einfluss auf den ProgrammablaufEinfacher Prozessorprocess_llm_output(llm_response)
★☆☆LLM-Ausgang bestimmt grundlegenden KontrollflussRouterif llm_decision(): path_a() sonst: path_b()
★★☆LLM-Ausgabe bestimmt FunktionsausführungWerkzeugaufrufrun_function(llm_chosen_tool, llm_chosen_args)
★★★LLM-Ausgabe steuert Iteration und ProgrammfortsetzungMehrstufige Mittelwhile llm_should_continue(): execute_next_step()
★★★Ein agentischer Workflow kann einen anderen agentischen Workflow startenMulti-Agentif llm_trigger(): execute_agent()

Merkmal von SmolAgents

🤗 Smolagents ist ein minimalistisches KI-Agenten-Framework, das vom Hugging Face-Team entwickelt wurde, um Entwicklern zu ermöglichen, robuste Agenten mit nur wenigen Codezeilen einzusetzen. smolagents steht für Einfachheit und Effizienz und ermöglicht es großen Sprachmodellen (LLMs), nahtlos mit der realen Welt zu interagieren.

✨ Einfachheit

Kompakte Codebasis: Mit etwa 1.000 Zeilen Kerncode in agents.pysmolagents beschränkt die Abstraktionen auf ein Minimum, um die Entwicklung zu vereinfachen.

Benutzerfreundlich

Entwickler können Agenten schnell definieren, die erforderlichen Tools bereitstellen und sie ohne komplizierte Konfigurationen sofort ausführen.

Code-Agenten

 smolagents konzentriert sich auf Code-Agentenbei dem Agenten Python-Code-Schnipsel schreiben und ausführen, um Aktionen durchzuführen, anstatt Aktionen als JSON- oder Text-Blobs zu generieren.

Hoher Wirkungsgrad

Im Vergleich zu standardmäßigen Tool-Calling-Methoden bieten Code-Agenten eine verbesserte Effizienz und Genauigkeit, indem sie Schritte und LLM-Aufrufe um etwa 30% reduzieren und bei komplexen Benchmarks eine überragende Leistung erzielen.

Sichere Ausführung

 Um eine sichere Codeausführung zu gewährleisten, unterstützt smolagents die Ausführung von Code in Sandbox-Umgebungen wie E2Bund bietet einen geschützten und isolierten Ausführungsraum.

Verschiedene LLMs

 smolagents lässt sich mühelos in jedes große Sprachmodell integrieren, einschließlich der Modelle, die über Transformers im Hugging Face Hub gehostet werden, sowie der Modelle von OpenAI, Anthropic und anderen über die LiteLLM-Integration.

SmolAgents :Integration mit Hugging Face Hub

Tools zum Teilen und Laden: Die enge Integration mit dem Hugging Face Hub ermöglicht Entwicklern den einfachen Austausch und Import von Tools und fördert so die Zusammenarbeit und den Austausch innerhalb der Community.

Ökosystem Wachstum: Durch die Nutzung der Möglichkeiten des Hubs erweitert smolagents kontinuierlich seine Funktionen und Tools und bietet so ein grenzenloses Entwicklungspotenzial.

Unterstützung für traditionelle Tool-Calling-Agents

Vielfalt der Wahlmöglichkeiten: Zusätzlich zu den Code-Agenten unterstützt smolagents auch traditionelle Werkzeuganrufer, wo Aktionen als JSON- oder Textblöcke geschrieben werden, die für bestimmte Szenarien und Anforderungen geeignet sind.

Gründe, sich für Code smolAgents zu entscheiden

Hervorragende Kompositionsfähigkeit: Der Code unterstützt natürlich die Verschachtelung und Wiederverwendung von Funktionen und ermöglicht so den Ausdruck komplexer Logik.

Effiziente Objektbehandlung: Im Vergleich zu JSON vereinfacht der Code die Verwaltung und Übertragung von Objekten.

Ultimative Flexibilität: Der Code kann jede Operation darstellen, die ein Computer ausführen kann, was eine enorme Vielseitigkeit bietet.

Umfangreiche Trainingsdaten: LLMs wurden an großen Mengen hochwertigen Codes geschult, was ihre Fähigkeit, Code zu generieren und zu verstehen, verbessert hat.

Leistungsvorteile von smolagents

In verschiedenen Benchmarks haben smolagents, die Open-Source-Modelle verwenden, die Leistung von Agenten mit proprietären Modellen erreicht. Dank der Effizienz von Code-Agenten und der kontinuierlichen Weiterentwicklung von Open-Source-Modellen können Entwickler leistungsstarke Agentensysteme aufbauen, ohne auf Closed-Source-Dienste angewiesen zu sein.

Anwendungsbeispiel für SmolAgents

In Smolagents sind die Agenten in Klassen gekapselt, die es ihnen ermöglichen, bestimmte Aufgaben zu erfüllen. Zum Beispiel kann ein ManagedAgent erstellt werden, um verschiedene Aufgaben zu verwalten, indem verschiedene Agententypen verwendet werden. Im Folgenden finden Sie ein vereinfachtes Beispiel dafür, wie zwei Agenten - einer für die Websuche und ein anderer für die Bilderzeugung - implementiert werden können. Hier erfahren Sie, wie Sie ein benutzerdefiniertes Tool erstellen, das Reisezeiten aus Google Maps abruft, und wie Sie es in einem Reiseplanungsagenten verwenden:

from typing import Optional
from smolagents import CodeAgent, HfApiModel, tool

@tool
def get_travel_duration(start_location: str, destination_location: str, transportation_mode: Optional[str] = None) -> str:
    """Gets the travel time between two places.

    Args:
        start_location: the place from which you start your ride
        destination_location: the place of arrival
        transportation_mode: The transportation mode, in 'driving', 'walking', 'bicycling', or 'transit'. Defaults to 'driving'.
    """
    import os   # All imports are placed within the function, to allow for sharing to Hub.
    import googlemaps
    from datetime import datetime

    gmaps = googlemaps.Client(os.getenv("GMAPS_API_KEY"))

    if transportation_mode is None:
        transportation_mode = "driving"
    try:
        directions_result = gmaps.directions(
            start_location,
            destination_location,
            mode=transportation_mode,
            departure_time=datetime(2025, 6, 6, 11, 0), # At 11, date far in the future
        )
        if len(directions_result) == 0:
            return "No way found between these places with the required transportation mode."
        return directions_result[0]["legs"][0]["duration"]["text"]
    except Exception as e:
        print(e)
        return e

agent = CodeAgent(tools=[get_travel_duration], model=HfApiModel(), additional_authorized_imports=["datetime"])

agent.run("Can you give me a nice one-day trip around Paris with a few locations and the times? Could be in the city or outside, but should fit in one day. I'm travelling only with a rented bicycle.")

Nach ein paar Schritten, in denen er Reisezeiten sammelt und Berechnungen durchführt, liefert der Agent diesen endgültigen Vorschlag: Eintägige Radtour nach Paris:


1. Start am Eiffelturm um 9:00 Uhr.
2. Sightseeing am Eiffelturm bis 10:30 Uhr.
3. Fahrt zur Kathedrale Notre-Dame um 10:46 Uhr.
4. Besichtigung der Kathedrale Notre-Dame bis 12:16 Uhr.
5. Fahrt zum Montmartre um 12:41 Uhr.
6. Sightseeing am Montmartre bis 14:11 Uhr.
7. Fahrt zum Jardin du Luxembourg um 14:33 Uhr.
8. Besichtigung des Jardin du Luxembourg bis 16:03 Uhr.
9. Fahrt zum Louvre-Museum um 16:12 Uhr.
10. Besichtigung des Louvre-Museums bis 17:42 Uhr.
11. Mittagspause bis 18:12 Uhr.
12. Geplante Endzeit: 18:12 Uhr.

Nachdem Sie ein Tool erstellt haben, können Sie es ganz einfach für den Hub freigeben:

get_travel_duration.push_to_hub("{Ihr_Benutzername}/get-travel-duration-tool")

Ressourcen von SmolAgents

Häufig gestellte Fragen zu smolagents

smolagents ist eine minimalistische KI-Agentenbibliothek, die vom Hugging Face Team entwickelt wurde. Sie ermöglicht es Entwicklern, mit minimalem Code leistungsstarke KI-Agenten zu erstellen und auszuführen. Durch die Konzentration auf Einfachheit und Effizienz ermöglicht smolagents großen Sprachmodellen (LLMs), nahtlos mit realen Aufgaben zu interagieren.

Im Gegensatz zu vielen KI-Agenten-Frameworks, die komplexe Abstraktionen und Konfigurationen aufweisen, verfügt smolagents über eine kompakte Codebasis von etwa 1.000 Zeilen. Es betont die Benutzerfreundlichkeit und unterstützt Code-Agenten, bei denen Agenten Python-Code-Schnipsel direkt ausführen, was die Effizienz erhöht und die Anzahl der erforderlichen Schritte und LLM-Aufrufe reduziert.

 Code-Agenten sind ein Hauptmerkmal von smolagents. Anstatt Aktionen als JSON- oder Text-Blobs zu generieren, schreiben Code-Agenten Python-Code-Schnipsel und führen sie aus, um Aufgaben zu erfüllen. Dieser Ansatz nutzt die Fähigkeit des LLM, Code zu generieren und zu verstehen, und bietet eine bessere Kompositionsfähigkeit und Flexibilität bei der Formulierung komplexer Logik.

Sie können smolagents mit pip mit dem Befehl installieren:

复制pip install smolagents

Um loszulegen, definieren Sie einen Agenten, indem Sie die erforderlichen Klassen importieren, die erforderlichen Werkzeuge und das LLM-Modell bereitstellen und Ihre Aufgaben ausführen. Zum Beispiel:

python复制von smolagents importieren CodeAgent, DuckDuckGoSearchTool, HfApiModel

agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
agent.run("Ihre Aufgabe hier")

 smolagents ist für eine breite Kompatibilität mit LLMs ausgelegt. Es lässt sich über Transformers nahtlos mit Modellen integrieren, die auf dem Hugging Face Hub gehostet werden, sowie mit Modellen von OpenAI, Anthropic und anderen über die LiteLLM-Integration. Dank dieser Flexibilität können Sie das für Ihre Projektanforderungen am besten geeignete LLM auswählen.

 Ja, zusätzlich zu den Code-Agenten unterstützt smolagents herkömmliche Werkzeugaufruf-Agenten. In diesem Modus werden Aktionen als JSON- oder Text-Blobs geschrieben, was für bestimmte Szenarien geeignet sein kann, in denen die Ausführung von Codeschnipseln nicht ideal ist.

 smolagents legt den Schwerpunkt auf die sichere Codeausführung, indem es Sandbox-Umgebungen unterstützt. So kann beispielsweise E2B (Execution to Binary) verwendet werden, das eine sichere und isolierte Umgebung für die Ausführung von Codefragmenten bietet. Dadurch wird sichergestellt, dass die Ausführung von Code die Sicherheit des Host-Systems nicht gefährdet.

 Code-Agenten bieten mehrere Vorteile:

  • Bessere Kompostierbarkeit: Der Code ermöglicht natürlich die Verschachtelung und Wiederverwendung von Funktionen, wodurch sich komplexe Logik leichter ausdrücken lässt.
  • Effiziente Objektverwaltung: Die Verwaltung und Übergabe von Objekten ist im Vergleich zu JSON im Code unkomplizierter.
  • Hohe Flexibilität: Der Code kann jede beliebige Rechenoperation darstellen, was ihm eine enorme Vielseitigkeit verleiht.
  • Reichhaltige Nutzung von Trainingsdaten: Da LLMs an großen Mengen von Code trainiert werden, sind sie geübt im Generieren und Verstehen von Codeschnipseln.

 smolagents ist eng in den Hugging Face Hub integriert, so dass Entwickler Tools einfach austauschen und laden können. Dies fördert ein kollaboratives Ökosystem, in dem Tools und Ressourcen von der Community beigetragen und abgerufen werden können, was die Funktionalität und Reichweite von smolagents erhöht.

Sie können die folgenden Ressourcen nutzen, um mehr über smolagents zu erfahren:

  • Offizielle Dokumentation: Besuchen Sie die smolagents-Dokumentation auf der Website "Hugging Face".
  • Leitfäden für den Einstieg: Sehen Sie sich die Einführungsanleitungen und Tutorials des Hugging Face-Teams an.
  • Beispielhafte Projekte: Entdecken Sie Beispielprojekte und Codebeispiele auf GitHub, um smolagents in Aktion zu sehen.
  • Gemeinschaftsforen: Tauschen Sie sich mit der Entwickler-Community in Foren und Diskussionen aus, um Einblicke und Unterstützung zu erhalten.

Choose from Your languange