Outils et intégrations

1. Introduction

#

Les outils (Tools) permettent aux agents IA d’interagir avec leur environnement : lire des fichiers, exécuter du code, interroger des APIs ou modifier des ressources externes.

Un LLM isolé ne réalise pas directement ces opérations. Il produit une demande d’action, ensuite exécutée par le harness ou un système connecté.

Plusieurs mécanismes interviennent :

Ces notions sont complémentaires et ne correspondent pas au même niveau d’abstraction.

2. Tool Calling et Function Calling

#

Le Tool Calling désigne le mécanisme par lequel un modèle demande l’utilisation d’un outil.

Le Function Calling constitue une forme courante de ce mécanisme, où le modèle produit un appel de fonction structuré.

Fonctionnement

#

1. Le harness présente les outils disponibles au modèle.
2. Le modèle sélectionne un outil et génère ses arguments.
3. Le harness valide les arguments et les autorisations.
4. L’outil est exécuté.
5. Le résultat est transmis au modèle.

Exemple : interroger une base de données

#

Un outil peut être exposé avec une définition structurée :

{
  "name": "count_job_offers",
  "description": "Compter les offres d'emploi selon leur catégorie",
  "parameters": {
    "type": "object",
    "properties": {
      "scope_class": {
        "type": "string",
        "enum": ["DATA", "REVIEW", "NON_DATA"]
      }
    },
    "required": ["scope_class"]
  }
}

L’agent peut alors demander :

{
  "scope_class": "DATA"
}

L’application exécute la fonction correspondante, puis retourne le résultat.

Le modèle choisit l’appel, mais n’exécute pas lui-même le code de la fonction.

Le tool calling peut être réalisé avec des fonctions locales, des APIs distantes ou des outils fournis par un framework.

3. APIs et CLI

#

Les APIs et les CLI constituent deux moyens courants d’interagir avec un environnement externe.

Exemple : API

#

Un agent pourrait interroger un service REST :

import requests

response = requests.get(
    "https://api.example.com/jobs",
    params={"category": "data"},
    timeout=10,
)
response.raise_for_status()

jobs = response.json()

L’accès nécessite un outil capable d’effectuer la requête et disposant des autorisations nécessaires.

Exemple : CLI

#

Un agent de développement peut utiliser un terminal :

uv run pytest
uv run ruff check .
git status

Les commandes permettent notamment de :

• exécuter des tests ;
• analyser du code ;
• gérer les dépendances ;
• manipuler Git ;
• lancer des pipelines.

Les CLI sont particulièrement utiles aux agents de développement, car elles permettent de réutiliser directement les outils existants du projet.

4. Model Context Protocol (MCP)

#

Le Model Context Protocol (MCP) est un protocole ouvert standardisant les échanges entre applications IA et systèmes externes.

Il évite de devoir développer une intégration spécifique pour chaque combinaison d’agent et de service.

Architecture MCP

#

Un host peut gérer plusieurs clients, chacun connecté à un serveur MCP.

Les trois primitives principales

#

Un serveur MCP peut exposer :

Les Tools permettent de demander des actions, tandis que les Resources mettent à disposition des informations.

Transports

#

MCP prend notamment en charge :

• stdio : communication avec un processus local.
• Streamable HTTP : communication avec un serveur distant ou local via HTTP.

Exemple : serveur MCP PostgreSQL

#

Un serveur MCP pourrait exposer plusieurs outils :

• list_tables : lister les tables ;
• describe_table : examiner un schéma ;
• execute_query : exécuter une requête SQL autorisée.

L’agent découvre ces fonctionnalités via MCP et peut les utiliser à travers son harness.

MCP standardise l’interface d’accès aux capacités ; il ne remplace ni le LLM ni le harness.

5. Différence entre Tool Calling et MCP

#

Les deux mécanismes interviennent à des niveaux différents.

Exemple :

1. Un serveur MCP expose un outil search_documents.
2. Le harness découvre cet outil.
3. Le modèle demande son utilisation via tool calling.
4. Le client MCP transmet l’appel au serveur.
5. Le résultat revient au modèle.

Il est donc possible d’utiliser le tool calling sans MCP, et d’accéder à des outils MCP grâce au tool calling.

6. Skills et outils

#

Un Skill est une procédure réutilisable qui explique à l’agent comment accomplir une tâche.

Il peut contenir :

• des instructions (SKILL.md) ;
• des scripts ;
• des références documentaires ;
• des templates ;
• des conventions de validation.

Différence fondamentale

#

Exemple : audit de qualité des données

#

Un skill data-quality-audit pourrait demander à l’agent de :

1. Examiner les schémas et contraintes.
2. Vérifier les valeurs manquantes.
3. Détecter les doublons.
4. Comparer les volumes.
5. Exécuter les tests.
6. Produire une synthèse.

Pour réaliser ces opérations, l’agent peut utiliser :

• une CLI Python ;
• une connexion DuckDB ;
• un serveur MCP SQL ;
• des scripts fournis par le skill.

Un skill peut orchestrer plusieurs outils, mais ne constitue pas nécessairement un outil exécutable.

Voir : Organisation d’un projet agentique.

7. Sélection et conception des outils

#

Multiplier les outils disponibles n’améliore pas systématiquement les performances d’un agent.

Un catalogue trop important peut compliquer leur sélection et augmenter le volume du contexte.

Bonnes pratiques

#

Granularité

#

Deux approches sont possibles :

• Outils spécialisés : list_tables, count_rows, describe_schema.
• Outils génériques : execute_sql, run_shell.

Les outils spécialisés facilitent le contrôle des actions.

Les outils génériques offrent davantage de flexibilité, mais nécessitent des restrictions plus rigoureuses.

Un outil SQL en lecture seule est généralement préférable à un accès SQL illimité pour un agent chargé uniquement d’analyser des données.

8. Sécurité des intégrations

#

Les outils représentent une surface de risque importante, puisqu’ils permettent à l’agent d’agir sur des systèmes réels.

Principes essentiels

#

• Séparer les outils de lecture et d’écriture.
• Restreindre les accès aux ressources nécessaires.
• Ne pas exposer inutilement de secrets.
• Valider les arguments avant l’exécution.
• Journaliser les actions sensibles.
• Exiger une approbation pour les opérations critiques.

Une description d’outil ou une instruction dans un prompt ne constitue pas une restriction de sécurité suffisante.

Les contrôles doivent être appliqués par le harness et les systèmes externes.

9. Synthèse

#

Les intégrations permettent aux agents IA de dépasser la simple génération de texte pour agir sur des environnements logiciels.

Les principales notions sont :

• Tool : capacité accessible à l’agent.
• Tool Calling : mécanisme permettant au modèle de demander une action.
• Function Calling : appel structuré d’une fonction.
• API : interface de communication avec un service.
• CLI : interface d’exécution de commandes.
• MCP : protocole standardisant l’accès aux outils, ressources et prompts.
• Skill : procédure réutilisable mobilisant éventuellement plusieurs outils.

Le choix d’une intégration dépend des capacités nécessaires, de la simplicité d’implémentation et des exigences de sécurité.

Un projet agentique peut fonctionner uniquement avec quelques outils locaux. MCP et les skills deviennent utiles lorsqu’ils répondent à des besoins concrets de réutilisation, de standardisation ou d’intégration.

Références

#

• OpenAI — Using Tools
• OpenAI — Function Calling
• Model Context Protocol — Documentation
• Model Context Protocol — Architecture
• OpenAI — Skills