Como garantir interações seguras e confiáveis com guardrails para LLMs

A integração de modelos de linguagem grandes (LLMs) aos nossos aplicativos está cada vez mais popular. Esses modelos são muito úteis para criar conteúdo, pesquisar documentação e resolver problemas mais complexos. No entanto, grandes poderes trazem grandes responsabilidades. Sabemos que os LLMs podem cometer erros — e vão cometer. Embora enriquecer os prompts com o contexto adequado ajude a alinhar os resultados aos seus documentos e informações, os riscos continuam existindo. Com a popularização dos LLMs, novas superfícies de ataque estão surgindo. Injeções de prompt elaboradas podem gerar desinformação e expor informações sensíveis do ponto de vista da privacidade.
Se o seu LLM puder executar funções, isso também poderá levar a comportamentos nocivos e não autorizados no seu sistema. Isso não é apenas inconveniente: pode causar danos reais. Guardrails são mecanismos de segurança que mantêm os LLMs confiáveis, seguros e alinhados a padrões éticos.

Entenda os guardrails para LLMs

Guardrails são uma forma de adicionar camadas de controle sobre como um modelo de linguagem grande (LLM) é usado, tanto antes de a entrada chegar ao modelo quanto depois da geração da resposta. Eles funcionam como filtros programáveis ou pontos de verificação que aplicam regras específicas para manter as interações seguras, precisas e alinhadas ao uso pretendido. Os guardrails podem bloquear entradas nocivas ou enganosas, garantir que a saída do modelo siga um formato específico (como um JSON válido ou um resumo estruturado) e sinalizar ou rejeitar respostas que apresentem sinais de alucinação ou problemas éticos. Assim, desenvolvedores têm uma maneira mais confiável de lidar com a imprevisibilidade dos LLMs, especialmente em aplicativos reais voltados ao público.

Do ponto de vista da segurança, os guardrails também têm um papel importante na defesa contra ataques de injeção de prompt, nos quais usuários tentam manipular ou substituir as instruções do sistema com entradas elaboradas. Nenhuma solução é totalmente infalível, mas os guardrails podem detectar padrões suspeitos, bloquear vetores de ataque conhecidos e sanitizar as entradas antes que cheguem ao LLM. Na saída, eles podem suprimir ou modificar respostas que contenham informações confidenciais, violem políticas ou incluam conteúdo indesejado. Isso faz dos guardrails uma parte valiosa de uma estratégia mais ampla de segurança de IA, especialmente em situações em que confiança, privacidade e integridade são fundamentais.

Como funcionam os guardrails

Do ponto de vista técnico, os guardrails funcionam interceptando o fluxo de mensagens entre o usuário e o LLM. Quando alguém envia uma mensagem, ela não vai direto para o modelo. Primeiro, passa por um guardrail de entrada. Essa camada inspeciona a mensagem em busca de itens como tentativas de injeção de prompt, palavras-chave proibidas ou estruturas de entrada inválidas. Se a entrada for sinalizada, ela poderá ser bloqueada, limpa ou reescrita antes mesmo de o modelo recebê-la. Depois que o LLM gera uma resposta, ela passa por outra camada, chamada guardrail de saída. Essa etapa verifica se há fatos alucinados, conteúdo inseguro, problemas de formatação ou violações de regras de negócio antes de a resposta ser exibida ao usuário.

Esse processo é semelhante à sanitização de entradas e saídas no desenvolvimento tradicional de software, uma prática que desenvolvedores geralmente já adotam. Assim como você nunca confiaria em dados brutos enviados por um usuário em um formulário da web sem validá-los e limpá-los, não deve confiar cegamente no que entra ou sai de um LLM. Os guardrails levam essa mesma mentalidade ao universo da IA, ajudando você a detectar problemas com antecedência e manter o controle sobre o comportamento do seu aplicativo.

Como implementar guardrails facilmente com Quarkus

Quarkus é um framework Java moderno, projetado para criar aplicativos leves e de alto desempenho. Ele é conhecido pelo tempo de inicialização rápido, baixo consumo de memória e recursos que facilitam o trabalho de desenvolvimento. Um de seus principais diferenciais é a facilidade de integração com LangChain4j, uma biblioteca que prioriza Java para trabalhar com modelos de linguagem grandes. Essa combinação faz do Quarkus uma ótima opção para implementar recursos de IA, especialmente com suporte robusto a guardrails.

