MCP Toolbox para Bases de Datos¶

Soportado en ADKPythonTypescriptGo

MCP Toolbox for Databases es un servidor MCP de código abierto para bases de datos. Fue diseñado pensando en calidad empresarial y lista para producción. Te permite desarrollar herramientas más fácil, rápido y de forma más segura al manejar las complejidades como agrupación de conexiones, autenticación y más.

El Kit de Desarrollo de Agentes (ADK) de Google tiene soporte integrado para Toolbox. Para más información sobre cómo empezar o configurar Toolbox, consulta la documentación.

GenAI Toolbox

Fuentes de Datos Soportadas¶

MCP Toolbox proporciona conjuntos de herramientas listos para usar para las siguientes bases de datos y plataformas de datos:

Google Cloud¶

BigQuery (incluyendo herramientas para ejecución SQL, descubrimiento de esquemas y pronósticos de series temporales impulsados por IA)
AlloyDB (compatible con PostgreSQL, con herramientas tanto para consultas estándar como consultas en lenguaje natural)
AlloyDB Admin
Spanner (soporta dialectos tanto GoogleSQL como PostgreSQL)
Cloud SQL (con soporte dedicado para Cloud SQL for PostgreSQL, Cloud SQL for MySQL, y Cloud SQL for SQL Server)
Cloud SQL Admin
Firestore
Bigtable
Dataplex (para descubrimiento de datos y búsqueda de metadatos)
Cloud Monitoring

Bases de Datos Relacionales y SQL¶

Bases de Datos NoSQL y Almacenes Clave-Valor¶

Bases de Datos de Grafos¶

Neo4j (con herramientas para consultas Cypher e inspección de esquemas)
Dgraph

Plataformas de Datos y Federación¶

Looker (para ejecutar Looks, consultas y construir paneles a través de la API de Looker)
Trino (para ejecutar consultas federadas a través de múltiples fuentes)

Otros¶

HTTP

Configurar e implementar¶

Toolbox es un servidor de código abierto que tú despliegas y gestionas. Para más instrucciones sobre cómo desplegar y configurar, consulta la documentación oficial de Toolbox:

Instalar SDK del Cliente para ADK¶

PythonTypescriptGo

ADK depende del paquete de python toolbox-adk para usar Toolbox. Instala el paquete antes de empezar:

pip install google-adk[toolbox]

Cargando Herramientas de Toolbox¶

Una vez que tu servidor Toolbox esté configurado, funcionando, puedes cargar herramientas desde tu servidor usando ADK:

from google.adk.agents import Agent
from google.adk.tools.toolbox_toolset import ToolboxToolset

toolset = ToolboxToolset(
    server_url="http://127.0.0.1:5000"
)

root_agent = Agent(
    ...,
    tools=[toolset] # Proporciona el conjunto de herramientas al Agente
)

Autenticación¶

El ToolboxToolset soporta varias estrategias de autenticación incluyendo Workload Identity (ADC), User Identity (OAuth2) y API Keys. Para documentación completa, consulta la Guía de Autenticación de Toolbox ADK.

Ejemplo: Workload Identity (ADC)

Recomendado para Cloud Run, GKE o desarrollo local con gcloud auth login.

from google.adk.tools.toolbox_toolset import ToolboxToolset
from toolbox_adk import CredentialStrategy

# target_audience: La URL de tu servidor Toolbox
creds = CredentialStrategy.workload_identity(target_audience="<TOOLBOX_URL>")

toolset = ToolboxToolset(
    server_url="<TOOLBOX_URL>",
    credentials=creds
)

Configuración Avanzada¶

Puedes configurar enlace de parámetros, hooks de solicitud y encabezados adicionales. Consulta la documentación de Toolbox ADK para más detalles.

Enlace de Parámetros¶

Enlaza valores a parámetros de herramientas globalmente. Estos valores están ocultos del modelo.

toolset = ToolboxToolset(
    server_url="...",
    bound_params={
        "region": "us-central1",
        "api_key": lambda: get_api_key() # Puede ser un callable
    }
)

Uso con Hooks¶

