Conectando Agentes de IA a Bancos de Dados Enterprise: Chegada do MCP Toolbox Java SDK

As equipes de engenharia estão evoluindo de simples chatbots para sistemas baseados em agentes (agentic systems) capazes de interagir diretamente com bancos de dados de missão crítica. No entanto, construir esses agentes no cenário enterprise geralmente significa enfrentar um muro de integrações complexas: código de colagem (glue code) personalizado, APIs frágeis e lógica de banco de dados dispersa.

Para substituir esses gargalos por um control plane unificado e seguro, o Google anunciou o Java SDK para o Model Context Protocol (MCP) Toolbox for Databases. Este lançamento traz a orquestração de agentes typesafe para o ecossistema corporativo mais adotado do mundo. A maturidade do Java — com seu suporte a alta concorrência, integridade transacional estrita e gestão robusta de estado — é fundamental para escalar agentes de IA em produção com segurança.

MCP: O "USB-C" para Agentes de IA

Imagine o Model Context Protocol (MCP) como um tradutor universal para IA.

Criado para padronizar como os modelos de IA se conectam a ferramentas e datasets externos, o MCP substitui scripts de integração fragmentados por um protocolo universal. Se o seu agente precisa executar uma query SQL transacional, pesquisar documentos de normas ou acionar uma REST API, o MCP fornece uma interface única.

Com o MCP Toolbox for Databases, a implementação desse protocolo torna-se direta, eliminando a necessidade de reinventar a roda a cada nova integração de dados.

MCP Toolbox para Bancos de Dados

O MCP Toolbox for Databases é um servidor MCP open source que suporta nativamente 42 fontes de dados, incluindo AlloyDB, Cloud SQL e Cloud Spanner, além de fontes de terceiros. O diferencial estratégico aqui é a capacidade de definir ferramentas personalizadas (custom tools) que mapeiam as intenções de linguagem natural de um agente diretamente para operações específicas no banco de dados.

Embora já existam SDKs para Python, JavaScript e Go, o lançamento para Java e Spring Boot atende ao cenário corporativo de "Dia 2" — onde concorrência e gerenciamento de estado conversacional são requisitos inegociáveis. Com o novo SDK, arquitetos de sistemas podem construir sistemas multi-agentes complexos sem abandonar a stack tecnológica consolidada da empresa.

Primeiros Passos com o Java SDK

O design do MCP Toolbox Java SDK foi pensado para ser frictionless. Para começar, basta adicionar a dependência ao seu pom.xml:

Copiar<dependency>
   <groupId>com.google.cloud.mcp</groupId>
   <artifactId>mcp-toolbox-sdk-java</artifactId>
   <version>0.2.0</version>
</dependency>

Com isso, seu projeto está pronto para casos de uso de classe enterprise.

Exemplo Real: O Concierge de Transporte Autônomo

Para demonstrar o poder do SDK, considere o exemplo da Cymbal Transit, uma rede fictícia de ônibus. Em vez de menus suspensos, os clientes querem perguntar:

"Preciso ir de NY para Boston amanhã cedo. Posso levar meu cachorro? Se sim, reserve a viagem mais rápida."

Para processar isso, o agente precisa cruzar dados não estruturados (políticas de pets) com dados estruturados (horários e assentos) e executar uma transação (booking), mantendo o contexto da conversa.

A Fundação: AlloyDB com Native Embeddings

O AlloyDB é ideal para este cenário por processar dados relacionais e vetores (AI vectors) no mesmo engine. Ele gera embeddings nativamente via extensão google_ml_integration, evitando o tráfego excessivo de texto para APIs externas.

Após configurar o cluster, os objetos do banco são definidos via SQL:

Copiar-- Habilita extensões para busca semântica e embeddings
CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS google_ml_integration;

-- Tabela 1: Políticas (Dados não estruturados para RAG)
CREATE TABLE transit_policies (
    policy_id SERIAL PRIMARY KEY,
    category VARCHAR(50),
    policy_text TEXT,
    policy_embedding vector(768) 
);

-- Tabela 2: Horários (Dados estruturados)
CREATE TABLE bus_schedules (
    trip_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    origin_city VARCHAR(100),
    destination_city VARCHAR(100),
    departure_time TIMESTAMP,
    arrival_time TIMESTAMP,
    available_seats INT DEFAULT 50,
    ticket_price DECIMAL(6,2)
);

