Technical Tutorials

Les grands modèles de langage (LLM) sont passés de générateurs de texte statiques à des moteurs dynamiques capables de réaliser des tâches complexes. Cependant, leur véritable puissance dans la création d'agents IA robustes s'exprime via un mécanisme appelé Appel de fonction (également appelé utilisation d'outils ou appel d'action). Cette fonctionnalité permet aux modèles d'interagir avec le monde extérieur, les transformant de simples répondants passifs en résolveurs de problèmes actifs.

Qu'est-ce que l'Appel de fonction ?

Au cœur de l'appel de fonction se trouve une interface structurée entre le LLM et la logique backend de votre application. Au lieu d'obliger le modèle à halluciner des réponses ou de vous contraindre à analyser du texte non structuré, vous fournissez au modèle un schéma décrivant les fonctions disponibles. Le modèle décide ensuite quelle fonction invoquer et extrait les arguments nécessaires à partir de la demande de l'utilisateur.

Par exemple, si un utilisateur demande : « Quel temps fait-il à Londres ? », le modèle peut identifier qu'il ne dispose pas de données en temps réel. Au lieu de deviner, il peut générer une demande structurée pour appeler une fonction get_weather. Votre application exécute ensuite cette fonction, reçoit la réponse JSON en temps réel et la renvoie au modèle pour obtenir un résumé en langage naturel.

Définir le schéma

La base d'un appel de fonction efficace est une définition précise du schéma JSON. Ce schéma agit comme un contrat, garantissant que le modèle comprend les types d'entrées et de sorties requis. La précision est ici cruciale ; des schémas ambigus entraînent des appels échoués ou une extraction incorrecte des arguments.

Considérons un schéma simple pour un convertisseur de devises :

{
  "name": "convert_currency",
  "description": "Convertit un montant d'une devise à une autre.",
  "parameters": {
    "type": "object",
    "properties": {
      "amount": {
        "type": "number",
        "description": "La valeur numérique à convertir."
      },
      "from_currency": {
        "type": "string",
        "description": "Le code de la devise source (par ex., USD, EUR)."
      },
      "to_currency": {
        "type": "string",
        "description": "Le code de la devise cible."
      }
    },
    "required": ["amount", "from_currency", "to_currency"]
  }
}

La boucle de conversation

L'implémentation de l'appel de fonction nécessite un flux de conversation spécifique. Vous ne pouvez pas simplement envoyer la demande de l'utilisateur et attendre une réponse finale en une seule étape. Le processus implique généralement trois phases distinctes :

Demande initiale : L'utilisateur envoie une demande. Le LLM l'analyse et détermine si une fonction doit être appelée. Si oui, il renvoie une réponse structurée indiquant le nom de la fonction et les arguments.
Exécution : Le code backend détecte l'appel de fonction, exécute la logique réelle (par ex., interrogation d'une base de données ou d'une API externe) et capture le résultat.
Alimentation du contexte : Vous ajoutez le résultat de l'exécution de la fonction à l'historique de la conversation sous forme de message « sortie d'outil » et le renvoyez au LLM.

Voici un extrait de code conceptuel illustrant cette boucle en utilisant une structure de pseudo-bibliothèque :

def handle_llm_interaction(user_prompt, history):
    # Étape 1 : Envoyer la demande au LLM avec les définitions de fonctions
    response = llm.chat(messages=history, functions=weather_functions)
    
    if response.has_function_calls():
        for call in response.function_calls:
            # Étape 2 : Exécuter la fonction sur le backend
            result = execute_function(call.name, call.arguments)
            
            # Étape 3 : Ajouter le résultat de la fonction à l'historique
            history.append({
                "role": "function",
                "name": call.name,
                "content": str(result)
            })
        
        # Étape 4 : Renvoyer l'historique mis à jour au LLM pour la réponse finale
        final_response = llm.chat(messages=history)
        return final_response.text
    
    return response.text

Bonnes pratiques pour la production

Bien que l'appel de fonction simplifie le développement d'agents, il introduit de nouvelles complexités. Premièrement, gérez toujours les erreurs avec élégance. Si une fonction échoue en raison de problèmes réseau ou de données invalides, renvoyez un message d'erreur dans le champ « content » afin que le LLM puisse informer l'utilisateur de manière appropriée. Deuxièmement, évitez d'exposer trop de fonctions. Chaque outil supplémentaire augmente la charge cognitive du modèle, ce qui peut entraîner des temps de réponse plus longs ou une « dilution de l'attention ». Enfin, validez les arguments côté serveur. Ne faites jamais aveuglément confiance à l'extraction du LLM ; assurez-vous que les types de données correspondent strictement à votre schéma.

Conclusion

L'appel de fonction est le pont entre les connaissances statiques intégrées dans les poids des LLM et les données dynamiques du monde réel accessibles via les API. En maîtrisant ce modèle, les développeurs peuvent créer des agents qui non seulement comprennent l'intention, mais peuvent également agir en conséquence. À mesure que l'écosystème mûrit, des outils comme LangChain et LlamaIndex continueront d'abstraire une grande partie du code répétitif, permettant aux ingénieurs de se concentrer sur la conception de flux de travail intelligents et fiables qui résolvent les problèmes réels des utilisateurs.