Adjunta funciones pre_hook y post_hook para ejecutar lógica antes y después de la invocación de herramientas.

async def log_start(context, args):
    print(f"Starting tool with args: {args}")

toolset = ToolboxToolset(
    server_url="...",
    pre_hook=log_start
)

ADK depende del paquete TS @toolbox-sdk/adk para usar Toolbox. Instala el paquete antes de empezar:

npm install @toolbox-sdk/adk

Cargando Herramientas de Toolbox¶

Una vez que tu servidor Toolbox esté configurado y funcionando, puedes cargar herramientas desde tu servidor usando ADK:

import {InMemoryRunner, LlmAgent} from '@google/adk';
import {Content} from '@google/genai';
import {ToolboxClient} from '@toolbox-sdk/adk'

const toolboxClient = new ToolboxClient("http://127.0.0.1:5000");
const loadedTools = await toolboxClient.loadToolset();

export const rootAgent = new LlmAgent({
  name: 'weather_time_agent',
  model: 'gemini-2.5-flash',
  description:
    'Agente para responder preguntas sobre la hora y el clima en una ciudad.',
  instruction:
    'Eres un agente útil que puede responder preguntas de usuarios sobre la hora y el clima en una ciudad.',
  tools: loadedTools,
});

async function main() {
  const userId = 'test_user';
  const appName = rootAgent.name;
  const runner = new InMemoryRunner({agent: rootAgent, appName});
  const session = await runner.sessionService.createSession({
    appName,
    userId,
  });

  const prompt = 'What is the weather in New York? And the time?';
  const content: Content = {
    role: 'user',
    parts: [{text: prompt}],
  };
  console.log(content);
  for await (const e of runner.runAsync({
    userId,
    sessionId: session.id,
    newMessage: content,
  })) {
    if (e.content?.parts?.[0]?.text) {
      console.log(`${e.author}: ${JSON.stringify(e.content, null, 2)}`);
    }
  }
}

main().catch(console.error);

ADK depende del módulo go mcp-toolbox-sdk-go para usar Toolbox. Instala el módulo antes de empezar:

go get github.com/googleapis/mcp-toolbox-sdk-go

Cargando Herramientas de Toolbox¶

Una vez que tu servidor Toolbox esté configurado y funcionando, puedes cargar herramientas desde tu servidor usando ADK:

package main

import (
    "context"
    "fmt"

    "github.com/googleapis/mcp-toolbox-sdk-go/tbadk"
    "google.golang.org/adk/agent/llmagent"
)

func main() {

  toolboxClient, err := tbadk.NewToolboxClient("https://127.0.0.1:5000")
    if err != nil {
        log.Fatalf("Failed to create MCP Toolbox client: %v", err)
    }

  // Carga un conjunto específico de herramientas
  toolboxtools, err := toolboxClient.LoadToolset("my-toolset-name", ctx)
  if err != nil {
    return fmt.Sprintln("Could not load Toolbox Toolset", err)
  }

  toolsList := make([]tool.Tool, len(toolboxtools))
    for i := range toolboxtools {
      toolsList[i] = &toolboxtools[i]
    }

  llmagent, err := llmagent.New(llmagent.Config{
    ...,
    Tools:       toolsList,
  })

  // Carga una sola herramienta
  tool, err := client.LoadTool("my-tool-name", ctx)
  if err != nil {
    return fmt.Sprintln("Could not load Toolbox Tool", err)
  }

  llmagent, err := llmagent.New(llmagent.Config{
    ...,
    Tools:       []tool.Tool{&toolboxtool},
  })
}

Características Avanzadas de Toolbox¶

Toolbox tiene una variedad de características para facilitar el desarrollo de herramientas Gen AI para bases de datos. Para más información, lee más sobre las siguientes características:

Parámetros Autenticados: enlaza entradas de herramientas a valores de tokens OIDC automáticamente, facilitando la ejecución de consultas sensibles sin potencialmente filtrar datos
Invocaciones Autorizadas: restringe el acceso para usar una herramienta basándose en el token de autenticación del usuario
OpenTelemetry: obtén métricas y rastreo de Toolbox con OpenTelemetry