Cadre d'agents d'intelligence artificielle Smolagents

 HuggingFace's NEW Agent Framework ,Create Powerful AI Agents with Minimal Effort

SmolAgents - Agents IA puissants, code minimal, sur le framework Hugging Face | Product Hunt

Deep Research build By Smolagents FREE

Powered By Smolagents

Ai code Smolagents | FAST&FREE

Réalisé par Together AI et LlamaCoder

smolagents and tools gallery

best smolagents in huggingface

 Qu'est-ce qu'un agent ?

Les agents d'intelligence artificielle sont les programmes dans lesquels les résultats du programme d'éducation et de formation tout au long de la vie contrôlent le flux de travail.

Le tableau montre comment l'agence varie d'un système à l'autre :

Niveau de l'agenceDescriptionComment cela s'appelle-t-il ?Exemple de modèle
☆☆☆Les résultats du LLM n'ont pas d'impact sur le déroulement du programmeProcesseur simpleprocess_llm_output(llm_response)
★☆☆La sortie LLM détermine le flux de contrôle de baseRouteurif llm_decision() : path_a() else : path_b()
★★☆La sortie LLM détermine l'exécution de la fonctionAppel d'outilrun_function(llm_chosen_tool, llm_chosen_args)
★★★La sortie LLM contrôle l'itération et la poursuite du programmeAgent en plusieurs étapeswhile llm_should_continue() : execute_next_step()
★★★Un flux de travail agentique peut démarrer un autre flux de travail agentique.Multi-agentsif llm_trigger() : execute_agent()

Fonctionnalité de SmolAgents

🤗 Smolagents est un cadre minimaliste d'agent d'IA développé par l'équipe Hugging Face, conçu pour permettre aux développeurs de déployer des agents robustes avec seulement quelques lignes de code. En embrassant la simplicité et l'efficacité, smolagents permet aux grands modèles de langage (LLM) d'interagir de manière transparente avec le monde réel.

Simplicité

Base de code compacte: Avec environ 1 000 lignes de code de base en agents.pysmolagents réduit les abstractions au minimum pour faciliter le développement.

Convivialité

Les développeurs peuvent rapidement définir des agents, fournir les outils nécessaires et les exécuter immédiatement sans configuration complexe.

Agents du code

 smolagents se concentre sur agents de codeoù les agents écrivent et exécutent des extraits de code Python pour effectuer des actions, au lieu de générer des actions sous forme de JSON ou de blocs de texte.

Haute efficacité

Par rapport aux méthodes d'appel d'outils standard, les agents de code offrent une efficacité et une précision accrues, réduisant les étapes et les appels LLM d'environ 30%, et réalisant des performances supérieures sur des repères complexes.

Exécution sécurisée

 Pour garantir une exécution sûre du code, smolagents prend en charge l'exécution du code dans des environnements de type "bac à sable" (sandbox) tels que E2BLe système de gestion de l'information de l'Union européenne (UE) permet de créer un espace protégé et isolé pour l'exécution des tâches.

Divers LLM

 smolagents s'intègre sans effort à n'importe quel grand modèle de langage, y compris les modèles hébergés sur le Hugging Face Hub via Transformers, ainsi que les modèles d'OpenAI, d'Anthropic et d'autres grâce à l'intégration de LiteLLM.

SmolAgents :Intégration avec Hugging Face Hub

Outils de partage et de chargement: L'intégration poussée avec le Hugging Face Hub permet aux développeurs de partager et d'importer facilement des outils, favorisant ainsi la collaboration et le partage au sein de la communauté.

Croissance de l'écosystème: En s'appuyant sur les capacités du Hub, smolagents s'enrichit continuellement de nouvelles fonctionnalités et de nouveaux outils, offrant ainsi un potentiel de développement illimité.

Soutien aux agents traditionnels d'appel d'outils

Variété de choix: Outre les agents de codage, smolagents prend également en charge les agents de codage traditionnels. agents d'appel des outilsoù les actions sont écrites sous forme de JSON ou de blocs de texte, en fonction de scénarios et d'exigences spécifiques.

Raisons d'opter pour le code smolAgents

Composabilité supérieure: Le code prend naturellement en charge l'imbrication et la réutilisation des fonctions, ce qui permet l'expression d'une logique complexe.

Traitement efficace des objets: Par rapport à JSON, le code simplifie la gestion et le transfert des objets.

Flexibilité ultime: Le code peut représenter n'importe quelle opération qu'un ordinateur peut effectuer, ce qui lui confère une immense polyvalence.

Données de formation étendues: Les LLM ont été formés sur de grandes quantités de code de haute qualité, ce qui a amélioré leur capacité à générer et à comprendre le code.

Avantages en termes de performance de smolagents

Dans divers benchmarks, les smolagent utilisant des modèles open-source ont égalé les performances des agents utilisant des modèles propriétaires. Grâce à l'efficacité des agents de code et aux progrès continus des modèles open-source, les développeurs peuvent construire des systèmes d'agents puissants sans dépendre de services fermés.

Exemple d'application des SmolAgents

Dans Smolagents, les agents sont encapsulés dans des classes qui leur permettent d'effectuer des tâches spécifiques. Par exemple, un Agent géré peut être créé pour gérer différentes tâches en utilisant différents types d'agents. Voici un exemple simplifié de la mise en œuvre de deux agents, l'un pour la recherche sur le web et l'autre pour la génération d'images,Voici comment créer un outil personnalisé qui récupère les temps de trajet à partir de Google Maps, et comment l'utiliser dans un agent de planification de voyages :

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.")

