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.