MCP Toolbox for Databases

1![logo](./logo.png)
2 
3# MCP Toolbox for Databases
4 
5<a href="https://trendshift.io/repositories/13019" target="_blank"><img src="https://trendshift.io/api/badge/repositories/13019" alt="googleapis%2Fgenai-toolbox | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
6 
7[![Docs](https://img.shields.io/badge/docs-MCP_Toolbox-blue)](https://googleapis.github.io/genai-toolbox/)
8[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?style=flat&logo=discord&logoColor=white)](https://discord.gg/Dmm69peqjh)
9[![Medium](https://img.shields.io/badge/Medium-12100E?style=flat&logo=medium&logoColor=white)](https://medium.com/@mcp_toolbox)
10[![Go Report Card](https://goreportcard.com/badge/github.com/googleapis/genai-toolbox)](https://goreportcard.com/report/github.com/googleapis/genai-toolbox)
11 
12> [!NOTE]
13> MCP Toolbox for Databases is currently in beta, and may see breaking
14> changes until the first stable release (v1.0).
15 
16MCP Toolbox for Databases is an open source MCP server for databases. It enables
17you to develop tools easier, faster, and more securely by handling the complexities
18such as connection pooling, authentication, and more.
19 
20This README provides a brief overview. For comprehensive details, see the [full
21documentation](https://googleapis.github.io/genai-toolbox/).
22 
23> [!NOTE]
24> This solution was originally named “Gen AI Toolbox for Databases” as
25> its initial development predated MCP, but was renamed to align with recently
26> added MCP compatibility.
27 
28<!-- TOC ignore:true -->
29## Table of Contents
30 
31<!-- TOC -->
32 
33- [Why Toolbox?](#why-toolbox)
34- [General Architecture](#general-architecture)
35- [Getting Started](#getting-started)
36  - [Installing the server](#installing-the-server)
37  - [Running the server](#running-the-server)
38  - [Integrating your application](#integrating-your-application)
39  - [Using Toolbox with Gemini CLI Extensions](#using-toolbox-with-gemini-cli-extensions)
40- [Configuration](#configuration)
41  - [Sources](#sources)
42  - [Tools](#tools)
43  - [Toolsets](#toolsets)
44  - [Prompts](#prompts)
45- [Versioning](#versioning)
46  - [Pre-1.0.0 Versioning](#pre-100-versioning)
47  - [Post-1.0.0 Versioning](#post-100-versioning)
48- [Contributing](#contributing)
49- [Community](#community)
50 
51<!-- /TOC -->
52 
53## Why Toolbox?
54 
55Toolbox helps you build Gen AI tools that let your agents access data in your
56database. Toolbox provides:
57 
58- **Simplified development**: Integrate tools to your agent in less than 10
59  lines of code, reuse tools between multiple agents or frameworks, and deploy
60  new versions of tools more easily.
61- **Better performance**: Best practices such as connection pooling,
62  authentication, and more.
63- **Enhanced security**: Integrated auth for more secure access to your data
64- **End-to-end observability**: Out of the box metrics and tracing with built-in
65  support for OpenTelemetry.
66 
67**⚡ Supercharge Your Workflow with an AI Database Assistant ⚡**
68 
69Stop context-switching and let your AI assistant become a true co-developer. By
70[connecting your IDE to your databases with MCP Toolbox][connect-ide], you can
71delegate complex and time-consuming database tasks, allowing you to build faster
72and focus on what matters. This isn't just about code completion; it's about
73giving your AI the context it needs to handle the entire development lifecycle.
74 
75Here’s how it will save you time:
76 
77- **Query in Plain English**: Interact with your data using natural language
78  right from your IDE. Ask complex questions like, *"How many orders were
79  delivered in 2024, and what items were in them?"* without writing any SQL.
80- **Automate Database Management**: Simply describe your data needs, and let the
81  AI assistant manage your database for you. It can handle generating queries,
82  creating tables, adding indexes, and more.
83- **Generate Context-Aware Code**: Empower your AI assistant to generate
84  application code and tests with a deep understanding of your real-time
85  database schema.  This accelerates the development cycle by ensuring the
86  generated code is directly usable.
87- **Slash Development Overhead**: Radically reduce the time spent on manual
88  setup and boilerplate. MCP Toolbox helps streamline lengthy database
89  configurations, repetitive code, and error-prone schema migrations.
90 
91Learn [how to connect your AI tools (IDEs) to Toolbox using MCP][connect-ide].
92 
93[connect-ide]: https://googleapis.github.io/genai-toolbox/how-to/connect-ide/
94 
95## General Architecture
96 
97Toolbox sits between your application's orchestration framework and your
98database, providing a control plane that is used to modify, distribute, or
99invoke tools. It simplifies the management of your tools by providing you with a
100centralized location to store and update tools, allowing you to share tools
101between agents and applications and update those tools without necessarily
102redeploying your application.
103 
104<p align="center">
105<img src="./docs/en/getting-started/introduction/architecture.png" alt="architecture" width="50%"/>
106</p>
107 
108## Getting Started
109 
110### Quickstart: Running Toolbox using NPX
111 
112You can run Toolbox directly with a [configuration file](#configuration):
113 
114```sh
115npx @toolbox-sdk/server --tools-file tools.yaml
116```
117 
118This runs the latest version of the toolbox server with your configuration file.
119 
120> [!NOTE]
121> This method should only be used for non-production use cases such as
122> experimentation. For any production use-cases, please consider [Installing the
123> server](#installing-the-server) and then [running it](#running-the-server).
124 
125### Installing the server
126 
127For the latest version, check the [releases page][releases] and use the
128following instructions for your OS and CPU architecture.
129 
130[releases]: https://github.com/googleapis/genai-toolbox/releases
131 
132<details open>
133<summary>Binary</summary>
134 
135To install Toolbox as a binary:
136 
137<!-- {x-release-please-start-version} -->
138> <details>
139> <summary>Linux (AMD64)</summary>
140>
141> To install Toolbox as a binary on Linux (AMD64):
142>
143> ```sh
144> # see releases page for other versions
145> export VERSION=0.27.0
146> curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
147> chmod +x toolbox
148> ```
149>
150> </details>
151> <details>
152> <summary>macOS (Apple Silicon)</summary>
153>
154> To install Toolbox as a binary on macOS (Apple Silicon):
155>
156> ```sh
157> # see releases page for other versions
158> export VERSION=0.27.0
159> curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/darwin/arm64/toolbox
160> chmod +x toolbox
161> ```
162>
163> </details>
164> <details>
165> <summary>macOS (Intel)</summary>
166>
167> To install Toolbox as a binary on macOS (Intel):
168>
169> ```sh
170> # see releases page for other versions
171> export VERSION=0.27.0
172> curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/darwin/amd64/toolbox
173> chmod +x toolbox
174> ```
175>
176> </details>
177> <details>
178> <summary>Windows (Command Prompt)</summary>
179>
180> To install Toolbox as a binary on Windows (Command Prompt):
181>
182> ```cmd
183> :: see releases page for other versions
184> set VERSION=0.27.0
185> curl -o toolbox.exe "https://storage.googleapis.com/genai-toolbox/v%VERSION%/windows/amd64/toolbox.exe"
186> ```
187>
188> </details>
189> <details>
190> <summary>Windows (PowerShell)</summary>
191>
192> To install Toolbox as a binary on Windows (PowerShell):
193>
194> ```powershell
195> # see releases page for other versions
196> $VERSION = "0.27.0"
197> curl.exe -o toolbox.exe "https://storage.googleapis.com/genai-toolbox/v$VERSION/windows/amd64/toolbox.exe"
198> ```
199>
200> </details>
201</details>
202 
203<details>
204<summary>Container image</summary>
205You can also install Toolbox as a container:
206 
207```sh
208# see releases page for other versions
209export VERSION=0.27.0
210docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION
211```
212 
213</details>
214 
215<details>
216<summary>Homebrew</summary>
217 
218To install Toolbox using Homebrew on macOS or Linux:
219 
220```sh
221brew install mcp-toolbox
222```
223 
224</details>
225 
226<details>
227<summary>Compile from source</summary>
228 
229To install from source, ensure you have the latest version of
230[Go installed](https://go.dev/doc/install), and then run the following command:
231 
232```sh
233go install github.com/googleapis/genai-toolbox@v0.27.0
234```
235<!-- {x-release-please-end} -->
236 
237</details>
238 
239<details>
240<summary>Gemini CLI Extensions</summary>
241 
242To install Gemini CLI Extensions for MCP Toolbox, run the following command:
243 
244```sh
245gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox
246```
247 
248</details>
249 
250### Running the server
251 
252[Configure](#configuration) a `tools.yaml` to define your tools, and then
253execute `toolbox` to start the server:
254 
255<details open>
256<summary>Binary</summary>
257 
258To run Toolbox from binary:
259 
260```sh
261./toolbox --tools-file "tools.yaml"
262```
263 
264> ⓘ Note  
265> Toolbox enables dynamic reloading by default. To disable, use the
266> `--disable-reload` flag.
267 
268</details>
269 
270<details>
271 
272<summary>Container image</summary>
273 
274To run the server after pulling the [container image](#installing-the-server):
275 
276```sh
277export VERSION=0.24.0 # Use the version you pulled
278docker run -p 5000:5000 \
279-v $(pwd)/tools.yaml:/app/tools.yaml \
280us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION \
281--tools-file "/app/tools.yaml"
282```
283 
284> ⓘ Note  
285> The `-v` flag mounts your local `tools.yaml` into the container, and `-p` maps
286> the container's port `5000` to your host's port `5000`.
287 
288</details>
289 
290<details>
291 
292<summary>Source</summary>
293 
294To run the server directly from source, navigate to the project root directory
295and run:
296 
297```sh
298go run .
299```
300 
301> ⓘ Note  
302> This command runs the project from source, and is more suitable for development
303> and testing. It does **not** compile a binary into your `$GOPATH`. If you want
304> to compile a binary instead, refer the [Developer
305> Documentation](./DEVELOPER.md#building-the-binary).
306 
307</details>
308 
309<details>
310 
311<summary>Homebrew</summary>
312 
313If you installed Toolbox using [Homebrew](https://brew.sh/), the `toolbox`
314binary is available in your system path. You can start the server with the same
315command:
316 
317```sh
318toolbox --tools-file "tools.yaml"
319```
320 
321</details>
322 
323<details>
324<summary>NPM</summary>
325 
326To run Toolbox directly without manually downloading the binary (requires Node.js):
327```sh
328npx @toolbox-sdk/server --tools-file tools.yaml
329```
330 
331</details>
332 
333<details>
334 
335<summary>Gemini CLI</summary>
336 
337Interact with your custom tools using natural language. Check
338[gemini-cli-extensions/mcp-toolbox](https://github.com/gemini-cli-extensions/mcp-toolbox)
339for more information.
340 
341</details>
342 
343You can use `toolbox help` for a full list of flags! To stop the server, send a
344terminate signal (`ctrl+c` on most platforms).
345 
346For more detailed documentation on deploying to different environments, check
347out the resources in the [How-to
348section](https://googleapis.github.io/genai-toolbox/how-to/)
349 
350### Integrating your application
351 
352Once your server is up and running, you can load the tools into your
353application. See below the list of Client SDKs for using various frameworks:
354 
355<details open>
356  <summary>Python (<a href="https://github.com/googleapis/mcp-toolbox-sdk-python">Github</a>)</summary>
357  <br>
358  <blockquote>
359 
360  <details open>
361    <summary>Core</summary>
362 
3631. Install [Toolbox Core SDK][toolbox-core]:
364 
365    ```bash
366    pip install toolbox-core
367    ```
368 
3691. Load tools:
370 
371    ```python
372    from toolbox_core import ToolboxClient
373 
374    # update the url to point to your server
375    async with ToolboxClient("http://127.0.0.1:5000") as client:
376 
377        # these tools can be passed to your application!
378        tools = await client.load_toolset("toolset_name")
379    ```
380 
381For more detailed instructions on using the Toolbox Core SDK, see the
382[project's README][toolbox-core-readme].
383 
384[toolbox-core]: https://pypi.org/project/toolbox-core/
385[toolbox-core-readme]: https://github.com/googleapis/mcp-toolbox-sdk-python/tree/main/packages/toolbox-core/README.md
386 
387  </details>
388  <details>
389    <summary>LangChain / LangGraph</summary>
390 
3911. Install [Toolbox LangChain SDK][toolbox-langchain]:
392 
393    ```bash
394    pip install toolbox-langchain
395    ```
396 
3971. Load tools:
398 
399    ```python
400    from toolbox_langchain import ToolboxClient
401 
402    # update the url to point to your server
403    async with ToolboxClient("http://127.0.0.1:5000") as client:
404 
405        # these tools can be passed to your application!
406        tools = client.load_toolset()
407    ```
408 
409    For more detailed instructions on using the Toolbox LangChain SDK, see the
410    [project's README][toolbox-langchain-readme].
411 
412    [toolbox-langchain]: https://pypi.org/project/toolbox-langchain/
413    [toolbox-langchain-readme]: https://github.com/googleapis/mcp-toolbox-sdk-python/blob/main/packages/toolbox-langchain/README.md
414 
415  </details>
416  <details>
417    <summary>LlamaIndex</summary>
418 
4191. Install [Toolbox Llamaindex SDK][toolbox-llamaindex]:
420 
421    ```bash
422    pip install toolbox-llamaindex
423    ```
424 
4251. Load tools:
426 
427    ```python
428    from toolbox_llamaindex import ToolboxClient
429 
430    # update the url to point to your server
431    async with ToolboxClient("http://127.0.0.1:5000") as client:
432 
433        # these tools can be passed to your application!
434        tools = client.load_toolset()
435    ```
436 
437    For more detailed instructions on using the Toolbox Llamaindex SDK, see the
438    [project's README][toolbox-llamaindex-readme].
439 
440    [toolbox-llamaindex]: https://pypi.org/project/toolbox-llamaindex/
441    [toolbox-llamaindex-readme]: https://github.com/googleapis/genai-toolbox-llamaindex-python/blob/main/README.md
442 
443  </details>
444</details>
445</blockquote>
446<details>
447  <summary>Javascript/Typescript (<a href="https://github.com/googleapis/mcp-toolbox-sdk-js">Github</a>)</summary>
448  <br>
449  <blockquote>
450 
451  <details open>
452    <summary>Core</summary>
453 
4541. Install [Toolbox Core SDK][toolbox-core-js]:
455 
456    ```bash
457    npm install @toolbox-sdk/core
458    ```
459 
4601. Load tools:
461 
462    ```javascript
463    import { ToolboxClient } from '@toolbox-sdk/core';
464 
465    // update the url to point to your server
466    const URL = 'http://127.0.0.1:5000';
467    let client = new ToolboxClient(URL);
468 
469    // these tools can be passed to your application!
470    const tools = await client.loadToolset('toolsetName');
471    ```
472 
473    For more detailed instructions on using the Toolbox Core SDK, see the
474    [project's README][toolbox-core-js-readme].
475 
476    [toolbox-core-js]: https://www.npmjs.com/package/@toolbox-sdk/core
477    [toolbox-core-js-readme]: https://github.com/googleapis/mcp-toolbox-sdk-js/blob/main/packages/toolbox-core/README.md
478 
479  </details>
480  <details>
481    <summary>LangChain / LangGraph</summary>
482 
4831. Install [Toolbox Core SDK][toolbox-core-js]:
484 
485    ```bash
486    npm install @toolbox-sdk/core
487    ```
488 
4892. Load tools:
490 
491    ```javascript
492    import { ToolboxClient } from '@toolbox-sdk/core';
493 
494    // update the url to point to your server
495    const URL = 'http://127.0.0.1:5000';
496    let client = new ToolboxClient(URL);
497 
498    // these tools can be passed to your application!
499    const toolboxTools = await client.loadToolset('toolsetName');
500 
501    // Define the basics of the tool: name, description, schema and core logic
502    const getTool = (toolboxTool) => tool(currTool, {
503        name: toolboxTool.getName(),
504        description: toolboxTool.getDescription(),
505        schema: toolboxTool.getParamSchema()
506    });
507 
508    // Use these tools in your Langchain/Langraph applications
509    const tools = toolboxTools.map(getTool);
510    ```
511 
512  </details>
513  <details>
514    <summary>Genkit</summary>
515 
5161. Install [Toolbox Core SDK][toolbox-core-js]:
517 
518    ```bash
519    npm install @toolbox-sdk/core
520    ```
521 
5222. Load tools:
523 
524    ```javascript
525    import { ToolboxClient } from '@toolbox-sdk/core';
526    import { genkit } from 'genkit';
527 
528    // Initialise genkit
529    const ai = genkit({
530        plugins: [
531            googleAI({
532                apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
533            })
534        ],
535        model: googleAI.model('gemini-2.0-flash'),
536    });
537 
538    // update the url to point to your server
539    const URL = 'http://127.0.0.1:5000';
540    let client = new ToolboxClient(URL);
541 
542    // these tools can be passed to your application!
543    const toolboxTools = await client.loadToolset('toolsetName');
544 
545    // Define the basics of the tool: name, description, schema and core logic
546    const getTool = (toolboxTool) => ai.defineTool({
547        name: toolboxTool.getName(),
548        description: toolboxTool.getDescription(),
549        schema: toolboxTool.getParamSchema()
550    }, toolboxTool)
551 
552    // Use these tools in your Genkit applications
553    const tools = toolboxTools.map(getTool);
554    ```
555 
556  </details>
557  <details>
558    <summary>ADK</summary>
559 
5601. Install [Toolbox ADK SDK][toolbox-adk-js]:
561 
562    ```bash
563    npm install @toolbox-sdk/adk
564    ```
565 
5662. Load tools:
567 
568    ```javascript
569    import { ToolboxClient } from '@toolbox-sdk/adk';
570 
571    // update the url to point to your server
572    const URL = 'http://127.0.0.1:5000';
573    let client = new ToolboxClient(URL);
574 
575    // these tools can be passed to your application!
576    const tools = await client.loadToolset('toolsetName');
577    ```
578 
579    For more detailed instructions on using the Toolbox ADK SDK, see the
580    [project's README][toolbox-adk-js-readme].
581 
582    [toolbox-adk-js]: https://www.npmjs.com/package/@toolbox-sdk/adk
583    [toolbox-adk-js-readme]:
584       https://github.com/googleapis/mcp-toolbox-sdk-js/blob/main/packages/toolbox-adk/README.md
585 
586  </details>
587</details>
588</blockquote>
589<details>
590  <summary>Go (<a href="https://github.com/googleapis/mcp-toolbox-sdk-go">Github</a>)</summary>
591  <br>
592  <blockquote>
593 
594  <details>
595    <summary>Core</summary>
596 
5971. Install [Toolbox Go SDK][toolbox-go]:
598 
599    ```bash
600    go get github.com/googleapis/mcp-toolbox-sdk-go
601    ```
602 
6032. Load tools:
604 
605    ```go
606    package main
607 
608    import (
609      "github.com/googleapis/mcp-toolbox-sdk-go/core"
610      "context"
611    )
612 
613    func main() {
614      // Make sure to add the error checks
615      // update the url to point to your server
616      URL := "http://127.0.0.1:5000";
617      ctx := context.Background()
618 
619      client, err := core.NewToolboxClient(URL)
620 
621      // Framework agnostic tools
622      tools, err := client.LoadToolset("toolsetName", ctx)
623    }
624    ```
625 
626    For more detailed instructions on using the Toolbox Go SDK, see the
627    [project's README][toolbox-core-go-readme].
628 
629    [toolbox-go]: https://pkg.go.dev/github.com/googleapis/mcp-toolbox-sdk-go/core
630    [toolbox-core-go-readme]: https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/core/README.md
631 
632  </details>
633  <details>
634    <summary>LangChain Go</summary>
635 
6361. Install [Toolbox Go SDK][toolbox-go]:
637 
638    ```bash
639    go get github.com/googleapis/mcp-toolbox-sdk-go
640    ```
641 
6422. Load tools:
643 
644    ```go
645    package main
646 
647    import (
648      "context"
649      "encoding/json"
650 
651      "github.com/googleapis/mcp-toolbox-sdk-go/core"
652      "github.com/tmc/langchaingo/llms"
653    )
654 
655    func main() {
656      // Make sure to add the error checks
657      // update the url to point to your server
658      URL := "http://127.0.0.1:5000"
659      ctx := context.Background()
660 
661      client, err := core.NewToolboxClient(URL)
662 
663      // Framework agnostic tool
664      tool, err := client.LoadTool("toolName", ctx)
665 
666      // Fetch the tool's input schema
667      inputschema, err := tool.InputSchema()
668 
669      var paramsSchema map[string]any
670      _ = json.Unmarshal(inputschema, &paramsSchema)
671 
672      // Use this tool with LangChainGo
673      langChainTool := llms.Tool{
674        Type: "function",
675        Function: &llms.FunctionDefinition{
676          Name:        tool.Name(),
677          Description: tool.Description(),
678          Parameters:  paramsSchema,
679        },
680      }
681    }
682 
683    ```
684 
685  </details>
686  <details>
687    <summary>Genkit</summary>
688 
6891. Install [Toolbox Go SDK][toolbox-go]:
690 
691    ```bash
692    go get github.com/googleapis/mcp-toolbox-sdk-go
693    ```
694 
6952. Load tools:
696 
697    ```go
698    package main
699    import (
700      "context"
701      "log"
702 
703      "github.com/firebase/genkit/go/genkit"
704      "github.com/googleapis/mcp-toolbox-sdk-go/core"
705      "github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
706    )
707 
708    func main() {
709      // Make sure to add the error checks
710      // Update the url to point to your server
711      URL := "http://127.0.0.1:5000"
712      ctx := context.Background()
713      g := genkit.Init(ctx)
714 
715      client, err := core.NewToolboxClient(URL)
716 
717      // Framework agnostic tool
718      tool, err := client.LoadTool("toolName", ctx)
719 
720      // Convert the tool using the tbgenkit package
721      // Use this tool with Genkit Go
722      genkitTool, err := tbgenkit.ToGenkitTool(tool, g)
723      if err != nil {
724        log.Fatalf("Failed to convert tool: %v\n", err)
725      }
726      log.Printf("Successfully converted tool: %s", genkitTool.Name())
727    }
728    ```
729 
730  </details>
731  <details>
732    <summary>Go GenAI</summary>
733 
7341. Install [Toolbox Go SDK][toolbox-go]:
735 
736    ```bash
737    go get github.com/googleapis/mcp-toolbox-sdk-go
738    ```
739 
7402. Load tools:
741 
742    ```go
743    package main
744 
745    import (
746      "context"
747      "encoding/json"
748 
749      "github.com/googleapis/mcp-toolbox-sdk-go/core"
750      "google.golang.org/genai"
751    )
752 
753    func main() {
754      // Make sure to add the error checks
755      // Update the url to point to your server
756      URL := "http://127.0.0.1:5000"
757      ctx := context.Background()
758 
759      client, err := core.NewToolboxClient(URL)
760 
761      // Framework agnostic tool
762      tool, err := client.LoadTool("toolName", ctx)
763 
764      // Fetch the tool's input schema
765      inputschema, err := tool.InputSchema()
766 
767      var schema *genai.Schema
768      _ = json.Unmarshal(inputschema, &schema)
769 
770      funcDeclaration := &genai.FunctionDeclaration{
771        Name:        tool.Name(),
772        Description: tool.Description(),
773        Parameters:  schema,
774      }
775 
776      // Use this tool with Go GenAI
777      genAITool := &genai.Tool{
778        FunctionDeclarations: []*genai.FunctionDeclaration{funcDeclaration},
779      }
780    }
781    ```
782 
783  </details>
784  <details>
785    <summary>OpenAI Go</summary>
786 
7871. Install [Toolbox Go SDK][toolbox-go]:
788 
789    ```bash
790    go get github.com/googleapis/mcp-toolbox-sdk-go
791    ```
792 
7932. Load tools:
794 
795    ```go
796    package main
797 
798    import (
799      "context"
800      "encoding/json"
801 
802      "github.com/googleapis/mcp-toolbox-sdk-go/core"
803      openai "github.com/openai/openai-go"
804    )
805 
806    func main() {
807      // Make sure to add the error checks
808      // Update the url to point to your server
809      URL := "http://127.0.0.1:5000"
810      ctx := context.Background()
811 
812      client, err := core.NewToolboxClient(URL)
813 
814      // Framework agnostic tool
815      tool, err := client.LoadTool("toolName", ctx)
816 
817      // Fetch the tool's input schema
818      inputschema, err := tool.InputSchema()
819 
820      var paramsSchema openai.FunctionParameters
821      _ = json.Unmarshal(inputschema, &paramsSchema)
822 
823      // Use this tool with OpenAI Go
824      openAITool := openai.ChatCompletionToolParam{
825        Function: openai.FunctionDefinitionParam{
826          Name:        tool.Name(),
827          Description: openai.String(tool.Description()),
828          Parameters:  paramsSchema,
829        },
830      }
831 
832    }
833    ```
834 
835  </details>
836  <details open>
837    <summary>ADK Go</summary>
838 
8391. Install [Toolbox Go SDK][toolbox-go]:
840 
841    ```bash
842    go get github.com/googleapis/mcp-toolbox-sdk-go
843    ```
844 
8451. Load tools:
846 
847    ```go
848    package main
849 
850    import (
851      "github.com/googleapis/mcp-toolbox-sdk-go/tbadk"
852      "context"
853    )
854 
855    func main() {
856      // Make sure to add the error checks
857      // Update the url to point to your server
858      URL := "http://127.0.0.1:5000"
859      ctx := context.Background()
860      client, err := tbadk.NewToolboxClient(URL)
861      if err != nil {
862        return fmt.Sprintln("Could not start Toolbox Client", err)
863      }
864 
865      // Use this tool with ADK Go
866      tool, err := client.LoadTool("toolName", ctx)
867      if err != nil {
868        return fmt.Sprintln("Could not load Toolbox Tool", err)
869      }
870    }
871    ```
872 
873    For more detailed instructions on using the Toolbox Go SDK, see the
874    [project's README][toolbox-core-go-readme].
875 
876 
877  </details>
878</details>
879</blockquote>
880</details>
881 
882### Using Toolbox with Gemini CLI Extensions
883 
884[Gemini CLI extensions][gemini-cli-extensions] provide tools to interact
885directly with your data sources from command line. Below is a list of Gemini CLI
886extensions that are built on top of **Toolbox**. They allow you to interact with
887your data sources through pre-defined or custom tools with natural language.
888Click into the link to see detailed instructions on their usage.
889 
890To use **custom** tools with Gemini CLI:
891 
892- [MCP Toolbox](https://github.com/gemini-cli-extensions/mcp-toolbox)
893 
894To use [prebuilt tools][prebuilt] with Gemini CLI:
895 
896- [AlloyDB for PostgreSQL](https://github.com/gemini-cli-extensions/alloydb)
897- [AlloyDB for PostgreSQL
898  Observability](https://github.com/gemini-cli-extensions/alloydb-observability)
899- [BigQuery Data
900  Analytics](https://github.com/gemini-cli-extensions/bigquery-data-analytics)
901- [BigQuery Conversational
902  Analytics](https://github.com/gemini-cli-extensions/bigquery-conversational-analytics)
903- [Cloud SQL for
904  MySQL](https://github.com/gemini-cli-extensions/cloud-sql-mysql)
905- [Cloud SQL for MySQL
906  Observability](https://github.com/gemini-cli-extensions/cloud-sql-mysql-observability)
907- [Cloud SQL for
908  PostgreSQL](https://github.com/gemini-cli-extensions/cloud-sql-postgresql)
909- [Cloud SQL for PostgreSQL
910  Observability](https://github.com/gemini-cli-extensions/cloud-sql-postgresql-observability)
911- [Cloud SQL for SQL
912  Server](https://github.com/gemini-cli-extensions/cloud-sql-sqlserver)
913- [Cloud SQL for SQL Server
914  Observability](https://github.com/gemini-cli-extensions/cloud-sql-sqlserver-observability)
915- [Looker](https://github.com/gemini-cli-extensions/looker)
916- [Dataplex](https://github.com/gemini-cli-extensions/dataplex)
917- [MySQL](https://github.com/gemini-cli-extensions/mysql)
918- [PostgreSQL](https://github.com/gemini-cli-extensions/postgres)
919- [Spanner](https://github.com/gemini-cli-extensions/spanner)
920- [Firestore](https://github.com/gemini-cli-extensions/firestore-native)
921- [SQL Server](https://github.com/gemini-cli-extensions/sql-server)
922 
923[prebuilt]: https://googleapis.github.io/genai-toolbox/reference/prebuilt-tools/
924[gemini-cli-extensions]:
925    https://github.com/google-gemini/gemini-cli/blob/main/docs/extensions/index.md
926 
927## Configuration
928 
929The primary way to configure Toolbox is through the `tools.yaml` file. If you
930have multiple files, you can tell toolbox which to load with the `--tools-file
931tools.yaml` flag.
932 
933You can find more detailed reference documentation to all resource types in the
934[Resources](https://googleapis.github.io/genai-toolbox/resources/).
935 
936### Sources
937 
938The `sources` section of your `tools.yaml` defines what data sources your
939Toolbox should have access to. Most tools will have at least one source to
940execute against.
941 
942```yaml
943kind: sources
944name: my-pg-source
945type: postgres
946host: 127.0.0.1
947port: 5432
948database: toolbox_db
949user: toolbox_user
950password: my-password
951```
952 
953For more details on configuring different types of sources, see the
954[Sources](https://googleapis.github.io/genai-toolbox/resources/sources).
955 
956### Tools
957 
958The `tools` section of a `tools.yaml` define the actions an agent can take: what
959type of tool it is, which source(s) it affects, what parameters it uses, etc.
960 
961```yaml
962kind: tools
963name: search-hotels-by-name
964type: postgres-sql
965source: my-pg-source
966description: Search for hotels based on name.
967parameters:
968  - name: name
969    type: string
970    description: The name of the hotel.
971statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';
972```
973 
974For more details on configuring different types of tools, see the
975[Tools](https://googleapis.github.io/genai-toolbox/resources/tools).
976 
977### Toolsets
978 
979The `toolsets` section of your `tools.yaml` allows you to define groups of tools
980that you want to be able to load together. This can be useful for defining
981different groups based on agent or application.
982 
983```yaml
984toolsets:
985    my_first_toolset:
986        - my_first_tool
987        - my_second_tool
988    my_second_toolset:
989        - my_second_tool
990        - my_third_tool
991```
992 
993You can load toolsets by name:
994 
995```python
996# This will load all tools
997all_tools = client.load_toolset()
998 
999# This will only load the tools listed in 'my_second_toolset'
1000my_second_toolset = client.load_toolset("my_second_toolset")
1001```
1002 
1003### Prompts
1004 
1005The `prompts` section of a `tools.yaml` defines prompts that can be used for
1006interactions with LLMs.
1007 
1008```yaml
1009prompts:
1010  code_review:
1011    description: "Asks the LLM to analyze code quality and suggest improvements."
1012    messages:
1013      - content: "Please review the following code for quality, correctness, and potential improvements: \n\n{{.code}}"
1014    arguments:
1015      - name: "code"
1016        description: "The code to review"
1017```
1018 
1019For more details on configuring prompts, see the
1020[Prompts](https://googleapis.github.io/genai-toolbox/resources/prompts).
1021 
1022## Versioning
1023 
1024This project uses [semantic versioning](https://semver.org/) (`MAJOR.MINOR.PATCH`).
1025Since the project is in a pre-release stage (version `0.x.y`), we follow the
1026standard conventions for initial  development:
1027 
1028### Pre-1.0.0 Versioning
1029 
1030While the major version is `0`, the public API should be considered unstable.
1031The version will be incremented  as follows:
1032 
1033- **`0.MINOR.PATCH`**: The **MINOR** version is incremented when we add
1034  new functionality or make breaking, incompatible API changes.
1035- **`0.MINOR.PATCH`**: The **PATCH** version is incremented for
1036  backward-compatible bug fixes.
1037 
1038### Post-1.0.0 Versioning
1039 
1040Once the project reaches a stable `1.0.0` release, the version number
1041**`MAJOR.MINOR.PATCH`** will follow the more common convention:
1042 
1043- **`MAJOR`**: Incremented for incompatible API changes.
1044- **`MINOR`**: Incremented for new, backward-compatible functionality.
1045- **`PATCH`**: Incremented for backward-compatible bug fixes.
1046 
1047The public API that this applies to is the CLI associated with Toolbox, the
1048interactions with official SDKs, and the definitions in the `tools.yaml` file.
1049 
1050## Contributing
1051 
1052Contributions are welcome. Please, see the [CONTRIBUTING](CONTRIBUTING.md)
1053to get started.
1054 
1055Please note that this project is released with a Contributor Code of Conduct.
1056By participating in this project you agree to abide by its terms. See
1057[Contributor Code of Conduct](CODE_OF_CONDUCT.md) for more information.
1058 
1059## Community
1060 
1061Join our [discord community](https://discord.gg/GQrFB3Ec3W) to connect with our developers!
1062