MCP Toolbox for Databases

Pour installer Toolbox sous forme de binaire :

Linux (AMD64)

Pour installer Toolbox sous forme de binaire sous Linux (AMD64) :

# see releases page for other versions
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)

Pour installer Toolbox sous forme de binaire sous macOS (Apple Silicon) :

# see releases page for other versions
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)

Pour installer Toolbox sous forme de binaire sous macOS (Intel) :

# see releases page for other versions
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 (Invite de commandes)

Pour installer Toolbox sous forme de binaire sous Windows (Invite de commandes) :

:: see releases page for other versions
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)

Pour installer Toolbox sous forme de binaire sous Windows (PowerShell) :

# see releases page for other versions
$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 (Invite de commandes)

Pour installer Toolbox sous forme de binaire sous Windows ARM64 (Invite de commandes) :

:: see releases page for other versions
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)

Pour installer Toolbox sous forme de binaire sous Windows ARM64 (PowerShell) :

# see releases page for other versions
$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

Pour installer Toolbox avec Homebrew sous macOS ou Linux :

brew install mcp-toolbox

Pour installer à partir des sources, assurez-vous d’avoir la dernière version de Go installé, puis exécutez la commande suivante :

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

Interagissez avec vos outils personnalisés en langage naturel via Gemini CLI.

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

Pour exécuter Toolbox à partir du binaire :

./toolbox --config "tools.yaml"

ⓘ Remarque Toolbox active le rechargement dynamique par défaut. Pour le désactiver, utilisez l’option --disable-reload.

Pour exécuter le serveur après avoir récupéré l’image de conteneur :

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"

ⓘ Remarque L’option -v monte votre fichier tools.yaml local dans le conteneur, et -p associe le port 5000 du conteneur au port 5000 de votre hôte.

Pour exécuter le serveur directement à partir des sources, accédez au répertoire racine du projet et exécutez :

go run .

ⓘ Remarque Cette commande exécute le projet à partir des sources et convient mieux au développement et aux tests. Elle ne compile pas de binaire dans votre $GOPATH. Pour compiler un binaire, consultez la documentation destinée aux développeurs.

Si vous avez installé Toolbox avec Homebrew, le binaire toolbox est disponible dans le chemin système. Vous pouvez démarrer le serveur avec la même commande :

toolbox --config "tools.yaml"

Pour exécuter Toolbox directement sans télécharger manuellement le binaire (Node.js requis) :

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

# Run Gemini CLI
gemini

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

Core

1. Installez Toolbox Core SDK :

   pip install toolbox-core
   

2. Chargez les outils :

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

Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox Core SDK, consultez le README du projet.

LangChain / LangGraph

1. Installez Toolbox LangChain SDK :

   pip install toolbox-langchain
   

2. Chargez les outils :

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

   Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox LangChain SDK, consultez le README du projet.

LlamaIndex

1. Installez Toolbox Llamaindex SDK :

   pip install toolbox-llamaindex
   

2. Chargez les outils :

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

   Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox Llamaindex SDK, consultez le README du projet.

Core

1. Installez Toolbox Core SDK :

   npm install @toolbox-sdk/core
   

2. Chargez les outils :

   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');
   

   Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox Core SDK, consultez le README du projet.

LangChain / LangGraph

1. Installez Toolbox Core SDK :

   npm install @toolbox-sdk/core
   

2. Chargez les outils :

   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. Installez Toolbox Core SDK :

   npm install @toolbox-sdk/core
   

2. Chargez les outils :

   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. Installez Toolbox ADK SDK :

   npm install @toolbox-sdk/adk
   

2. Chargez les outils :

   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');
   

   Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox ADK SDK, consultez le README du projet.

Core

1. Installez Toolbox Go SDK :

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

2. Chargez les outils :

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

   Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox Go SDK, consultez le README du projet.

LangChain Go

1. Installez Toolbox Go SDK :

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

2. Chargez les outils :

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

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

2. Chargez les outils :

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

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

2. Chargez les outils :

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

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

2. Chargez les outils :

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

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

2. Chargez les outils :

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

   Pour obtenir des instructions plus détaillées sur l’utilisation de Toolbox Go SDK, consultez le README du projet.