TRUST-SQL: Tool-Integrated Multi-Turn Reinforcement Learning for Text-to-SQL over Unknown Schemas

O artigo apresenta o TRUST-SQL, um framework que utiliza aprendizado por reforço multi-turno integrado a ferramentas para resolver o problema de Text-to-SQL em cenários de esquemas desconhecidos, permitindo que agentes autônomos identifiquem e verifiquem ativamente metadados relevantes sem depender de pré-carregamento de esquemas completos.

O essencial

Imagine que você precisa pedir um prato específico em um restaurante gigante, mas o cardápio tem milhares de páginas, está cheio de erros de digitação e as receitas mudam todos os dias.

A maioria dos sistemas de "Texto para SQL" (que transformam perguntas em comandos de banco de dados) funciona como um garçom que já tem o cardápio inteiro na mão antes de você chegar. Ele lê tudo, memoriza e tenta adivinhar o que você quer. Isso funciona bem em restaurantes pequenos, mas no mundo real (empresas com bancos de dados gigantes), esse cardápio é tão grande que o garçom se confunde, inventa pratos que não existem (alucinações) ou esquece ingredientes importantes.

O papel TRUST-SQL propõe uma nova abordagem: em vez de ter o cardápio inteiro na mesa, o garçom é treinado para explorar a cozinha ativamente.

Aqui está a explicação simplificada do que eles fizeram:

1. O Problema: O Garçom Cego vs. O Garçom Investigador

• O Jeito Antigo (Hipótese de Esquema Completo): O garçom recebe uma pilha de 10.000 páginas de cardápio. Ele tenta ler tudo de uma vez. Como a memória dele é limitada, ele ignora detalhes, inventa ingredientes que nunca viu e erra o pedido.
• O Jeito TRUST-SQL (Esquema Desconhecido): O garçom não tem o cardápio. Ele sabe que precisa pedir. Então, ele vai até a cozinha e pergunta: "O que vocês têm?". Ele verifica os ingredientes reais, confirma se o prato existe e só então monta o pedido. Ele não inventa nada; ele investiga.

2. A Solução: O Protocolo de 4 Fases (A Dança do Garçom)

Para evitar que o garçom se perca ou invente coisas, o TRUST-SQL criou um roteiro rígido de 4 passos que ele deve seguir, como se fosse uma coreografia:

1. Explorar (Explore): O agente vai à cozinha e pergunta: "Quais pratos existem?". Ele verifica a lista real de tabelas e colunas.
2. Propor (Propose): Antes de cozinhar, ele escreve num papel: "Ok, vou usar o Prato X e o Ingrediente Y que acabei de verificar". Isso é um ponto de verificação. Ele é obrigado a confirmar o que viu antes de prosseguir. Isso impede que ele invente ingredientes mágicos.
3. Gerar (Generate): Agora que ele sabe o que tem, ele escreve o pedido (o comando SQL) baseado apenas no que foi verificado.
4. Confirmar (Confirm): Ele entrega o pedido final.

3. O Segredo Mágico: "Dual-Track GRPO" (Treinamento em Duas Pistas)

Aqui está a parte mais inteligente da engenharia. Como ensinar um garçom a fazer tudo isso sem frustrá-lo?

Imagine que você está treinando um cachorro. Se ele puxa a coleira (explora) e depois morde o dono (gera o SQL errado), você não sabe se deve punir a puxada ou a mordida. O sistema antigo dava uma única nota final: "Você errou o pedido".

O TRUST-SQL usa uma técnica chamada Dual-Track GRPO (Duas Pistas):

• Pista 1 (A Exploração): O agente recebe uma nota separada por ter encontrado os ingredientes certos na cozinha. Se ele achou o ingrediente certo, ele ganha pontos, mesmo que o pedido final tenha um erro de digitação.
• Pista 2 (A Geração): O agente recebe uma nota separada por montar o pedido corretamente.

Isso resolve o problema de "quem merece o crédito?". O sistema aprende que encontrar a informação certa é tão importante quanto escrever o código certo. Eles são treinados juntos, mas com recompensas separadas, garantindo que o agente não pare de explorar só porque o SQL ficou difícil.

4. Os Resultados: Menos é Mais

