以二进制文件形式安装 Toolbox：

Linux (AMD64)

在 Linux (AMD64) 上以二进制文件形式安装 Toolbox：

# 其他版本请参见发布页面
export VERSION=1.0.0
curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

macOS (Apple Silicon)

在 macOS (Apple Silicon) 上以二进制文件形式安装 Toolbox：

# 其他版本请参见发布页面
export VERSION=1.0.0
curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/arm64/toolbox
chmod +x toolbox

macOS (Intel)

在 macOS (Intel) 上以二进制文件形式安装 Toolbox：

# 其他版本请参见发布页面
export VERSION=1.0.0
curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/amd64/toolbox
chmod +x toolbox

Windows (命令提示符)

在 Windows (命令提示符) 上以二进制文件形式安装 Toolbox：

:: 其他版本请参见发布页面
set VERSION=1.0.0
curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/amd64/toolbox.exe"

Windows (PowerShell)

在 Windows (PowerShell) 上以二进制文件形式安装 Toolbox：

# 其他版本请参见发布页面
$VERSION = "1.0.0"
curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/amd64/toolbox.exe"

# 其他版本请参见发布页面
export VERSION=1.0.0
docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION

在 macOS 或 Linux 上使用 Homebrew 安装 Toolbox：

brew install mcp-toolbox

要从源码安装，请确保已安装最新版本的 Go，然后运行以下命令：

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

# 安装 Gemini CLI
npm install -g @google/gemini-cli
# 安装扩展
gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgres
# 运行 Gemini CLI
gemini

通过 Gemini CLI 使用自然语言与你的自定义工具进行交互。

# 安装扩展
gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox

从二进制文件运行 Toolbox：

./toolbox --config "tools.yaml"

ⓘ 注意
Toolbox 默认启用动态重载功能。如需禁用，请使用 --disable-reload 标志。

拉取 容器镜像 后，运行以下命令启动服务器：

export VERSION=0.24.0 # 使用你拉取的版本
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"

ⓘ 注意
-v 标志会将本地的 tools.yaml 挂载到容器中，而 -p 则将容器的端口 5000 映射到主机的端口 5000。

若要直接从源代码运行服务器，请导航到项目根目录并执行：

go run .

ⓘ 注意
此命令会直接从源代码运行项目，更适合开发和测试。它不会编译出二进制文件并放置到你的 $GOPATH 中。如果你想编译二进制文件，请参阅 开发者文档。

如果你使用 Homebrew 安装了 Toolbox，toolbox 二进制文件将位于系统的 PATH 中。你可以使用相同的命令启动服务器：

toolbox --config "tools.yaml"

若想直接运行 Toolbox 而无需手动下载二进制文件（需要 Node.js）：

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

# 运行 Gemini CLI
gemini

# 列出扩展
/exttensions list
# 列出 MCP 服务器
/mcp list

核心 SDK

1. 安装 Toolbox Core SDK：

   pip install toolbox-core
   

2. 加载工具：

   from toolbox_core import ToolboxClient
   
   # 将 URL 更新为指向你的服务器
   async with ToolboxClient("http://127.0.0.1:5000") as client:
   
       # 这些工具可以传递给你的应用程序！
       tools = await client.load_toolset("toolset_name")
   

有关使用 Toolbox Core SDK 的更多详细说明，请参阅项目的 README。

LangChain / LangGraph

1. 安装 Toolbox LangChain SDK：

   pip install toolbox-langchain
   

2. 加载工具：

   from toolbox_langchain import ToolboxClient
   
   # 将 URL 更新为指向你的服务器
   async with ToolboxClient("http://127.0.0.1:5000") as client:
   
       # 这些工具可以传递给你的应用程序！
       tools = client.load_toolset()
   

有关使用 Toolbox LangChain SDK 的更多详细说明，请参阅项目的 README。

LlamaIndex

1. 安装 Toolbox Llamaindex SDK：

   pip install toolbox-llamaindex
   

2. 加载工具：

   from toolbox_llamaindex import ToolboxClient
   
   # 将 URL 更新为指向你的服务器
   async with ToolboxClient("http://127.0.0.1:5000") as client:
   
       # 这些工具可以传递给你的应用程序！
       tools = client.load_toolset()
   

有关使用 Toolbox Llamaindex SDK 的更多详细说明，请参阅项目的 README。

核心 SDK

1. 安装 Toolbox Core SDK：

   npm install @toolbox-sdk/core
   

2. 加载工具：

   import { ToolboxClient } from '@toolbox-sdk/core';
   
   // 将 URL 更新为指向你的服务器
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // 这些工具可以传递给你的应用程序！
   const tools = await client.load_toolset('toolsetName');
   

有关使用 Toolbox Core SDK 的更多详细说明，请参阅项目的 README。

LangChain / LangGraph

1. 安装 Toolbox Core SDK：

   npm install @toolbox-sdk/core
   