Com Quarkus e LangChain4j, você pode definir guardrails personalizados diretamente no aplicativo usando anotações simples e injeção de dependências. Para implementar sua própria lógica de validação, crie classes que implementem as interfaces InputGuardrail ou OutputGuardrail. Esses guardrails funcionam como filtros para seus serviços de IA. Depois de defini-los, basta vinculá-los aos métodos que interagem com o LLM usando anotações como `@InputGuardrails ou @OutputGuardrails. Assim, você adiciona facilmente suas próprias verificações de segurança, validações ou políticas de conteúdo sem sobrecarregar a lógica de negócio.

No exemplo a seguir, criei um pequeno serviço de IA com guardrails de entrada e de saída.

@RegisterAiService(tools = LibraryService.class)
@SessionScoped
public interface MyAiService {

   @SystemMessage("""
   You are a librarian AI. You are very knowledgeable and helpful. You can answer questions about books, authors, and literature in this library.
   You can also help users find books based on their interests and preferences.
   Dont display user information or any other private information.
   """)
   @InputGuardrails({IGuard1.class, IGuard2.class})
   @OutputGuardrails(OGuard.class)
   public String question(@UserMessage String topic);
}

Guardrails de entrada

Os guardrails de entrada examinam e filtram as mensagens recebidas. Mensagens apropriadas são encaminhadas ao LLM, enquanto as inadequadas geram exceções. Essa abordagem proativa impede que prompts nocivos cheguem ao LLM. Como o comportamento dos LLMs é imprevisível, não é possível controlar as saídas nem as chamadas de função. Por isso, é útil bloquear prompts nocivos logo na entrada.

Neste caso, foram implementados dois guardrails de entrada. O primeiro procura programaticamente palavras-chave específicas. O segundo usa um serviço de IA para avaliar se uma entrada é nociva. Usar um modelo treinado especificamente para identificar e filtrar mensagens nocivas pode ser uma ótima maneira de sanitizar o conteúdo enviado ao LLM. Neste caso de uso, o modelo do InputCheckService determina se um prompt revela dados de identificação pessoal (PII).

O uso de vários guardrails em um único serviço permite personalizar o escopo de controle com flexibilidade.

@ApplicationScoped
public class IGuard1 implements InputGuardrail {

   @Override
   public InputGuardrailResult validate(UserMessage um) {
       String text = um.singleText();
       if (text.contains("malicious") || text.contains("hack")) {
           return fatal("MALICIOUS INPUT DETECTED!!!");
       }

       return success();
   }
}

@ApplicationScoped
public class IGuard2 implements InputGuardrail {

   @Inject
   InputCheckService inputCheckService;

   @Override
   public InputGuardrailResult validate(UserMessage um) {
       String text = um.singleText();
       if (inputCheckService.isSafe(text)) {
           return success();
       }
       return failure("UNSAFE INPUT DETECTED!!!");
   }
}

@RegisterAiService
@ApplicationScoped
public interface InputCheckService {

   @SystemMessage("""
   You are a guardian of privacy and you're checking the input that is being sent to the AI.
   Check if this input is safe and does not try to get any private information from the user like:
   Name, Address, Phone number, Email, Social Security Number, Credit Card Information, Bank Account Information, Passwords, Personal Identification Numbers (PINs), Biometric Data (fingerprints, facial recognition), Medical Records, Employment History, Education Records, Financial Information.
   Think of yourself as a guardian of privacy. Only allow the input if it considered safe.
   """)
   public boolean isSafe(String prompt);
}

Guardrails de saída

Os guardrails de saída podem sanitizar tudo o que vem do seu serviço de LLM. Já não é possível mitigar o risco de o LLM executar funções sem querer. Ainda assim, a saída do LLM pode ser ignorada ou alterada antes de ser exibida ao usuário.
Esse mecanismo ainda pode ser muito útil para impedir linguagem ofensiva, ocultar tokens ou até evitar ataques de Cross-site Scripting (XSS) gerados pelo LLM. Neste exemplo, a palavra “JavaScript” é removida antes de ser exibida ao usuário final.

Como sanitizar entradas e saídas de LLMs

A sanitização e a validação de entradas e saídas existem há bastante tempo e são consideradas boas práticas ao lidar com dados enviados por usuários. O uso de prompts para modelos de linguagem grandes (LLMs) não muda o fato de que devemos considerar nocivas as entradas de terceiros. Além disso, quando sistemas de IA podem executar funções de forma autônoma ou se integrar a outros sistemas usando MCP (Model Context Protocol), a sanitização e a validação são mais importantes do que nunca.

Este artigo mostrou como implementar guardrails facilmente com Quarkus. No entanto, essa abordagem não se limita a frameworks e linguagens específicos. Ela deve ser considerada uma medida essencial de mitigação para garantir que os aplicativos com LLMs permaneçam sob controle e funcionem como esperado.

A implementação completa deste projeto está disponível no GitHub. A documentação do Quarkus explica como usar Guardrails com Quarkus.