Pourquoi les agents IA adoptent JSON Schema, Function Calling et MCP : évolution technique

En 2023, les plugins ChatGPT ont donné au monde un premier aperçu des modèles appelant des API. En 2024, Function Calling est devenu la norme chez tous les fournisseurs. En 2025, Anthropic a publié MCP et des IDE comme Cursor et Claude Desktop l'ont adopté. Dans le même arc, JSON a évolué d'un format d'échange de données vers celui d'Agent.système de saisieetprotocole de poignée de main.

Si vous créez des pipelines RAG, des workflows d'automatisation ou des produits de style Copilot, vous finirez par rencontrer trois termes :Schéma JSON(contraintes structurelles),Appel de fonction(le modèle sélectionne les outils et remplit les paramètres), etPCM(Model Context Protocol – connectivité d’outils standardisée). Cet article s'adresse aux développeurs d'applications backend, de plateforme et d'IA. Il explique pourquoi chaque couche a émergé, quel problème elle résout, comment elles s'articulent et comment choisir dans la pratique.

Pourquoi les agents ont besoin d'interfaces structurées

Le modèle de base des premières applications LLM était le suivant : les utilisateurs posaient des questions → le modèle générait un langage naturel → copiait manuellement les résultats pour exécution. C'est suffisant pour les scénarios de chat, mais cela ne peut pas piloter de manière fiable l'écriture de bases de données, l'envoi d'e-mails, la vérification de l'inventaire, etc.Répétable et vérifiabletâches automatisées.

Le mode ReAct (Reason + Act) sous le projet Prompt pur permet au modèle d'écrire "Action: search(query=...)" dans le texte, et le programme hôte utilise une analyse régulière - il peut s'exécuter, mais il est fragile : l'imbrication des crochets, l'échappement des guillemets et le mélange multilingue entraîneront un échec de l'analyse. Ce qu'exige l'environnement de production, c'estLisible par machine, vérifiable, versionnablecontrat au lieu de compter sur la chance pour analyser Markdown.

JSON répond à trois exigences : il existe en grande quantité dans les données de formation LLM, il peut être lu à la fois par les humains et les programmes, et il dispose d'un écosystème de vérification de schéma mature. En conséquence, JSON Schema est devenu la norme de facto pour décrire « quelle forme de données le modèle doit générer » ; Function Calling intègre également « quelle fonction appeler et quels paramètres transmettre » dans la même structure JSON.

Chronologie de l’évolution technologique

Les changements essentiels apportés à cette ligne sont :Traduire « ce que le modèle veut faire » du langage naturel en messages structurés typés, puis exécuté en toute sécurité par le programme hôte ou le serveur MCP.

Schéma JSON : le « système de types » de l'agent

Le schéma JSON était à l'origine utilisé pour la documentation des API et la vérification de la configuration (OpenAPI, Kubernetes CRD, etc.). Dans le scénario Agent, il assume deux types de responsabilités :

• Paramètres d'entrée de l'outil: Description search_products requires query (string) and limit (integer, default 10)
• Sortie du modèle: Par exemple, lors de l'extraction d'entités, d'étiquettes de classification, de conclusions d'approbation, etc., des champs fixes doivent être renvoyés pour une consommation en aval.

Paramètres d'outil typiques Schéma

{
  "type": "object",
  "properties": {
    "city": {
      "type": "string",
      "description": "City name, e.g. Beijing or Shanghai"
    },
    "unit": {
      "type": "string",
      "enum": ["celsius", "fahrenheit"],
      "description": "Temperature unit"
    }
  },
  "required": ["city"]
}

The description field is particularly important: it enters the context of the model and helps the model understand when to call and what the semantics of each parameter are - Schema also servesvalidateuretRapide.

Sorties structurées et schéma

Si seul le schéma est écrit dans Prompt, le modèle peut toujours contenir des champs supplémentaires ou des erreurs de type. Le mode Sorties structurées/JSON fourni par OpenAI, Google, etc. contraindra les jetons pendant l'étape de décodage afin que la sortie soit strictement conforme au schéma. C’est une nécessité pour le pipeline de type « Invoice OCR → Structured JSON → Accounting System ».

Suggestions pendant la phase de développement : utilisez d'abord des outils tels que la boîte à outils JSONSyntaxe du schéma de vérification locale, and then use the sample payload to verify whether required and enum intercept illegal input as expected.

Appel de fonction : poignée de main entre les modèles et les outils

L'appel de fonction (également appelé Tool Use, Tools API par divers fournisseurs) définit la communication entre le modèle et l'hôte.une série de poignées de main:

1. L'hôte envoie la liste d'outils (nom, description, schéma des paramètres) au modèle avec des messages
2. The model does not directly execute the code, but returns tool_calls: selected tool name + JSON parameter string
3. The host executes the real function (check DB, adjust HTTP), and stuff the result back into the conversation as tool role message
4. Le modèle génère des réponses visibles pour l'utilisateur final en fonction des résultats

Comparaison avec le mode texte ReAct

Function Calling n’élimine pas le framework Agent (LangChain, AutoGen, Cursor Agent, etc.), mais devient l’interface entre le framework et le modèle.fine couche de protocole——Le framework est responsable de l'orchestration, des nouvelles tentatives et de la mémoire ; l'API du modèle est chargée de « décider quel outil appeler ».

MCP : écosystème d'outils enfichables