O papel mostra que, mesmo sem ter o cardápio inteiro na mão (sem pré-carregar os dados), o sistema TRUST-SQL:

• Acerta mais: Ele supera sistemas que tentam ler tudo de uma vez.
• É mais rápido: Em vez de ler 10.000 páginas, ele lê apenas as 3 páginas que precisa.
• Não alucina: Como ele é obrigado a verificar antes de propor, ele não inventa pratos que não existem.

Resumo em uma Metáfora Final

Pense no TRUST-SQL como um detetive particular.

• O método antigo é como alguém que tenta adivinhar quem é o culpado olhando para uma foto de 1 milhão de pessoas ao mesmo tempo. Ele se perde e aponta para a pessoa errada.
• O TRUST-SQL é o detetive que vai à cena do crime, pergunta aos vizinhos, verifica as impressões digitais e só então aponta para o culpado. Ele não sabe quem é o culpado no início, mas ele sabe como descobrir com precisão.

Conclusão: O TRUST-SQL ensina a Inteligência Artificial a não "adivinhar" o que existe no banco de dados, mas sim a investigar e verificar ativamente, tornando-a muito mais confiável em ambientes reais e complexos.

Resumo técnico

1. O Problema: A Falha da "Hipótese de Esquema Completo"

O campo de Text-to-SQL (tradução de linguagem natural para consultas SQL) tem avançado significativamente impulsionado por Grandes Modelos de Linguagem (LLMs). No entanto, a maioria das abordagens atuais opera sob a Hipótese de Esquema Completo (Full Schema Assumption). Isso pressupõe que o esquema completo do banco de dados (todas as tabelas e colunas) é injetado no contexto de entrada do modelo antes da geração.

Limitações no Mundo Real:

• Ambientes Empresariais: Bancos de dados reais frequentemente contêm centenas de tabelas com metadados massivos, ruidosos e que evoluem constantemente (adições, exclusões, reestruturações).
• Janela de Contexto Limitada: Injetar todo o esquema de antemão é impraticável devido aos limites de contexto dos LLMs.
• Distratores e Alucinações: Metadados irrelevantes ou desatualizados distraem o modelo, levando a alucinações (criação de tabelas ou colunas inexistentes) e degradação do desempenho.

O artigo propõe o cenário de Esquema Desconhecido (Unknown Schema), onde um agente não pode confiar em um esquema pré-carregado. Em vez disso, ele deve ativamente explorar o banco de dados, identificar e verificar apenas o subconjunto de metadados relevante para responder à pergunta do usuário.

---

2. Metodologia: TRUST-SQL

O TRUST-SQL aborda esse problema formulando a tarefa como um Processo de Decisão de Markov Parcialmente Observável (POMDP), onde o estado real do ambiente (o esquema completo) é oculto, e o agente recebe apenas observações parciais através de chamadas de ferramentas.

A. Protocolo de Interação de Quatro Fases

Para garantir raciocínio confiável e evitar alucinações, o agente segue um protocolo estruturado de quatro fases:

1. Explore (Explorar): O agente consulta metadados do banco de dados (ex: sqlite_master) para descobrir tabelas e colunas disponíveis.
2. Propose (Propor): Um ponto de verificação cognitivo obrigatório. O agente deve comprometer-se com um esquema verificado (K_t) antes de gerar qualquer SQL. Isso força a confirmação de que as estruturas usadas são reais.
3. Generate (Gerar): Com base no esquema verificado, o agente gera uma consulta SQL candidata.
4. Confirm (Confirmar): O agente submete a consulta final para execução e verificação do resultado.

Este protocolo permite transições não lineares (ex: voltar a explorar se a geração falhar), criando um ciclo de refinamento iterativo.

B. Estratégia de Treinamento: Dual-Track GRPO

O maior desafio no aprendizado por reforço (RL) de múltiplas rodadas é a atribuição de crédito (credit assignment): saber se uma falha final foi causada por uma exploração ruim de esquema ou por uma lógica SQL defeituosa.

O TRUST-SQL introduz o Dual-Track GRPO (Otimização de Política Relativa de Grupo de Dupla Trilha):

