MCP Toolbox for Databases

Para instalar Toolbox como binario:

Linux (AMD64)

Para instalar Toolbox como binario en Linux (AMD64):

# consulta la página de versiones para otras versiones
export VERSION=1.13.1
curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

macOS (Apple Silicon)

Para instalar Toolbox como binario en macOS (Apple Silicon):

# consulta la página de versiones para otras versiones
export VERSION=1.13.1
curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/arm64/toolbox
chmod +x toolbox

macOS (Intel)

Para instalar Toolbox como binario en macOS (Intel):

# consulta la página de versiones para otras versiones
export VERSION=1.13.1
curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/amd64/toolbox
chmod +x toolbox

Windows (Símbolo del sistema)

Para instalar Toolbox como binario en Windows (Símbolo del sistema):

:: consulta la página de versiones para otras versiones
set VERSION=1.13.1
curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/amd64/toolbox.exe"

Windows (PowerShell)

Para instalar Toolbox como binario en Windows (PowerShell):

# consulta la página de versiones para otras versiones
$VERSION = "1.13.1"
curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/amd64/toolbox.exe"

Windows ARM64 (Símbolo del sistema)

Para instalar Toolbox como binario en Windows ARM64 (Símbolo del sistema):

:: consulta la página de versiones para otras versiones
set VERSION=1.13.1
curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/arm64/toolbox.exe"

Windows ARM64 (PowerShell)

Para instalar Toolbox como binario en Windows ARM64 (PowerShell):

# consulta la página de versiones para otras versiones
$VERSION = "1.13.1"
curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/arm64/toolbox.exe"

# see releases page for other versions
export VERSION=1.13.1
docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION

Para instalar Toolbox usando Homebrew en macOS o Linux:

brew install mcp-toolbox

Para instalar desde el código fuente, asegúrate de tener la última versión de Go instalado y luego ejecuta el siguiente comando:

go install github.com/googleapis/mcp-toolbox@v1.13.1

# Install Gemini CLI
npm install -g @google/gemini-cli
# Install the extension
gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgres
# Run Gemini CLI
gemini

Interactúa con tus herramientas personalizadas usando lenguaje natural a través de Gemini CLI.

# Install the extension
gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox

Para ejecutar Toolbox desde el binario:

./toolbox --config "tools.yaml"

ⓘ Nota
Toolbox habilita la recarga dinámica de forma predeterminada. Para deshabilitarla, usa la bandera --disable-reload.

Para ejecutar el servidor después de extraer la imagen de contenedor:

export VERSION=0.24.0 # Use the version you pulled
docker run -p 5000:5000 \
-v $(pwd)/tools.yaml:/app/tools.yaml \
us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION \
--config "/app/tools.yaml"

ⓘ Nota
La bandera -v monta tu tools.yaml local en el contenedor, y -p asigna el puerto 5000 del contenedor al puerto 5000 de tu host.

Para ejecutar el servidor directamente desde el código fuente, navega al directorio raíz del proyecto y ejecuta:

go run .

ⓘ Nota
Este comando ejecuta el proyecto desde el código fuente y es más adecuado para desarrollo y pruebas. No compila un binario en tu $GOPATH. Si deseas compilar un binario en su lugar, consulta la Documentación para desarrolladores.

Si instalaste Toolbox usando Homebrew, el binario toolbox está disponible en tu ruta del sistema. Puedes iniciar el servidor con el mismo comando:

toolbox --config "tools.yaml"

Para ejecutar Toolbox directamente sin descargar manualmente el binario (requiere Node.js):

npx @toolbox-sdk/server --config tools.yaml

# Run Gemini CLI
gemini

# List extensions
/extensions list
# List MCP servers
/mcp list

Core

1. Instala Toolbox Core SDK:

   pip install toolbox-core
   

2. Carga herramientas:

   from toolbox_core import ToolboxClient
   
   # update the url to point to your server
   async with ToolboxClient("http://127.0.0.1:5000") as client:
   
       # these tools can be passed to your application!
       tools = await client.load_toolset("toolset_name")
   