-- Tabela 3: Reservas (Ações transacionais)
CREATE TABLE bookings (
    booking_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    trip_id UUID REFERENCES bus_schedules(trip_id),
    passenger_id VARCHAR(100),
    status VARCHAR(20) DEFAULT 'CONFIRMED',
    booking_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Ingestão e Geração de Embeddings

Abaixo, um exemplo de como alimentar o banco. Para detalhes completos, consulte o repositório.

Copiar-- 1. Insere políticas e gera embeddings nativamente no AlloyDB
INSERT INTO transit_policies (category, policy_text, policy_embedding) 
... 

-- 2. Gera mais de 200 horários realistas para os próximos 7 dias
INSERT INTO bus_schedules (origin_city, destination_city, departure_time, arrival_time, ticket_price, available_seats)
... 

Arquitetura de Agente Stateful no Spring Boot

O maior desafio é o session management. Se o usuário diz "Reservar a das 8h", o agente deve saber a que viagem ele se refere. Usando o Java MCP SDK com LangChain4j, a memória da conversa é mantida na HTTP Session e injetada no processo de decisão do agente.

O código abaixo mostra como a lógica de orquestração é definida de forma declarativa, sem queries hard-coded:

Copiarinterface TransitAgent {
    @SystemMessage({
        "You are the Cymbal Transit Concierge.",
        "Use the 'querySchedules' tool for finding schedules.",
        "Use 'bookTicket' to execute transactions.",
        "Use 'searchPolicies' to look up luggage and pet rules."
    })
    String chat(@MemoryId String sessionId, @UserMessage String userMessage);
}

@Service
class TransitAgentTools {
    @Tool("Query specific schedules between an origin and destination city.")
    public String querySchedules(String origin, String destination) { ... }

    @Tool("Book a ticket for a passenger.")
    public String bookTicket(String tripId, String passengerName) { ... }
}

Mapeando Intenções para SQL: O tools.yaml

O isolamento de camadas é um ponto forte. O LLM não precisa conhecer o schema do banco (o que evita alucinações e exposição de segurança). O mapeamento ocorre em um arquivo tools.yaml que vincula as chamadas de ferramentas a statements SQL parametrizados.

Copiartools:
  query-schedules:
    kind: postgres-sql
    source: alloydb
    description: Find available bus schedules between cities.
    parameters:
      - name: origin
        type: string
      - name: destination
        type: string
    statement: |
      SELECT CAST(trip_id AS TEXT) AS trip_id, departure_time, ticket_price 
      FROM bus_schedules 
      WHERE lower(origin_city) = lower($1) AND lower(destination_city) = lower($2)      

Conectando os Pontos no Java

O SDK lida com o trabalho pesado: descoberta, consulta e execução segura de transações a partir do Spring Boot.

Copiar// 1. Inicializa o cliente
McpToolboxClient mcpClient = McpToolboxClient.builder()
    .baseUrl("https://toolbox-my-project-uc.a.run.app")
    .apiKey(myIdToken) 
    .build();

// 2. Invoca uma ferramenta de leitura
String schedules = mcpClient.invokeTool("query-schedules", Map.of(
    "origin", "New York",
    "destination", "Boston"
)).join().content().get(0).text();

// 3. Executa transação com bind de parâmetros (contexto do usuário autenticado)
AuthTokenGetter toolAuthGetter = () -> CompletableFuture.completedFuture(myIdToken);

mcpClient.loadTool("book-ticket", Map.of("google_auth", toolAuthGetter))
    .thenCompose(tool -> {
        tool.bindParam("passenger_name", "Jane Doe");
        return tool.execute(Map.of("trip_id", "UUID-AQUI"));
    });

O método bindParam é vital: permite injetar o contexto do usuário autenticado diretamente na transação, sem passar pelo LLM, reforçando os controles de SecOps.

Segurança e Deployment

A segurança é simplificada pelo uso de Application Default Credentials (ADC), herdando a identidade diretamente do ambiente (Cloud Run ou local) sem segredos hard-coded. Como o Toolbox e o Spring Boot Agent são desacoplados, eles escalam de forma independente no Cloud Run, garantindo eficiência de custos (FinOps).

Conclusão

A transição de chatbots stateless para agentes transacionais autônomos é a mudança tecnológica desta década. Com o Java SDK para MCP Toolbox, empresas brasileiras que utilizam Java como base de seus sistemas críticos agora possuem um caminho sólido e seguro para integrar IA generativa aos seus registros operacionais.

Para explorar o código completo, acesse o MCP Toolbox Java SDK no GitHub.

---

Artigo originalmente publicado por Anubhav Dhawan, Software Engineer, Google em Cloud Blog.