MCP Toolbox for Databases

To install Toolbox as a binary:

Linux (AMD64)

To install Toolbox as a binary on Linux (AMD64):

sh

# see releases page for other versionsexport VERSION=1.15.0curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/linux/amd64/toolboxchmod +x toolbox

macOS (Apple Silicon)

To install Toolbox as a binary on macOS (Apple Silicon):

sh

# see releases page for other versionsexport VERSION=1.15.0curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/arm64/toolboxchmod +x toolbox

macOS (Intel)

To install Toolbox as a binary on macOS (Intel):

sh

# see releases page for other versionsexport VERSION=1.15.0curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/amd64/toolboxchmod +x toolbox

Windows (Command Prompt)

To install Toolbox as a binary on Windows (Command Prompt):

cmd

:: see releases page for other versionsset VERSION=1.15.0curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/amd64/toolbox.exe"

Windows (PowerShell)

To install Toolbox as a binary on Windows (PowerShell):

powershell

# see releases page for other versions$VERSION = "1.15.0"curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/amd64/toolbox.exe"

Windows ARM64 (Command Prompt)

To install Toolbox as a binary on Windows ARM64 (Command Prompt):

cmd

:: see releases page for other versionsset VERSION=1.15.0curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/arm64/toolbox.exe"

Windows ARM64 (PowerShell)

To install Toolbox as a binary on Windows ARM64 (PowerShell):

powershell

# see releases page for other versions$VERSION = "1.15.0"curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/arm64/toolbox.exe"

To install Toolbox using Homebrew on macOS or Linux:

brew install mcp-toolbox

To install from source, ensure you have the latest version of Go installed, and then run the following command:

go install github.com/googleapis/[email protected]

# Install Gemini CLInpm install -g @google/gemini-cli# Install the extensiongemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgres# Run Gemini CLIgemini

Interact with your custom tools using natural language through the Gemini CLI.

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

To run Toolbox from binary:

./toolbox --config "tools.yaml"

ⓘ Note
Toolbox enables dynamic reloading by default. To disable, use the --disable-reload flag.

To run the server after pulling the container image:

export VERSION=0.24.0 # Use the version you pulleddocker 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"

ⓘ Note
The -v flag mounts your local tools.yaml into the container, and -p maps the container's port 5000 to your host's port 5000.

To run the server directly from source, navigate to the project root directory and run:

go run .

ⓘ Note
This command runs the project from source, and is more suitable for development and testing. It does not compile a binary into your $GOPATH. If you want to compile a binary instead, refer the Developer Documentation.

If you installed Toolbox using Homebrew, the toolbox binary is available in your system path. You can start the server with the same command:

toolbox --config "tools.yaml"

To run Toolbox directly without manually downloading the binary (requires Node.js):

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

Core

1. Install Toolbox Core SDK:

   bash

   pip install toolbox-core

2. Load tools:

   python

   from toolbox_core import ToolboxClient
   # update the url to point to your serverasync 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")

For more detailed instructions on using the Toolbox Core SDK, see the project's README.

LangChain / LangGraph

1. Install Toolbox LangChain SDK:

   bash

   pip install toolbox-langchain

2. Load tools:

   python

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

   For more detailed instructions on using the Toolbox LangChain SDK, see the project's README.

LlamaIndex

1. Install Toolbox Llamaindex SDK:

   bash

   pip install toolbox-llamaindex

2. Load tools:

   python

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

   For more detailed instructions on using the Toolbox Llamaindex SDK, see the project's README.

Core

1. Install Toolbox Core SDK:

   bash

   npm install @toolbox-sdk/core

2. Load tools:

   javascript

   import { ToolboxClient } from '@toolbox-sdk/core';
   // update the url to point to your serverconst 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');

   For more detailed instructions on using the Toolbox Core SDK, see the project's README.

LangChain / LangGraph

1. Install Toolbox Core SDK:

   bash

   npm install @toolbox-sdk/core

2. Load tools:

   javascript

   import { ToolboxClient } from '@toolbox-sdk/core';
   // update the url to point to your serverconst 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 logicconst getTool = (toolboxTool) => tool(currTool, {    name: toolboxTool.getName(),    description: toolboxTool.getDescription(),    schema: toolboxTool.getParamSchema()});
   // Use these tools in your Langchain/Langraph applicationsconst tools = toolboxTools.map(getTool);

Genkit

1. Install Toolbox Core SDK:

   bash

   npm install @toolbox-sdk/core

2. Load tools:

   javascript

   import { ToolboxClient } from '@toolbox-sdk/core';import { genkit } from 'genkit';
   // Initialise genkitconst 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 serverconst 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 logicconst getTool = (toolboxTool) => ai.defineTool({    name: toolboxTool.getName(),    description: toolboxTool.getDescription(),    schema: toolboxTool.getParamSchema()}, toolboxTool)
   // Use these tools in your Genkit applicationsconst tools = toolboxTools.map(getTool);

ADK

1. Install Toolbox ADK SDK:

   bash

   npm install @toolbox-sdk/adk

2. Load tools:

   javascript

   import { ToolboxClient } from '@toolbox-sdk/adk';
   // update the url to point to your serverconst 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');

   For more detailed instructions on using the Toolbox ADK SDK, see the project's README.

Core

1. Install Toolbox Go SDK:

   bash

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

2. Load tools:

   go

   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)}

   For more detailed instructions on using the Toolbox Go SDK, see the project's README.

LangChain Go

1. Install Toolbox Go SDK:

   bash

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

2. Load tools:

   go

   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. Install Toolbox Go SDK:

   bash

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

2. Load tools:

   go

   package mainimport (  "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. Install Toolbox Go SDK:

   bash

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

2. Load tools:

   go

   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. Install Toolbox Go SDK:

   bash

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

2. Load tools:

   go

   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. Install Toolbox Go SDK:

   bash

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

2. Load tools:

   go

   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)  }}

   For more detailed instructions on using the Toolbox Go SDK, see the project's README.