Para instrucciones más detalladas sobre el uso del Toolbox Core SDK, consulta el README del proyecto.

LangChain / LangGraph

1. Instala Toolbox LangChain SDK:

   pip install toolbox-langchain
   

2. Carga herramientas:

   from toolbox_langchain import ToolboxClient
   
   # update the url to point to your server
   async with ToolboxClient("http://127.0.0.1:5000") as client:
   
       # these tools can be passed to your application!
       tools = client.load_toolset()
   

   Para instrucciones más detalladas sobre el uso del Toolbox LangChain SDK, consulta el README del proyecto.

LlamaIndex

1. Instala Toolbox Llamaindex SDK:

   pip install toolbox-llamaindex
   

2. Carga herramientas:

   from toolbox_llamaindex import ToolboxClient
   
   # update the url to point to your server
   async with ToolboxClient("http://127.0.0.1:5000") as client:
   
       # these tools can be passed to your application!
       tools = client.load_toolset()
   

   Para instrucciones más detalladas sobre el uso del Toolbox Llamaindex SDK, consulta el README del proyecto.

Core

1. Instala Toolbox Core SDK:

   npm install @toolbox-sdk/core
   

2. Carga herramientas:

   import { ToolboxClient } from '@toolbox-sdk/core';
   
   // update the url to point to your server
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // these tools can be passed to your application!
   const tools = await client.loadToolset('toolsetName');
   

   Para instrucciones más detalladas sobre el uso del Toolbox Core SDK, consulta el README del proyecto.

LangChain / LangGraph

1. Instala Toolbox Core SDK:

   npm install @toolbox-sdk/core
   

2. Carga herramientas:

   import { ToolboxClient } from '@toolbox-sdk/core';
   
   // update the url to point to your server
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // these tools can be passed to your application!
   const toolboxTools = await client.loadToolset('toolsetName');
   
   // Define the basics of the tool: name, description, schema and core logic
   const getTool = (toolboxTool) => tool(currTool, {
       name: toolboxTool.getName(),
       description: toolboxTool.getDescription(),
       schema: toolboxTool.getParamSchema()
   });
   
   // Use these tools in your Langchain/Langraph applications
   const tools = toolboxTools.map(getTool);
   

Genkit

1. Instala Toolbox Core SDK:

   npm install @toolbox-sdk/core
   

2. Carga herramientas:

   import { ToolboxClient } from '@toolbox-sdk/core';
   import { genkit } from 'genkit';
   
   // Initialise genkit
   const ai = genkit({
       plugins: [
           googleAI({
               apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
           })
       ],
       model: googleAI.model('gemini-2.0-flash'),
   });
   
   // update the url to point to your server
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // these tools can be passed to your application!
   const toolboxTools = await client.loadToolset('toolsetName');
   
   // Define the basics of the tool: name, description, schema and core logic
   const getTool = (toolboxTool) => ai.defineTool({
       name: toolboxTool.getName(),
       description: toolboxTool.getDescription(),
       schema: toolboxTool.getParamSchema()
   }, toolboxTool)
   
   // Use these tools in your Genkit applications
   const tools = toolboxTools.map(getTool);
   

ADK

1. Instala Toolbox ADK SDK:

   npm install @toolbox-sdk/adk
   

2. Carga herramientas:

   import { ToolboxClient } from '@toolbox-sdk/adk';
   
   // update the url to point to your server
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // these tools can be passed to your application!
   const tools = await client.loadToolset('toolsetName');
   

   Para instrucciones más detalladas sobre el uso del Toolbox ADK SDK, consulta el README del proyecto.

Core

1. Instala Toolbox Go SDK:

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

2. Carga herramientas:

   package main
   
   import (
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "context"
   )
   
   func main() {
     // Make sure to add the error checks
     // update the url to point to your server
     URL := "http://127.0.0.1:5000";
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // Framework agnostic tools
     tools, err := client.LoadToolset("toolsetName", ctx)
   }
   

   Para instrucciones más detalladas sobre el uso del Toolbox Go SDK, consulta el README del proyecto.

LangChain Go

1. Instala Toolbox Go SDK:

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

