Créez de véritables applications agentiques avec CUGA : deux douzaines d'exemples fonctionnels sur un cadre léger

Créez de véritables applications agentiques avec CUGA : deux douzaines d'exemples fonctionnels sur un harnais léger

L'essor de l'IA agentique — des systèmes capables de raisonner, planifier et exécuter des tâches de manière autonome — a transformé la façon dont les développeurs abordent l'automatisation. Pourtant, la création de tels agents nécessite souvent des frameworks complexes, une infrastructure lourde et beaucoup de code standard. Voici CUGA (Compact Unified Generative Agent), un harnais léger qui vous permet de construire et déployer des applications agentiques avec un minimum d'effort. Dans cet article, nous explorerons comment CUGA vous permet de créer deux douzaines d'exemples fonctionnels, des chatbots simples aux agents de raisonnement multi-étapes, le tout sur un harnais léger. Nous aborderons l'installation, la configuration et l'utilisation pratique avec des commandes réelles, en nous appuyant sur les développements récents des frameworks d'agents IA mis en avant par des sources comme le blog Hugging Face, OpenAI News, le blog Microsoft AI et Anthropic News.

Qu'est-ce que CUGA et pourquoi les applications agentiques sont importantes

Les applications agentiques sont des systèmes d'IA capables de percevoir leur environnement, de prendre des décisions et d'agir pour atteindre des objectifs. Contrairement aux chatbots traditionnels qui répondent à des requêtes, les applications agentiques peuvent décomposer des tâches complexes, utiliser des outils (par exemple, recherche, calculatrices, API) et itérer sur leurs résultats. CUGA fournit une couche d'abstraction minimale au-dessus des modèles de langage (LLM) comme ceux d'OpenAI, d'Anthropic ou des alternatives open-source, facilitant ainsi l'orchestration d'un comportement agentique sans outils d'orchestration lourds.

Le concept d'IA agentique a gagné en popularité dans l'industrie. Les récentes actualités d'OpenAI mettent l'accent sur le passage à des systèmes autonomes capables d'interactions dans le monde réel. Le blog Microsoft AI montre comment les agents s'intègrent aux outils d'entreprise comme Azure. Les recherches d'Anthropic soulignent la sécurité et la fiabilité des workflows agentiques. Le blog Hugging Face, quant à lui, a publié des exemples pratiques de construction d'agents avec des frameworks légers. CUGA s'aligne sur cette tendance en offrant un harnais à la fois simple et extensible.

Prérequis

Avant de plonger dans l'installation et les exemples, assurez-vous de disposer des éléments suivants :

• Python 3.10 ou version ultérieure : CUGA est natif en Python. Vérifiez votre version avec python --version.
• Un fournisseur de LLM pris en charge : Clé API OpenAI (pour GPT-4o ou GPT-4-turbo), clé API Anthropic (pour Claude 3.5 Sonnet), ou accès à un modèle local via Hugging Face Transformers.
• Familiarité de base avec la ligne de commande et Python : Vous exécuterez des scripts et modifierez des fichiers de configuration.
• Au moins 4 Go de RAM : Pour les modèles locaux ou les boucles d'agents lourdes.
• Connexion Internet : Pour les modèles basés sur API et les téléchargements de paquets.

Installation étape par étape

CUGA est distribué sous forme de paquet Python. Nous allons l'installer dans un environnement virtuel pour isoler les dépendances.

1. Créer et activer un environnement virtuel

Commencez par créer un environnement dédié pour vos projets CUGA. Cela évite les conflits avec d'autres paquets Python.

python -m venv cuga_env
source cuga_env/bin/activate  # Sous Windows : cuga_env\Scripts\activate

2. Installer CUGA et ses dépendances principales

Utilisez pip pour installer le paquet CUGA ainsi que les bibliothèques du fournisseur de LLM que vous prévoyez d'utiliser. Pour ce guide, nous installerons le support pour OpenAI, Anthropic et les modèles open-source via Hugging Face.

pip install cuga openai anthropic transformers torch

Le paquet cuga lui-même est léger — moins de 500 Ko. Les bibliothèques supplémentaires ajoutent des capacités pour différents backends.

3. Vérifier l'installation

Effectuez une vérification rapide pour vous assurer que CUGA est correctement installé et peut être importé.

python -c "from cuga import Agent; print('CUGA installé avec succès')"

Si vous voyez le message de succès, vous êtes prêt à configurer votre fournisseur de LLM.

4. Configurer vos clés API

CUGA lit les clés API à partir des variables d'environnement pour des raisons de sécurité. Définissez-les dans votre shell ou dans un fichier .env.

export OPENAI_API_KEY="votre-clé-openai-ici"
export ANTHROPIC_API_KEY="votre-clé-anthropic-ici"

Pour les modèles locaux, vous n'avez pas besoin de clés API — assurez-vous simplement que les transformateurs Hugging Face peuvent accéder au modèle (par exemple, meta-llama/Llama-2-7b-chat-hf).

5. Tester avec un agent simple

Créez un fichier nommé test_agent.py avec le contenu suivant pour vérifier que tout fonctionne :

