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.16.0
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.16.0
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.16.0
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.16.0
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.16.0"
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.16.0
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.16.0"
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.16.0
docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION

Para instalar Toolbox con Homebrew en macOS o Linux:

brew install mcp-toolbox

Para instalar desde el código fuente, asegúrate de tener la versión más reciente de Go instalado y, a continuación, ejecuta el siguiente comando:

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

# 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 en lenguaje natural mediante 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 desactivarla, usa la opción --disable-reload.

Para ejecutar el servidor después de descargar 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 opción -v monta tu tools.yaml local en el contenedor, y -p asigna el puerto 5000 del contenedor al puerto 5000 de tu equipo.

Para ejecutar el servidor directamente desde el código fuente, ve 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 el desarrollo y las pruebas. No compila un binario en tu $GOPATH. Si quieres compilar un binario, consulta la documentación para desarrolladores.

Si instalaste Toolbox con Homebrew, el binario toolbox está disponible en la ruta de tu 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 el SDK Toolbox Core:

   pip install toolbox-core
   

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox Core, consulta el README del proyecto.

LangChain / LangGraph

1. Instala el SDK Toolbox LangChain:

   pip install toolbox-langchain
   

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox LangChain, consulta el README del proyecto.

LlamaIndex

1. Instala el SDK Toolbox Llamaindex:

   pip install toolbox-llamaindex
   

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox Llamaindex, consulta el README del proyecto.

Core

1. Instala el SDK Toolbox Core:

   npm install @toolbox-sdk/core
   

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox Core, consulta el README del proyecto.

LangChain / LangGraph

1. Instala el SDK Toolbox Core:

   npm install @toolbox-sdk/core
   

2. Carga las 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 el SDK Toolbox Core:

   npm install @toolbox-sdk/core
   

2. Carga las 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 el SDK Toolbox ADK:

   npm install @toolbox-sdk/adk
   

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox ADK, consulta el README del proyecto.

Core

1. Instala el SDK Toolbox Go:

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

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox Go, consulta el README del proyecto.

LangChain Go

1. Instala el SDK Toolbox Go:

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

2. Carga las 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 el SDK Toolbox Go:

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

2. Carga las 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 el SDK Toolbox Go:

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

2. Carga las 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 el SDK Toolbox Go:

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

2. Carga las 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 el SDK Toolbox Go:

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

2. Carga las 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 obtener instrucciones más detalladas sobre el uso del SDK Toolbox Go, consulta el README del proyecto.