Vous n'avez probablement pas besoin d'un framework d'agent.

Vous n'avez probablement pas besoin d'un framework d'agents

Le paysage de l'IA est actuellement inondé de frameworks d'agents promettant de simplifier le développement de systèmes autonomes. De LangChain à AutoGPT en passant par Semantic Kernel de Microsoft, ces outils proposent des abstractions pour la planification, l'utilisation d'outils et la mémoire. Cependant, un nombre croissant de praticiens affirment que pour la plupart des cas d'usage réels, vous n'avez pas besoin d'un framework lourd. Cet article explore pourquoi une approche minimale et directe surpasse souvent les couches d'orchestration complexes, et fournit un guide concret pour construire un agent simple en utilisant uniquement l'API OpenAI et Python standard.

Pourquoi les frameworks peuvent être excessifs

Les frameworks introduisent des dépendances, des courbes d'apprentissage et des comportements cachés. Selon une analyse récente publiée sur **Towards Data Science** (source 1), de nombreux frameworks d'agents abstraient la logique décisionnelle critique, rendant le débogage difficile et augmentant la latence. L'idée centrale est qu'un « agent » est fondamentalement une boucle : un modèle qui reçoit une instruction, décide d'une action, l'exécute et observe le résultat. Vous pouvez implémenter cette boucle en moins de 100 lignes de Python.

Les propres actualités d'OpenAI (source 2) mettent l'accent sur l'appel de fonctions et les sorties structurées comme les éléments de base pour les agents. Le blog IA de Microsoft (source 3) souligne également que les systèmes autonomes les plus fiables utilisent des schémas simples d'appel d'outils plutôt que des orchestrateurs monolithiques. Les actualités d'Anthropic (source 4) renforcent que les agents efficaces sont souvent simplement des modèles bien sollicités avec quelques outils externes.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Python 3.10 ou supérieur installé sur votre système
• Une clé API OpenAI (avec accès à `gpt-4o` ou `gpt-4-turbo`)
• Une familiarité de base avec la ligne de commande
• Un éditeur de code (VS Code recommandé)

Installation étape par étape

Nous allons créer un agent minimal capable de répondre à des questions en effectuant des recherches web ou des calculs. Pas de framework, pas de dépendances lourdes.

Étape 1 : Configurer un environnement virtuel

Isolez les dépendances de votre projet pour éviter les conflits.

python -m venv agent-env
source agent-env/bin/activate  # Sur Windows : agent-env\Scripts\activate

Étape 2 : Installer les paquets requis

Nous avons seulement besoin du client Python OpenAI et de `requests` pour les appels HTTP optionnels.

pip install openai requests

Étape 3 : Définir votre clé API

Stockez votre clé de manière sécurisée en tant que variable d'environnement. Remplacez `votre-clé-ici` par votre clé réelle.

export OPENAI_API_KEY="votre-clé-ici"  # Sur Windows : set OPENAI_API_KEY=votre-clé-ici

Étape 4 : Créer le script de l'agent

Créez un fichier nommé `minimal_agent.py` et ouvrez-le dans votre éditeur.

# minimal_agent.py
import json
import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Définir les outils disponibles (fonctions que le modèle peut appeler)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo actuelle pour une ville",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nom de la ville"}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Effectuer un calcul mathématique",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "Expression mathématique comme '2+2'"}
                },
                "required": ["expression"]
            }
        }
    }
]

# Implémentations simples des outils
def get_weather(city: str) -> str:
    # En production, appelez une vraie API météo
    return f"Le temps à {city} est ensoleillé, 22°C."

def calculate(expression: str) -> str:
    try:
        result = eval(expression)  # À utiliser avec prudence en production
        return f"Résultat : {result}"
    except Exception as e:
        return f"Erreur : {str(e)}"