2. 加载工具：

   import { ToolboxClient } from '@toolbox-sdk/core';
   
   // 将 URL 更新为指向你的服务器
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   

// 这些工具可以传递给您的应用！ const toolboxTools = await client.loadToolset('toolsetName');

// 定义工具的基本信息：名称、描述、参数 schema 和核心逻辑
const getTool = (toolboxTool) => tool(currTool, {
    name: toolboxTool.getName(),
    description: toolboxTool.getDescription(),
    schema: toolboxTool.getParamSchema()
});

// 在您的 Langchain/Langgraph 应用中使用这些工具
const tools = toolboxTools.map(getTool);
```

Genkit

1. 安装 Toolbox Core SDK：

   npm install @toolbox-sdk/core
   

2. 加载工具：

   import { ToolboxClient } from '@toolbox-sdk/core';
   import { genkit } from 'genkit';
   
   // 初始化 genkit
   const ai = genkit({
       plugins: [
           googleAI({
               apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
           })
       ],
       model: googleAI.model('gemini-2.0-flash'),
   });
   
   // 将 URL 更新为指向您的服务器
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // 这些工具可以传递给您的应用！
   const toolboxTools = await client.loadToolset('toolsetName');
   
   // 定义工具的基本信息：名称、描述、参数 schema 和核心逻辑
   const getTool = (toolboxTool) => ai.defineTool({
       name: toolboxTool.getName(),
       description: toolboxTool.getDescription(),
       schema: toolboxTool.getParamSchema()
   }, toolboxTool)
   
   // 在您的 Genkit 应用中使用这些工具
   const tools = toolboxTools.map(getTool);
   

ADK

1. 安装 Toolbox ADK SDK：

   npm install @toolbox-sdk/adk
   

2. 加载工具：

   import { ToolboxClient } from '@toolbox-sdk/adk';
   
   // 将 URL 更新为指向您的服务器
   const URL = 'http://127.0.0.1:5000';
   let client = new ToolboxClient(URL);
   
   // 这些工具可以传递给您的应用！
   const tools = await client.loadToolset('toolsetName');
   

   有关 Toolbox ADK SDK 的更详细使用说明，请参阅 项目的 README 文件。

Core

1. 安装 Toolbox Go SDK：

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

2. 加载工具：

   package main
   
   import (
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "context"
   )
   
   func main() {
     // 务必添加错误检查
     // 将 URL 更新为指向您的服务器
     URL := "http://127.0.0.1:5000";
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // 框架无关的工具
     tools, err := client.LoadToolset("toolsetName", ctx)
   }
   

   有关 Toolbox Go SDK 的更详细使用说明，请参阅 项目的 README 文件。

LangChain Go

1. 安装 Toolbox Go SDK：

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

2. 加载工具：

   package main
   
   import (
     "context"
     "encoding/json"
   
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "github.com/tmc/langchaingo/llms"
   )
   
   func main() {
     // 务必添加错误检查
     // 将 URL 更新为指向您的服务器
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // 框架无关的工具
     tool, err := client.LoadTool("toolName", ctx)
   
     // 获取工具的输入 schema
     inputschema, err := tool.InputSchema()
   
     var paramsSchema map[string]any
     _ = json.Unmarshal(inputschema, &paramsSchema)
   
     // 在 LangChainGo 中使用此工具
     langChainTool := llms.Tool{
       Type: "function",
       Function: &llms.FunctionDefinition{
         Name:        tool.Name(),
         Description: tool.Description(),
         Parameters:  paramsSchema,
       },
     }
   }
   

Genkit

1. 安装 Toolbox Go SDK：

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

2. 加载工具：

   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() {
     // 务必添加错误检查
     // 将 URL 更新为指向您的服务器
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
     g := genkit.Init(ctx)
   
     client, err := core.NewToolboxClient(URL)
   
     // 框架无关的工具
     tool, err := client.LoadTool("toolName", ctx)
   
     // 使用 tbgenkit 包将工具转换
     // 在 Genkit Go 中使用此工具
     genkitTool, err := tbgenkit.ToGenkitTool(tool, g)
     if err != nil {
       log.Fatalf("工具转换失败：%v\n", err)
     }
     log.Printf("工具成功转换： %s", genkitTool.Name())
   }
   

Go GenAI

1. 安装 Toolbox Go SDK：

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

2. 加载工具：

   package main
   
   import (
     "context"
     "encoding/json"
   
     "github.com/googleapis/mcp-toolbox-sdk-go/core"
     "google.golang.org/genai"
   )
   
   func main() {
     // 务必添加错误检查
     // 将 URL 更新为指向您的服务器
     URL := "http://127.0.0.1:5000"
     ctx := context.Background()
   
     client, err := core.NewToolboxClient(URL)
   
     // 框架无关的工具
     tool, err := client.LoadTool("toolName", ctx)
   
     // 获取工具的输入 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:

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

2. Load tools:

   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:

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

2. Load tools:

   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.