Après quelques étapes de collecte des temps de parcours et de calculs, l'agent vous renvoie cette proposition finale : Itinéraire d'une journée à vélo à Paris :


1. Départ de la Tour Eiffel à 9h00.
2. Visite de la Tour Eiffel jusqu'à 10h30.
3. Se rendre à la cathédrale Notre-Dame à 10h46.
4. Visite de la cathédrale Notre-Dame jusqu'à 12h16.
5. Se rendre à Montmartre à 12h41.
6. Visite de Montmartre jusqu'à 14h11.
7. Voyage au Jardin du Luxembourg à 14h33.
8. Visite du Jardin du Luxembourg jusqu'à 16h03.
9. Voyage au musée du Louvre à 16h12.
10. Visite du musée du Louvre jusqu'à 17h42.
11. Pause déjeuner jusqu'à 18h12.
12. Heure de fin prévue : 18 h 12.

Après avoir créé un outil, il suffit de le partager avec le Hub :

get_travel_duration.push_to_hub("{votre_nom d'utilisateur}/get-travel-duration-tool")

Ressources de SmolAgents

Questions fréquemment posées sur les smolagent

smolagents est une bibliothèque minimaliste d'agents d'intelligence artificielle développée par l'équipe Hugging Face. Elle permet aux développeurs de créer et d'exécuter de puissants agents d'intelligence artificielle avec un minimum de code. En se concentrant sur la simplicité et l'efficacité, smolagents permet aux grands modèles de langage (LLM) d'interagir de manière transparente avec les tâches du monde réel.

Contrairement à de nombreux cadres d'agents d'IA qui ont des abstractions et des configurations complexes, smolagents maintient une base de code compacte d'environ 1 000 lignes. Il met l'accent sur la facilité d'utilisation et prend en charge les agents de code, où les agents exécutent directement des extraits de code Python, ce qui améliore l'efficacité et réduit le nombre d'étapes requises et d'appels LLM.

 Les agents de code sont une caractéristique essentielle des smolagent. Au lieu de générer des actions sous forme de JSON ou de blocs de texte, les agents de code écrivent et exécutent des extraits de code Python pour effectuer des tâches. Cette approche tire parti de la capacité du LLM à générer et à comprendre le code, offrant ainsi une meilleure composabilité et une plus grande flexibilité dans l'expression d'une logique complexe.

Vous pouvez installer smolagents en utilisant pip avec la commande :

复制pip install smolagents

Pour commencer, définissez un agent en important les classes nécessaires, fournissez les outils et le modèle LLM requis et exécutez vos tâches. Par exemple, vous pouvez définir un agent en important les classes nécessaires :

python复制from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel

agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
agent.run("Votre tâche ici")

 smolagents est conçu pour une large compatibilité avec les LLM. Il s'intègre de manière transparente avec les modèles hébergés sur le Hugging Face Hub via les Transformers, ainsi qu'avec les modèles d'OpenAI, d'Anthropic et d'autres grâce à l'intégration LiteLLM. Cette flexibilité vous permet de choisir le LLM le plus adapté aux besoins de votre projet.

 Oui, en plus des agents de code, smolagents prend en charge les agents d'appel d'outils traditionnels. Dans ce mode, les actions sont écrites sous forme de JSON ou de blocs de texte, ce qui peut convenir à des scénarios spécifiques dans lesquels l'exécution d'extraits de code n'est pas idéale.

 smolagents donne la priorité à l'exécution sécurisée du code en prenant en charge les environnements de type "bac à sable". Par exemple, il peut utiliser E2B (Execution to Binary), qui fournit un environnement sécurisé et isolé pour l'exécution d'extraits de code. Cela garantit que l'exécution du code ne compromet pas la sécurité du système hôte.

 Les agents de code offrent plusieurs avantages :

  • Meilleure composabilité : Le code permet naturellement l'imbrication et la réutilisation des fonctions, ce qui facilite l'expression d'une logique complexe.
  • Gestion efficace des objets : La gestion et le passage d'objets sont plus simples dans le code que dans JSON.
  • Grande flexibilité : Le code peut représenter n'importe quelle opération de calcul, ce qui lui confère une immense polyvalence.
  • Utilisation de données de formation riches : Comme les LLM sont formés sur de grandes quantités de code, ils sont compétents pour générer et comprendre des extraits de code.

 smolagents est profondément intégré au Hugging Face Hub, ce qui permet aux développeurs de partager et de charger facilement des outils. Cela favorise un écosystème collaboratif où les outils et les ressources peuvent être apportés et accessibles à la communauté, améliorant ainsi la fonctionnalité et la portée de smolagents.

Vous pouvez consulter les ressources suivantes pour en savoir plus sur les smolagent :

  • Documentation officielle : Consultez la documentation de smolagents sur le site Site web de Hugging Face.
  • Guides de démarrage : Consultez les guides d'introduction et les tutoriels fournis par l'équipe de Hugging Face.
  • Exemples de projets : Explorez les exemples de projets et de code sur GitHub pour voir smolagents en action.
  • Forums communautaires : S'engager auprès de la communauté des développeurs par le biais de forums et de discussions pour obtenir des informations et de l'aide.

Choose from Your languange