2. Carga herramientas:

   package main
   
   import (
     "context"
     "encoding/json"
   
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "github.com/tmc/langchaingo/llms"
   )
   
   func main() {
     // Make sure to add the error checks
     // update the url to point to your server
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // Framework agnostic tool
     tool, err := client.LoadTool("toolName", ctx)
   
     // Fetch the tool's input schema
     inputschema, err := tool.InputSchema()
   
     var paramsSchema map[string]any
     _ = json.Unmarshal(inputschema, &paramsSchema)
   
     // Use this tool with LangChainGo
     langChainTool := llms.Tool{
       Type: "function",
       Function: &llms.FunctionDefinition{
         Name:        tool.Name(),
         Description: tool.Description(),
         Parameters:  paramsSchema,
       },
     }
   }
   
   

Genkit

1. Instala Toolbox Go SDK:

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

2. Carga herramientas:

   package main
   import (
     "context"
     "log"
   
     "github.com/firebase/genkit/go/genkit"
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
   )
   
   func main() {
     // Make sure to add the error checks
     // Update the url to point to your server
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
     g := genkit.Init(ctx)
   
     client, err := core.NewToolboxClient(URL)
   
     // Framework agnostic tool
     tool, err := client.LoadTool("toolName", ctx)
   
     // Convert the tool using the tbgenkit package
     // Use this tool with Genkit Go
     genkitTool, err := tbgenkit.ToGenkitTool(tool, g)
     if err != nil {
       log.Fatalf("Failed to convert tool: %v\n", err)
     }
     log.Printf("Successfully converted tool: %s", genkitTool.Name())
   }
   

Go GenAI

1. Instala Toolbox Go SDK:

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

2. Carga herramientas:

   package main
   
   import (
     "context"
     "encoding/json"
   
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "google.golang.org/genai"
   )
   
   func main() {
     // Make sure to add the error checks
     // Update the url to point to your server
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // Framework agnostic tool
     tool, err := client.LoadTool("toolName", ctx)
   
     // Fetch the tool's input schema
     inputschema, err := tool.InputSchema()
   
     var schema *genai.Schema
     _ = json.Unmarshal(inputschema, &schema)
   
     funcDeclaration := &genai.FunctionDeclaration{
       Name:        tool.Name(),
       Description: tool.Description(),
       Parameters:  schema,
     }
   
     // Use this tool with Go GenAI
     genAITool := &genai.Tool{
       FunctionDeclarations: []*genai.FunctionDeclaration{funcDeclaration},
     }
   }
   

OpenAI Go

1. Instala Toolbox Go SDK:

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

2. Carga herramientas:

   package main
   
   import (
     "context"
     "encoding/json"
   
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     openai "github.com/openai/openai-go"
   )
   
   func main() {
     // Make sure to add the error checks
     // Update the url to point to your server
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // Framework agnostic tool
     tool, err := client.LoadTool("toolName", ctx)
   
     // Fetch the tool's input schema
     inputschema, err := tool.InputSchema()
   
     var paramsSchema openai.FunctionParameters
     _ = json.Unmarshal(inputschema, &paramsSchema)
   
     // Use this tool with OpenAI Go
     openAITool := openai.ChatCompletionToolParam{
       Function: openai.FunctionDefinitionParam{
         Name:        tool.Name(),
         Description: openai.String(tool.Description()),
         Parameters:  paramsSchema,
       },
     }
   
   }
   

ADK Go

1. Instala Toolbox Go SDK:

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

2. Carga herramientas:

   package main
   
   import (
     "github.com/googleapis/mcp-toolbox-sdk-go/tbadk"
     "context"
   )
   
   func main() {
     // Make sure to add the error checks
     // Update the url to point to your server
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
     client, err := tbadk.NewToolboxClient(URL)
     if err != nil {
       return fmt.Sprintln("Could not start Toolbox Client", err)
     }
   
     // Use this tool with ADK Go
     tool, err := client.LoadTool("toolName", ctx)
     if err != nil {
       return fmt.Sprintln("Could not load Toolbox Tool", err)
     }
   }
   

   Para instrucciones más detalladas sobre el uso del Toolbox Go SDK, consulta el README del proyecto.