from cuga import Agent

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Combien font 2 + 2 ?")
print(response)

Exécutez-le :

python test_agent.py

Vous devriez voir une réponse comme "La somme de 2 et 2 est 4."

Comprendre le harnais CUGA

Le harnais léger de CUGA se compose de trois composants principaux :

• Agent : La classe principale qui encapsule le LLM, les outils et la mémoire.
• Outil : Une fonction appelable que l'agent peut invoquer (par exemple, recherche web, calculatrice, lecteur de fichiers).
• Mémoire : Un stockage de contexte à court terme qui aide l'agent à maintenir un état entre les étapes.

Le harnais est conçu pour être minimal. Vous définissez des agents en quelques lignes de code, puis vous les composez en workflows. Cela contraste avec des frameworks plus lourds comme LangChain ou AutoGen, qui nécessitent plus de code standard.

Exemples d'utilisation : deux douzaines d'agents fonctionnels

Nous allons parcourir 24 exemples pratiques organisés par complexité. Chaque exemple est un script complet et exécutable. Par souci de concision, nous montrerons la logique principale — supposez que l'agent est initialisé comme ci-dessus.

Agents de base (Exemples 1 à 6)

Ces agents démontrent des tâches à tour unique avec des outils intégrés.

Exemple 1 : Réponse simple à une question

from cuga import Agent

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Quelle est la capitale de la France ?")
print(response)

Exemple 2 : Solveur mathématique

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Calcule l'intégrale de x^2 de 0 à 3.")
print(response)

Exemple 3 : Résumeur de texte

agent = Agent(model="claude-3-sonnet", provider="anthropic")
text = "Long article text here..."
response = agent.run(f"Résume ceci en 50 mots : {text}")
print(response)

Exemple 4 : Traducteur

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Traduis 'Bonjour, comment allez-vous ?' en anglais.")
print(response)

Exemple 5 : Explicateur de code

agent = Agent(model="gpt-4o", provider="openai")
code = "def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)"
response = agent.run(f"Explique ce code ligne par ligne : {code}")
print(response)

Exemple 6 : Analyseur de sentiments

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Analyse le sentiment : 'J'adore ce produit, mais la livraison était lente.'")
print(response)

Agents utilisant des outils (Exemples 7 à 12)

Ces agents utilisent le système d'outils intégré de CUGA. Nous allons d'abord définir un outil personnalisé.

Exemple 7 : Outil calculatrice

from cuga import Tool

def calculator(expression: str) -> str:
    return str(eval(expression))

calc_tool = Tool(name="calculator", func=calculator, description="Évalue des expressions mathématiques")
agent = Agent(model="gpt-4o", provider="openai", tools=[calc_tool])
response = agent.run("Combien font 345 * 678 ?")
print(response)

Exemple 8 : Outil de recherche web

import requests

def web_search(query: str) -> str:
    # Recherche simplifiée – en production, utilisez une API appropriée
    return f"Résultats pour {query} : [factice]"

search_tool = Tool(name="web_search", func=web_search, description="Recherche sur le web")
agent = Agent(model="gpt-4o", provider="openai", tools=[search_tool])
response = agent.run("Trouve des actualités récentes sur les agents IA.")
print(response)

Exemple 9 : Outil de lecture de fichier

def read_file(path: str) -> str:
    with open(path, 'r') as f:
        return f.read()

file_tool = Tool(name="file_reader", func=read_file, description="Lit un fichier depuis le disque")
agent = Agent(model="claude-3-sonnet", provider="anthropic", tools=[file_tool])
response = agent.run("Lis et résume 'data.txt'.")
print(response)

Exemple 10 : Outil d'exécution Python

def run_python(code: str) -> str:
    exec_globals = {}
    exec(code, exec_globals)
    return str(exec_globals)

python_tool = Tool(name="python_exec", func=run_python, description="Exécute du code Python")
agent = Agent(model="gpt-4o", provider="openai", tools=[python_tool])
response = agent.run("Calcule les 10 premiers nombres premiers en utilisant Python.")
print(response)

Exemple 11 : Outil date/heure

from datetime import datetime

def current_time() -> str:
    return datetime.now().isoformat()

time_tool = Tool(name="get_time", func=current_time, description="Obtient la date et l'heure actuelles")
agent = Agent(model="gpt-4o", provider="openai", tools=[time_tool])
response = agent.run("Quelle est l'heure actuelle en UTC ?")
print(response)

Exemple 12 : Envoi d'email (simulé)

def send_email(to: str, subject: str, body: str) -> str:
    # Simuler l'envoi
    return f"Email envoyé à {to} avec le sujet '{subject}'"

email_tool = Tool(name="send_email", func=send_email, description="Envoie un email")
agent = Agent(model="claude-3-sonnet", provider="anthropic", tools=[email_tool])
response = agent.run("Envoie un email à test@example.com avec le sujet 'Bonjour' et le corps 'Test'.")
print(response)

Agents de raisonnement multi-étapes (Exemples 13 à 18)

Ces agents utilisent la mémoire pour maintenir le contexte sur plusieurs tours.

Exemple 13 : Vérificateur de faits séquentiel

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("D'abord, trouve la population de Tokyo. Ensuite, compare-la à New York.")
print(response)

