Como implementar Function Calling seguro com guardrails em LLMs

Por que o Function Calling precisa de guardrails na empresa?

Quando permitimos que modelos de inteligência artificial interajam com o mundo real através de chamadas de ferramentas, abrimos uma porta poderosa, mas também um vetor de risco considerável. Na prática, o recurso conhecido como Function Calling permite que a inteligência artificial escolha uma função programada e preencha seus parâmetros com base na conversa com o usuário. No entanto, sem barreiras de segurança adequadas — os chamados guardrails ou cercas de proteção —, o modelo pode ser enganado para apagar dados, consultar informações confidenciais ou executar código malicioso no servidor.

Para entender a gravidade do problema, imagine um assistente virtual de atendimento ao cliente conectado a uma API de banco de dados para cancelar assinaturas. Se um usuário mal-intencionado digitar um comando disfarçado dizendo para ignorar instruções anteriores e apagar todas as contas, uma IA despreparada pode tentar passar esse comando diretamente para a ferramenta. Como detalhamos no guia sobre como integrar IA a APIs externas, conectar modelos a sistemas corporativos exige vigilância constante sobre os dados que transitam entre a interface de conversação e o código backend.

A segurança em sistemas corporativos não pode depender apenas da boa vontade do modelo de linguagem. Mesmo os modelos mais modernos sofrem ocasionalmente com desvios de comportamento ou manipulações maliciosas conhecidas como injeção de prompt. Por isso, a engenharia de software moderna exige uma abordagem de defesa em profundidade, onde o modelo é tratado como um usuário externo não confiável cujas solicitações devem ser rigorosamente inspecionadas antes de tocar em qualquer banco de dados ou microserviço crítico.

Validando esquemas JSON com rigor estrito

O primeiro passo para garantir a segurança no uso de ferramentas é impor um contrato rígido entre a inteligência artificial e a sua aplicação através de esquemas estruturados. Em vez de aceitar texto livre gerado pelo modelo, a arquitetura deve utilizar especificações rigorosas como o JSON Schema para definir exatamente quais campos são permitidos, quais tipos de dados são aceitos e quais parâmetros são obrigatórios para cada função disponível.

Na prática, isso significa que se a ferramenta espera um número de identificação do cliente no formato inteiro, qualquer resposta gerada pela IA que contenha texto corrompido ou código executável será rejeitada imediatamente pela biblioteca de validação antes mesmo de alcançar a função de backend. Essa barreira impede que injeções de texto atravessem a fronteira do modelo para o código de negócios. Além disso, quando combinamos essa validação com estratégias eficientes de otimização de custos e latência, como o uso de cache semântico em LLMs, garantimos que respostas seguras e validadas também tragam economia operacional.

Ferramentas modernas de desenvolvimento oferecem suporte nativo para validação estrita de esquemas diretamente na camada de API do provedor de IA. No entanto, depender apenas da API externa não basta; a aplicação receptora deve revalidar o JSON recebido usando bibliotecas locais robustas e confiáveis. Essa dupla checagem assegura que mesmo que o provedor de IA sofra instabilidades ou alterações de comportamento, o seu sistema interno permaneça protegido contra cargas úteis malformadas ou maliciosas.

Sanitização e limpeza de parâmetros na prática

Validar a estrutura do JSON não é suficiente se o conteúdo interno dos parâmetros contiver dados perigosos ou maliciosos. A sanitização consiste no processo de limpar, filtrar ou escapar caracteres especiais que poderiam ser interpretados de maneira indesejada por bancos de dados, interpretadores de shell ou bibliotecas de terceiros. Cada parâmetro gerado pela IA deve ser tratado como uma entrada de usuário comum e submetido às mesmas regras de higiene de software.

Considere o seguinte exemplo simplificado em Python utilizando validação de esquemas e tratamento de parâmetros antes da execução de uma consulta interna:

import json
from jsonschema import validate, ValidationError

# Esquema estrito para a ferramenta de busca de usuários
USER_SCHEMA = {
    "type": "object",
    "properties":
        "username": {"type": "string", "pattern": "^[a-zA-Z0-9_]{3,20}$"}
    },
    "required": ["username"],
    "additionalProperties": False
}

def execute_safe_query(tool_call_arguments):
    try:
        # Valida o formato contra o esquema rígido
        validate(instance=tool_call_arguments, schema=USER_SCHEMA)
        
        # Sanitização adicional contra injeções
        username = tool_call_arguments["username"].strip()
        
        # Executa a operação de forma segura
        return f"Consultando banco para o usuário: {username}"
    except ValidationError as e:
        return f"Erro de segurança: parâmetros inválidos detectados. {e.message}"

Neste exemplo, o uso de uma expressão regular restrita no esquema garante que apenas caracteres alfanuméricos e sublinhados sejam aceitos no nome de usuário, bloqueando tentativas de inserção de caracteres especiais ou comandos SQL maliciosos. Se a IA tentar passar uma string contendo comandos adicionais, a validação falhará imediatamente e o sistema registrará um alerta de segurança.

Prevenção contra injeção de prompt em ambientes corporativos

A injeção de prompt ocorre quando instruções maliciosas são inseridas em dados processados pela inteligência artificial — como em e-mails recebidos, arquivos enviados ou páginas web lidas por um agente autônomo —, fazendo com que o modelo interprete esses dados como ordens diretas. Quando o modelo é enganado dessa forma, ele pode acionar ferramentas legítimas com argumentos fraudulentos criados pelo invasor.

Para mitigar esse risco em ambientes corporativos, é fundamental implementar barreiras de isolamento de contexto e separar claramente o que é instrução de sistema, o que é dado do usuário e o que é conteúdo externo não confiável. O uso de delimitadores claros e o treinamento de modelos de monitoramento secundários para inspecionar as intenções do agente antes da execução física das ferramentas ajudam a conter ações indesejadas.

Além disso, quando agentes autônomos realizam operações financeiras ou transações sensíveis, os guardrails devem exigir aprovação humana obrigatória (o conceito de human-in-the-loop) sempre que o montante ou o risco superarem um limite preestabelecido. Essa camada final de supervisão assegura que falhas na inteligência artificial não se traduzam em prejuízos operacionais ou financeiros reais para a organização. Para aprofundar esses conceitos na prática em produção, confira também nossa análise técnica sobre ChatGPT Wallet: Como agentes de IA fazem pagamentos seguros.

Considerações finais sobre governança de IA

Implementar Function Calling seguro não é apenas uma tarefa técnica pontual, mas um pilar fundamental da governança de inteligência artificial em qualquer empresa moderna. À medida que os agentes autônomos ganham mais autonomia para interagir com sistemas internos, APIs de pagamento e bancos de dados, a responsabilidade pela segurança dos dados passa a abranger tanto o código tradicional quanto o comportamento imprevisível dos modelos de linguagem.

Ao combinar validação estrita de esquemas JSON, sanitização profunda de parâmetros, isolamento rigoroso de contextos e aprovação humana em fluxos críticos, as organizações podem extrair o máximo potencial da inteligência artificial sem expor suas infraestruturas a riscos inaceitáveis. O investimento contínuo em monitoramento e auditoria dessas chamadas garante um ecossistema digital resiliente, preparado para crescer com segurança e previsibilidade.