# Boucle de l'agent
def agent_loop(user_input: str, max_turns: int = 5):
    messages = [{"role": "user", "content": user_input}]
    
    for turn in range(max_turns):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        assistant_message = response.choices[0].message
        
        # Si le modèle veut appeler un outil
        if assistant_message.tool_calls:
            messages.append(assistant_message)
            for tool_call in assistant_message.tool_calls:
                function_name = tool_call.function.name
                arguments = json.loads(tool_call.function.arguments)
                
                if function_name == "get_weather":
                    result = get_weather(**arguments)
                elif function_name == "calculate":
                    result = calculate(**arguments)
                else:
                    result = f"Fonction inconnue : {function_name}"
                
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
        else:
            # Le modèle a répondu directement
            return assistant_message.content
    
    return "Nombre maximum de tours atteint."

if __name__ == "__main__":
    query = input("Entrez votre question : ")
    print(agent_loop(query))

**Explication** : Ce script définit deux outils (météo et calculatrice), implémente la boucle de l'agent qui appelle l'API OpenAI avec les définitions de fonctions, et traite automatiquement les appels d'outils. Le modèle décide quand utiliser un outil ou répondre directement.

Exemples d'utilisation

Exemple 1 : Question simple

Exécutez l'agent et posez une question simple.

python minimal_agent.py

Lorsque invité, entrez :

Quelle est la capitale de la France ?

**Sortie attendue** : Le modèle répondra directement sans appeler d'outil, renvoyant quelque chose comme "La capitale de la France est Paris."

Exemple 2 : Question assistée par outil

Posez une question qui nécessite un appel d'outil.

python minimal_agent.py

Entrez :

Quel temps fait-il à Tokyo ?

**Sortie attendue** : Le modèle identifie qu'il a besoin de l'outil `get_weather`, l'appelle avec `city="Tokyo"`, reçoit le résultat et renvoie : "Le temps à Tokyo est ensoleillé, 22°C."

Exemple 3 : Raisonnement en plusieurs étapes

Posez une question nécessitant un calcul.

python minimal_agent.py

Entrez :

Qu'est-ce que 15 pourcent de 200 ?

**Sortie attendue** : Le modèle appelle l'outil `calculate` avec `expression="15/100*200"`, obtient `Résultat : 30.0`, et répond : "15 pourcent de 200 est 30."

Quand un framework peut être utile

Malgré la simplicité ci-dessus, les frameworks peuvent être bénéfiques dans des scénarios spécifiques :

• **Systèmes multi-agents complexes** où les agents doivent communiquer et déléguer des tâches entre eux
• **Gestion de mémoire de niveau production** avec des bases de données vectorielles et une rétention de contexte à long terme
• **Observabilité intégrée** pour le traçage, la journalisation et le débogage de chaînes complexes
• **Intégrations pré-construites** avec des dizaines de services et API externes

Cependant, comme le note l'article de **Towards Data Science** (source 1), la plupart des projets n'atteignent jamais cette complexité. Commencez sans framework ; ajoutez de la complexité uniquement lorsque vous avez un besoin avéré.

Conclusion

Le battage médiatique autour des frameworks d'agents obscurcit souvent une vérité simple : une boucle de base avec appel de fonctions gère la grande majorité des tâches autonomes. En implémentant votre propre agent minimal avec l'API OpenAI, vous obtenez un contrôle total, une latence réduite et un débogage plus facile. Vous évitez le verrouillage fournisseur et les bugs spécifiques au framework. Le guide étape par étape ci-dessus démontre qu'un agent fonctionnel peut être construit en quelques minutes avec seulement la bibliothèque cliente officielle.

Avant d'adopter un framework, demandez-vous : Mon cas d'usage nécessite-t-il vraiment une orchestration complexe, ou puis-je le résoudre avec un appel API direct et quelques lignes de Python ? Pour la plupart des applications, la réponse sera la seconde option. Commencez simplement, itérez, et n'utilisez un framework que lorsque vos besoins spécifiques l'exigent.