Exemple 14 : Solveur de problèmes étape par étape

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Résous : Un train quitte la gare A à 60 mph. Un autre quitte la gare B à 80 mph. Les gares sont distantes de 300 miles. Quand se rencontrent-ils ?")
print(response)

Exemple 15 : Assistant de recherche

def search_tool(query: str) -> str:
    return f"Résumé : {query}"

agent = Agent(model="gpt-4o", provider="openai", tools=[Tool(name="search", func=search_tool, description="Recherche")])
response = agent.run("Fais des recherches sur l'histoire des réseaux de neurones. Commence par les perceptrons, puis la rétropropagation, puis les transformeurs.")
print(response)

Exemple 16 : Planificateur de tâches

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Planifie un voyage de 3 jours à Paris. Inclus les vols, les hôtels et les attractions. Produis une liste.")
print(response)

Exemple 17 : Relecteur de code

agent = Agent(model="gpt-4o", provider="openai")
code = "def add(a,b): return a+b"
response = agent.run(f"Relis ce code pour les bugs et les problèmes de style : {code}")
print(response)

Exemple 18 : Analyseur de données

def analyze_data(data: str) -> str:
    return f"Moyenne : {sum(map(float, data.split(',')))/len(data.split(','))}"

data_tool = Tool(name="analyze", func=analyze_data, description="Analyse des nombres séparés par des virgules")
agent = Agent(model="gpt-4o", provider="openai", tools=[data_tool])
response = agent.run("Analyse le jeu de données : 10,20,30,40,50")
print(response)

Workflows complexes (Exemples 19 à 24)

Ces exemples combinent plusieurs agents ou des motifs avancés.

Exemple 19 : Agent avec logique conditionnelle

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Si le marché boursier est en hausse aujourd'hui, résume les gains. Sinon, suggère une stratégie.")
print(response)

Exemple 20 : Débat multi-agents

agent1 = Agent(model="gpt-4o", provider="openai", system_prompt="Tu es un partisan de l'énergie nucléaire.")
agent2 = Agent(model="claude-3-sonnet", provider="anthropic", system_prompt="Tu es un écologiste opposé à l'énergie nucléaire.")

topic = "Devrions-nous construire plus de centrales nucléaires ?"
response1 = agent1.run(topic)
response2 = agent2.run(topic)
print(f"Pour : {response1}\nContre : {response2}")

Exemple 21 : Agent orchestrant des outils

def weather_api(city: str) -> str:
    return f"Météo à {city} : 72°F, ensoleillé"

weather_tool = Tool(name="weather", func=weather_api, description="Obtenir la météo")
agent = Agent(model="gpt-4o", provider="openai", tools=[weather_tool, calc_tool])
response = agent.run("Obtiens la météo pour New York et calcule la différence avec 80°F.")
print(response)

Exemple 22 : Agent à mémoire persistante

from cuga import Memory

memory = Memory()
agent = Agent(model="claude-3-sonnet", provider="anthropic", memory=memory)
agent.run("Je m'appelle Alice.")
response = agent.run("Quel est mon nom ?")
print(response)  # Devrait se souvenir "Alice"

Exemple 23 : Agent avec gestion d'erreurs

agent = Agent(model="gpt-4o", provider="openai")
response = agent.run("Essaie de diviser 10 par 0. Si erreur, explique pourquoi.")
print(response)

Exemple 24 : Agent auto-améliorant

agent = Agent(model="claude-3-sonnet", provider="anthropic")
response = agent.run("Écris un court poème. Ensuite, critique-le et réécris-le mieux.")
print(response)

Conseils de configuration pour la production

Pour un déploiement en conditions réelles, envisagez ces réglages :

• Limitation de débit : Définissez max_retries et timeout dans le constructeur de l'Agent.
• Journalisation : Activez la journalisation intégrée de CUGA avec agent.logger.setLevel("INFO").
• Mise en cache : Utilisez un objet Cache pour éviter les appels API redondants pour des requêtes identiques.

Exemple avec configuration :

from cuga import Agent, Cache

cache = Cache(ttl=3600)
agent = Agent(model="gpt-4o", provider="openai", cache=cache, max_retries=3, timeout=30)

Conclusion

Le harnais léger de CUGA permet aux développeurs de créer de véritables applications agentiques avec un minimum de friction. Des simples questions-réponses au raisonnement multi-étapes et à l'orchestration d'outils, les deux douzaines d'exemples que nous avons couverts démontrent l'étendue de ce qui est possible. En exploitant une interface Python familière, CUGA réduit la courbe d'apprentissage tout en conservant la flexibilité pour des workflows avancés. Alors que l'industrie de l'IA — validée par les développements d'OpenAI, d'Anthropic, de Microsoft et de la communauté open-source sur Hugging Face — évolue vers des systèmes plus autonomes, des outils comme CUGA seront essentiels pour le prototypage et le déploiement en production. Commencez par les étapes d'installation ci-dessus, expérimentez avec les exemples et adaptez-les à vos propres cas d'utilisation. L'ère des applications agentiques est arrivée, et CUGA la rend accessible.