Por que agentes de IA usam JSON Schema, Function Calling e MCP: evolução técnica completa

Em 2023, os plug-ins ChatGPT deram ao mundo uma primeira visão dos modelos que chamam APIs. Em 2024, a chamada de função tornou-se padrão entre os fornecedores. Em 2025, a Anthropic lançou o MCP, e IDEs como Cursor e Claude Desktop o adotaram - no mesmo arco, o JSON evoluiu de um formato de troca de dados para o formato do Agente.sistema de tipoeprotocolo de aperto de mão.

Se você estiver construindo pipelines RAG, fluxos de trabalho de automação ou produtos estilo Copilot, eventualmente encontrará três termos:Esquema JSON(restrições estruturais),Chamada de função(o modelo escolhe ferramentas e preenche parâmetros) ePCM(Model Context Protocol – conectividade de ferramenta padronizada). Este artigo é para desenvolvedores de back-end, plataforma e aplicativos de IA. Ele explica por que cada camada surgiu, qual problema ela resolve, como elas se encaixam e como escolher na prática.

Por que os agentes precisam de interfaces estruturadas

O padrão central dos primeiros aplicativos LLM era: os usuários faziam perguntas → o modelo gerava linguagem natural → copiava manualmente os resultados para execução. Isso é suficiente para cenários de bate-papo, mas não pode conduzir de forma confiável a gravação de banco de dados, o envio de e-mails, a verificação de inventário, etc.Repetível e auditáveltarefas automatizadas.

O modo ReAct (Reason + Act) no projeto Prompt puro permite que o modelo escreva "Action: search(query=...)" no texto, e o programa host usa análise regular - ele pode ser executado, mas é frágil: aninhamento de colchetes, escape de aspas e mistura de vários idiomas causarão falha na análise. O que o ambiente de produção exige éLegível por máquina, verificável, versionávelcontrato em vez de confiar na sorte para analisar Markdown.

JSON atende a três requisitos: existe em grandes quantidades em dados de treinamento LLM, pode ser lido tanto por humanos quanto por programas e possui um ecossistema maduro de verificação de esquema. Como resultado, o JSON Schema tornou-se o padrão de fato para descrever "que formato de dados o modelo deve produzir"; A chamada de função também incorpora "qual função chamar e quais parâmetros passar" na mesma estrutura JSON.

Cronograma de evolução da tecnologia

As alterações essenciais nesta linha são:Traduza "o que o modelo deseja fazer" da linguagem natural em mensagens estruturadas digitadase, em seguida, executado com segurança pelo programa host ou servidor MCP.

Esquema JSON: “sistema de tipos” do agente

O esquema JSON foi originalmente usado para documentação de API e verificação de configuração (OpenAPI, Kubernetes CRD, etc.). No cenário Agente, assume dois tipos de responsabilidades:

• Parâmetros de entrada da ferramenta: Description search_products requires query (string) and limit (integer, default 10)
• Saída do modelo: Por exemplo, ao extrair entidades, rótulos de classificação, conclusões de aprovação, etc., os campos fixos devem ser retornados para consumo posterior.

Esquema de parâmetros típicos da ferramenta