Function Calling résout le problème de « comment déclarer l’appel côté modèle ». Mais lorsque le nombre d’outils augmente et que les sources se dispersent (GitHub, Slack, Postgres, navigateurs, systèmes de fichiers), de nouveaux problèmes surgissent :

• Chaque hôte (IDE, client Chat, agent auto-construit) doit écrire une adaptation pour chaque outil.
• Les autorisations, les informations d'identification et les méthodes de transport stdio/HTTP sont indépendantes les unes des autres
• Les utilisateurs ne peuvent pas « installer un serveur MCP et le rendre disponible partout »

Protocole de contexte de modèle (MCP)Open source par Anthropic fin 2024, il se positionne comme un protocole standard entre Host et Tool Provider. La relation d'analogie est grossièrement :

Concepts fondamentaux du MCP

• Hôte: L'application qui a initié la connexion (telle que Cursor IDE)
• Client: Client MCP dans l'hôte, maintien de la session avec le serveur
• Serveur: processus qui exposent des outils, des ressources et des invites (tels que filesystem-mcp, github-mcp)
• Capacités: La liste d'outils est découverte dynamiquement au lieu d'être codée en dur dans Prompt.

MCP Tool's inputSchema itself is JSON Schema. Therefore, MCP does not replace Function Calling, but standardizes "tool implementation"; Host may still use MCP toolscartographieFormat d'appel de fonction pour l'API du modèle.

Comment les trois travaillent ensemble

Utilisez une couche logique pour comprendre la relation entre les trois :

┌─────────────────────────────────────────────┐
│  用户 / 业务系统                              │
└─────────────────────┬───────────────────────┘
                      ▼
┌─────────────────────────────────────────────┐
│  Agent Host（编排、权限、记忆）               │
│  ┌─────────────┐    ┌─────────────────────┐ │
│  │ LLM API     │◄──►│ Function Calling    │ │
│  │ (推理)      │    │ (tool_calls 消息)   │ │
│  └─────────────┘    └─────────────────────┘ │
│           ▲                    │              │
│           │ JSON Schema        ▼              │
│  ┌────────┴────────┐  ┌──────────────────┐  │
│  │ 输出 Schema     │  │ MCP Client       │  │
│  │ (Structured     │  │ ──stdio/SSE──►   │  │
│  │  Outputs)       │  │ MCP Server(s)    │  │
│  └─────────────────┘  └──────────────────┘  │
└─────────────────────────────────────────────┘

• Schéma JSON: Coupe transversale de chaque couche - paramètres de l'outil, schéma d'entrée MCP, sortie structurée du modèle
• Appel de fonction: Modèle ↔ Syntaxe d'appel de l'hôte
• PCM:Hôte ↔ Bus d'outils pour le monde extérieur

Les petits scripts ne peuvent avoir que des appels de fonctions + quelques fonctions locales ; Les plates-formes d'agents au niveau de l'entreprise utilisent souvent des clusters MCP + un registre de schémas unifié + des journaux d'audit.

Exemple complet de lien d'appel

L'utilisateur a demandé : « Quelle est la température à Shanghai aujourd'hui ? Au fait, vérifiez mon entrepôt lié au schéma JSON sur GitHub.

1. HôtePull available tools from MCP: get_weather, github_search_repos
2. Converti en un tableau d'outils de l'API du modèle, chacun avec des paramètres de schéma JSON
3. ModèleRenvoie deux tool_calls, les paramètres sont tous deux légaux JSON
4. HôteAppelez le serveur météo et le serveur github via MCP pour collecter les résultats JSON
5. Les résultats sont renvoyés sous forme de messages d'outil ; le modèle synthétise les réponses en langage naturel
6. Si vous devez l'écrire dans le système de bon de travail, utilisezSchéma de sortieConstraint final JSON: { "summary", "temperature", "repo_count" }

Si un paramètre d'étape n'est pas conforme au schéma, l'hôte peut le rejeter et demander au modèle de réessayer avant l'exécution - c'est difficile à faire avec le texte ReAct.échec rapide.

Comparaison de sélection et bonnes pratiques

Points de conception de schéma

• Field description clearly writes business semantics, which can reduce miscalls better than type alone.
• required Better to be strict than loose; use default or explicitly nullable for optional fields
• Use string + description instead for large enumerations to avoid the enum list being too long and occupying the context
• Le schéma est intégré à la gestion des versions de Git et la révision du code est effectuée de la même manière que les modifications de l'API.

FAQ

Résumé et prochaines étapes

La transformation de l'agent AI de « pouvoir discuter » à « pouvoir faire des choses » repose sur le verrouillage de l'incertitude dans des limites structurées couche par couche : JSON Schema définit la forme, Function Calling définit la manière dont le modèle s'étend et MCP définit la manière dont l'outil se connecte à l'écosystème. Les trois ne se substituent pas l’un à l’autre ;Différentes couches sur la même pile.

Suggestion d'étape suivante : prenez un véritable outil commercial (vérifier les commandes, envoyer des notifications), écrivez un schéma JSON pour celui-ci → connectez-vous à Function Calling et exécutez un seul tour → puis évaluez s'il vaut la peine de l'encapsuler en tant que serveur MCP pour une réutilisation de plusieurs hôtes. Le schéma et les exemples de données peuvent être vérifiés localement dans la boîte à outils JSON avant d'être mis en ligne.