• Separação de Trilhas: Cada trajetória de interação é dividida em duas trilhas de otimização independentes:
  • Trilha de Esquema (Schema Track): Otimizada até o ponto de "Propor". O objetivo é maximizar a qualidade da descoberta e verificação do esquema.
  • Trilha Completa (Full Track): Otimizada sobre toda a interação até a resposta final. O objetivo é a precisão da execução SQL.
• Vantagens em Nível de Token Mascaramento (Token-Level Masked Advantages): A estratégia aplica máscaras estritas aos tokens.
  • Os tokens gerados durante a fase de exploração recebem recompensa apenas baseada na qualidade do esquema.
  • Os tokens gerados após o ponto de "Propor" não recebem crédito pela descoberta do esquema, e vice-versa.
• Recompensas:
  • Recompensa de Execução: Baseada se o SQL executado retorna o mesmo resultado que o ground truth.
  • Recompensa de Esquema: Baseada na sobreposição estrutural entre o esquema proposto e o esquema mínimo necessário (ground truth).
  • Recompensa de Formato: Penaliza violações do protocolo de quatro fases.

---

3. Contribuições Principais

1. Framework Autônomo (TRUST-SQL): Um sistema que interage diretamente com bancos de dados não observáveis para recuperar e verificar metadados, fechando o ciclo de exploração descontrolada até a geração de SQL fundamentada, sem depender de contexto estático pré-carregado.
2. Estratégia Dual-Track GRPO: Uma nova técnica de treinamento que utiliza vantagens em nível de token e recompensas acopladas à execução para resolver o problema de atribuição de crédito em trajetórias longas. Isso resultou em uma melhoria relativa de 9,9% na precisão de execução em comparação com o GRPO padrão.
3. Protocolo de Verificação Cognitiva: A fase "Propose" atua como um checkpoint obrigatório que suprime drasticamente alucinações de esquema, forçando o agente a confirmar metadados antes de gerar código.

---

4. Resultados Experimentais

Os experimentos foram realizados em cinco benchmarks (BIRD-Dev, Spider-Test, Spider-DK, Spider-Syn, Spider-Realistic) com modelos base Qwen3 de 4B e 8B parâmetros.

• Desempenho Superior:
  • A variante 4B do TRUST-SQL alcançou uma melhoria absoluta média de 30,6% sobre o modelo base.
  • A variante 8B alcançou uma melhoria absoluta média de 16,6%.
• Comparação com Baselines:
  • O TRUST-SQL, operando sem esquema pré-carregado, igualou ou superou modelos fortes que dependem de schema prefilling (injeção de esquema completo).
  • Em benchmarks de robustez (como Spider-Realistic e Spider-DK), o TRUST-SQL superou todas as baselines, demonstrando melhor generalização em cenários ambíguos ou com ruído.
• Eficiência de Dados: O modelo foi treinado com um conjunto de dados altamente curado (9.2k amostras SFT + 11.6k amostras RL), superando métodos que utilizam milhões de dados sintéticos.
• Análise de "Schema Prefill": Curiosamente, injetar o esquema completo no TRUST-SQL não melhorou o desempenho e, em alguns casos, degradou a robustez, confirmando que a exploração ativa é mais eficaz do que a dependência passiva de metadados massivos.

---

5. Significado e Impacto

O trabalho TRUST-SQL representa uma mudança de paradigma fundamental para a aplicação de Text-to-SQL em ambientes corporativos reais:

• Viabilidade em Escala: Demonstra que é possível construir agentes que navegam em bancos de dados massivos e complexos sem esgotar a janela de contexto do LLM.
• Confiabilidade: Ao substituir a "tradução passiva" por "exploração ativa verificada", o sistema reduz drasticamente alucinações, um dos maiores obstáculos para a adoção de IA em bases de dados críticas.
• Aprendizado por Reforço Estruturado: A introdução do Dual-Track GRPO oferece uma solução técnica elegante para o problema clássico de atribuição de crédito em RL de múltiplas etapas, separando a qualidade da busca da qualidade da geração.

Em resumo, o TRUST-SQL prova que, em cenários de esquema desconhecido, a capacidade de um agente de explorar, verificar e raciocinar sobre metadados é superior à simples memorização ou ingestão passiva de esquemas completos.