{
  "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 servesvalidadoreIncitar.

Saídas Estruturadas e Esquema

Se apenas Schema for escrito no Prompt, o modelo ainda poderá ter campos extras ou erros de tipo. Saídas estruturadas/modo JSON fornecido por OpenAI, Google, etc. restringirão os tokens durante o estágio de decodificação para que a saída esteja estritamente em conformidade com o esquema. Esta é uma necessidade para o tipo de pipeline "OCR de fatura → JSON estruturado → Sistema de contabilidade".

Sugestões durante a fase de desenvolvimento: primeiro use ferramentas como a caixa de ferramentas JSONSintaxe do esquema de verificação local, and then use the sample payload to verify whether required and enum intercept illegal input as expected.

Chamada de Função: Handshake entre modelos e ferramentas

A Chamada de Função (também chamada de Uso de Ferramenta, API de Ferramentas por vários fornecedores) define a comunicação entre o modelo e o host.uma rodada de apertos de mão:

1. O host envia a lista de ferramentas (nome, descrição, esquema de parâmetros) para o modelo junto com mensagens
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. O modelo gera respostas visíveis para o usuário final com base nos resultados

Comparação com o modo de texto ReAct

A Chamada de Função não elimina a estrutura do Agente (LangChain, AutoGen, Cursor Agent, etc.), mas se torna a interface entre a estrutura e o modelo.camada de protocolo fina——A estrutura é responsável pela orquestração, novas tentativas e memória; a API do modelo é responsável por "decidir qual ferramenta chamar".

MCP: ecossistema de ferramentas conectáveis

A chamada de função resolve o problema de "como declarar a chamada no lado do modelo". Mas quando o número de ferramentas cresce e as fontes se dispersam (GitHub, Slack, Postgres, navegadores, sistemas de arquivos), surgem novos problemas:

• Cada Host (IDE, cliente de Chat, Agente autoconstruído) deve escrever uma adaptação para cada ferramenta.
• Permissões, credenciais e métodos de transporte stdio/HTTP são independentes uns dos outros
• Os usuários não podem “instalar um servidor MCP e disponibilizá-lo em qualquer lugar”

Protocolo de Contexto do Modelo (MCP)De código aberto pela Anthropic no final de 2024, é posicionado como um protocolo padrão entre o Host e o Provedor de Ferramentas. A relação de analogia é aproximadamente:

Conceitos básicos do MCP

• Hospedar: O aplicativo que iniciou a conexão (como Cursor IDE)
• Cliente: Cliente MCP no Host, mantendo sessão com o Servidor
• Servidor: processos que expõem ferramentas, recursos e prompts (como filesystem-mcp, github-mcp)
• Capacidades: a lista de ferramentas é descoberta dinamicamente em vez de codificada no 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 toolsmapeamentoFormato de chamada de função para a API do modelo.

Como os três trabalham juntos

Use uma camada lógica para entender a relação entre os três:

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

• Esquema JSON: Corte transversal de cada camada - parâmetros da ferramenta, esquema de entrada MCP, saída estruturada do modelo
• Chamada de função: Modelo ↔ Sintaxe de chamada de host
• PCM:Host ↔ Barramento de ferramentas para o mundo externo

Scripts pequenos podem ter apenas Chamadas de Função + algumas funções locais; As plataformas de agente de nível empresarial geralmente usam clusters MCP + registro de esquema unificado + logs de auditoria.

Exemplo completo de link de chamada

O usuário perguntou: "Qual é a temperatura em Xangai hoje? A propósito, verifique meu armazém relacionado ao esquema json no GitHub."

1. HospedarPull available tools from MCP: get_weather, github_search_repos
2. Convertido em uma matriz de ferramentas da API do modelo, cada uma com parâmetros do esquema JSON
3. ModeloRetorna duas tool_calls, os parâmetros são JSON legais
4. HospedarChame o Weather Server e o GitHub Server via MCP para coletar resultados JSON
5. Os resultados são retornados como mensagens de ferramentas; o modelo sintetiza respostas em linguagem natural
6. Se você precisar escrevê-lo no sistema de ordem de serviço, useEsquema de saídaConstraint final JSON: { "summary", "temperature", "repo_count" }

Se algum parâmetro da etapa não estiver em conformidade com o esquema, o host poderá rejeitá-lo e solicitar que o modelo tente novamente antes da execução - isso é difícil de fazer com o texto ReActfalha rápida.

Comparação de seleção e melhores práticas

Pontos de design de esquema

• 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
• O esquema é incorporado ao gerenciamento de versões do Git e a revisão do código é feita da mesma forma que as alterações da API.

Perguntas frequentes

Resumo e próximas etapas

A transformação do Agente de IA de “capaz de conversar” para “capaz de fazer coisas” depende do bloqueio da incerteza em limites estruturados, camada por camada: o esquema JSON define a forma, a chamada de função define como o modelo se estende e o MCP define como a ferramenta se conecta ao ecossistema. Os três não são substitutos um do outro;Diferentes camadas na mesma pilha.

Sugestão para o próximo passo: pegue uma ferramenta de negócios real (verifique pedidos, envie notificações), escreva o esquema JSON para ela → conecte-se à chamada de função e execute uma única rodada → então avalie se vale a pena encapsulá-la como um servidor MCP para reutilização de vários hosts. Os dados de esquema e de amostra podem ser verificados localmente na caixa de ferramentas JSON antes de ficarem online.