Skip to content
Back to search

mcp-toolbox

MCP Toolbox for Databases is an open source MCP server for databases.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/googleapis/mcp-toolbox with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/googleapis/mcp-toolbox'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/googleapis--mcp-toolbox/badge.svg)](/listings/googleapis--mcp-toolbox)

HTML

<a href="/listings/googleapis--mcp-toolbox"><img src="/api/listings/googleapis--mcp-toolbox/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Stop context-switching and let your AI assistant become a true co-developer. By connecting your IDE to your databases with MCP Toolbox, you can query your data in plain English, automate schema discovery and management, and generate database-aware code.

You can use the Toolbox in any MCP-compatible IDE or client (e.g., Gemini CLI, Google Antigravity, Claude Code, Codex, etc.) by configuring the MCP server.

**Prebuilt tools are also conveniently available via the [Google Antigravity MCP Store](https://antigravity.google/docs/mcp) with a simple click-to-install experience.**

1. Add the following to your client's MCP configuration file (usually `mcp.json` or `claude_desktop_config.json`):

```json { "mcpServers": { "toolbox-postgres": { "command": "npx", "args": [ "-y", "@toolbox-sdk/server", "--prebuilt=postgres", "--stdio" ] } } } ```

2. Set the appropriate environment variables to connect, see the [Prebuilt Tools Reference](https://mcp-toolbox.dev/documentation/configuration/prebuilt-configs/).

When you run Toolbox with a `--prebuilt=<database>` flag, you instantly get access to standard tools to interact with that database. You can also specify a specific toolset using the `--prebuilt=<database>/<toolset>` syntax (e.g., `--prebuilt=postgres/data` to only load SQL tools).

Supported databases currently include: - **Google Cloud:** AlloyDB, BigQuery, Cloud SQL (PostgreSQL, MySQL, SQL Server), Spanner, Firestore, Knowledge Catalog (formerly known as Dataplex). - **Other Databases:** PostgreSQL, MySQL, [MariaDB](https://mcp-toolbox.dev/integrations/mariadb/source/), SQL Server, Oracle, MongoDB, Redis, Elasticsearch, CockroachDB, ClickHouse, Couchbase, Neo4j, Snowflake, Trino, and more.

For a full list of available tools and their capabilities across all supported databases, see the [Prebuilt Tools Reference](https://mcp-toolbox.dev/documentation/configuration/prebuilt-configs/).

*See the [Install & Run the Toolbox server](#install--run-the-toolbox-server) section for different execution methods like Docker or binaries.*

> [!TIP] > For users looking for a managed solution, [Google Cloud MCP Servers](https://cloud.google.com/blog/products/databases/managed-mcp-servers-for-google-cloud-databases) > provide a managed MCP experience with prebuilt tools; you can [learn more about the differences here](https://mcp-toolbox.dev/dev/reference/faq/).

---

<a id="configuration"></a>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 1,151 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. ![logo](./logo.png)
  3. # MCP Toolbox for Databases
  4. <a href="https://trendshift.io/repositories/25495" target="_blank"><img src="https://trendshift.io/api/badge/repositories/25495" alt="googleapis%2Fmcp-toolbox | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
  5. [![License: Apache
  6. 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  7. [![Docs](https://img.shields.io/badge/Docs-MCP_Toolbox-blue)](https://mcp-toolbox.dev/)
  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. [![Python SDK](https://img.shields.io/pypi/v/toolbox-core?logo=python&logoColor=white&label=Python%20SDK)](https://pypi.org/project/toolbox-core/)
  11. [![JS/TS SDK](https://img.shields.io/npm/v/@toolbox-sdk/core?logo=javascript&logoColor=white&label=JS%20SDK)](https://www.npmjs.com/package/@toolbox-sdk/core)
  12. [![Go SDK](https://img.shields.io/github/v/release/googleapis/mcp-toolbox-sdk-go?logo=go&logoColor=white&label=Go%20SDK)](https://pkg.go.dev/github.com/googleapis/mcp-toolbox-sdk-go)
  13. [![Java SDK](https://img.shields.io/maven-central/v/com.google.cloud.mcp/mcp-toolbox-sdk-java?logo=apache-maven&logoColor=white&label=Java%20SDK)](https://mvnrepository.com/artifact/com.google.cloud.mcp/mcp-toolbox-sdk-java)
  14. </div>
  15. MCP Toolbox for Databases is an open source Model Context Protocol (MCP) server that connects your AI agents, IDEs, and applications directly to your enterprise databases.
  16. <p align="center">
  17. <img src="docs/en/documentation/introduction/architecture.png" alt="architecture" width="50%"/>
  18. </p>
  19. It serves a **dual purpose**:
  20. 1. **Ready-to-use MCP Server (Build-Time):** Instantly connect Gemini CLI, Google Antigravity, Claude Code, Codex, or other MCP clients to your databases using our *prebuilt generic tools*. Talk to your data, explore schemas, and generate code without writing boilerplate.
  21. 2. **Custom Tools Framework (Run-Time):** A robust framework to build specialized, highly secure AI tools for your production agents. Define structured queries, semantic search, and NL2SQL capabilities safely and easily.
  22. This README provides a brief overview. For comprehensive details, see the [full documentation](https://mcp-toolbox.dev/).
  23. > [!IMPORTANT]
  24. > **Repository Name Update:** The `genai-toolbox` repository has been officially renamed to `mcp-toolbox`. To ensure your local environment reflects the new name, you may update your remote:
  25. > `git remote set-url origin https://github.com/googleapis/mcp-toolbox.git`
  26. > [!NOTE]
  27. > This solution was originally named “Gen AI Toolbox for Databases” (github.com/googleapis/genai-toolbox) as its initial development predated MCP, but was renamed to align with the MCP compatibility.
  28. <!-- TOC ignore:true -->
  29. ## Table of Contents
  30. - [Why MCP Toolbox?](#why-mcp-toolbox)
  31. - [Quick Start: Prebuilt Tools](#quick-start-prebuilt-tools)
  32. - [Quick Start: Custom Tools](#quick-start-custom-tools)
  33. - [Install & Run the Toolbox server](#install--run-the-toolbox-server)
  34. - [Connect to Toolbox](#connect-to-toolbox)
  35. - [MCP Client](#mcp-client)
  36. - [Toolbox SDKs: Integrate with your Application](#toolbox-sdks-integrate-with-your-application)
  37. - [Additional Features](#additional-features)
  38. - [Versioning](#versioning)
  39. - [Contributing](#contributing)
  40. - [Community](#community)
  41. ---
  42. ## Why MCP Toolbox?
  43. - **Out-of-the-Box Database Access:** Prebuilt generic tools for instant data exploration (e.g., `list_tables`, `execute_sql`) directly from your IDE or CLI.
  44. - **Custom Tools Framework:** Build production-ready tools with your own predefined logic, ensuring safety through Restricted Access, Structured Queries, and Semantic Search.
  45. - **Simplified Development:** Integrate tools into your Agent Development Kit (ADK), LangChain, LlamaIndex, or custom agents in less than 10 lines of code.
  46. - **Better Performance:** Handles connection pooling, integrated auth (IAM), and end-to-end observability (OpenTelemetry) out of the box.
  47. - **Enhanced Security**: Integrated authentication for more secure access to your data.
  48. - **End-to-end Observability**: Out of the box metrics and tracing with built-in support for OpenTelemetry.
  49. ---
  50. ## Quick Start: Prebuilt Tools
  51. Stop context-switching and let your AI assistant become a true co-developer. By connecting your IDE to your databases with MCP Toolbox, you can query your data in plain English, automate schema discovery and management, and generate database-aware code.
  52. You can use the Toolbox in any MCP-compatible IDE or client (e.g., Gemini CLI, Google Antigravity, Claude Code, Codex, etc.) by configuring the MCP server.
  53. **Prebuilt tools are also conveniently available via the [Google Antigravity MCP Store](https://antigravity.google/docs/mcp) with a simple click-to-install experience.**
  54. 1. Add the following to your client's MCP configuration file (usually `mcp.json` or `claude_desktop_config.json`):
  55. ```json
  56. {
  57. "mcpServers": {
  58. "toolbox-postgres": {
  59. "command": "npx",
  60. "args": [
  61. "-y",
  62. "@toolbox-sdk/server",
  63. "--prebuilt=postgres",
  64. "--stdio"
  65. ]
  66. }
  67. }
  68. }
  69. ```
  70. 2. Set the appropriate environment variables to connect, see the [Prebuilt Tools Reference](https://mcp-toolbox.dev/documentation/configuration/prebuilt-configs/).
  71. When you run Toolbox with a `--prebuilt=<database>` flag, you instantly get access to standard tools to interact with that database. You can also specify a specific toolset using the `--prebuilt=<database>/<toolset>` syntax (e.g., `--prebuilt=postgres/data` to only load SQL tools).
  72. Supported databases currently include:
  73. - **Google Cloud:** AlloyDB, BigQuery, Cloud SQL (PostgreSQL, MySQL, SQL Server), Spanner, Firestore, Knowledge Catalog (formerly known as Dataplex).
  74. - **Other Databases:** PostgreSQL, MySQL, [MariaDB](https://mcp-toolbox.dev/integrations/mariadb/source/), SQL Server, Oracle, MongoDB, Redis, Elasticsearch, CockroachDB, ClickHouse, Couchbase, Neo4j, Snowflake, Trino, and more.
  75. For a full list of available tools and their capabilities across all supported databases, see the [Prebuilt Tools Reference](https://mcp-toolbox.dev/documentation/configuration/prebuilt-configs/).
  76. *See the [Install & Run the Toolbox server](#install--run-the-toolbox-server) section for different execution methods like Docker or binaries.*
  77. > [!TIP]
  78. > For users looking for a managed solution, [Google Cloud MCP Servers](https://cloud.google.com/blog/products/databases/managed-mcp-servers-for-google-cloud-databases)
  79. > provide a managed MCP experience with prebuilt tools; you can [learn more about the differences here](https://mcp-toolbox.dev/dev/reference/faq/).
  80. ---
  81. <a id="configuration"></a>
  82. ## Quick Start: Custom Tools
  83. Toolbox can also be used as a framework for customized tools.
  84. The primary way to configure Toolbox is through the `tools.yaml` file. If you
  85. have multiple files, you can tell Toolbox which to load with the `--config
  86. tools.yaml` flag.
  87. You can find more detailed reference documentation to all resource types in the
  88. [Resources](https://mcp-toolbox.dev/documentation/configuration/).
  89. ### Sources
  90. The `sources` section of your `tools.yaml` defines what data sources your
  91. Toolbox should have access to. Most tools will have at least one source to
  92. execute against.
  93. ```yaml
  94. kind: source
  95. name: my-pg-source
  96. type: postgres
  97. host: 127.0.0.1
  98. port: 5432
  99. database: toolbox_db
  100. user: toolbox_user
  101. password: my-password
  102. ```
  103. For more details on configuring different types of sources, see the
  104. [Sources](https://mcp-toolbox.dev/documentation/configuration/sources/).
  105. ### Tools
  106. The `tools` section of a `tools.yaml` define the actions an agent can take: what
  107. type of tool it is, which source(s) it affects, what parameters it uses, etc.
  108. ```yaml
  109. kind: tool
  110. name: search-hotels-by-name
  111. type: postgres-sql
  112. source: my-pg-source
  113. description: Search for hotels based on name.
  114. parameters:
  115. - name: name
  116. type: string
  117. description: The name of the hotel.
  118. statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';
  119. ```
  120. For more details on configuring different types of tools, see the
  121. [Tools](https://mcp-toolbox.dev/documentation/configuration/tools/).
  122. ### Toolsets
  123. The `toolsets` section of your `tools.yaml` allows you to define groups of tools
  124. that you want to be able to load together. This can be useful for defining
  125. different groups based on agent or application.
  126. ```yaml
  127. kind: toolset
  128. name: my_first_toolset
  129. tools:
  130. - my_first_tool
  131. - my_second_tool
  132. ---
  133. kind: toolset
  134. name: my_second_toolset
  135. tools:
  136. - my_second_tool
  137. - my_third_tool
  138. ```
  139. ### Prompts
  140. The `prompts` section of a `tools.yaml` defines prompts that can be used for
  141. interactions with LLMs.
  142. ```yaml
  143. kind: prompt
  144. name: code_review
  145. description: "Asks the LLM to analyze code quality and suggest improvements."
  146. messages:
  147. - content: >
  148. Please review the following code for quality, correctness,
  149. and potential improvements: \n\n{{.code}}
  150. arguments:
  151. - name: "code"
  152. description: "The code to review"
  153. ```
  154. For more details on configuring prompts, see the
  155. [Prompts](https://mcp-toolbox.dev/documentation/configuration/prompts/).
  156. ### Resources
  157. The `resources` and `resourceTemplates` sections of your `tools.yaml` define read-only
  158. content, files, or parameterized directory trees that can be discovered and retrieved
  159. by MCP clients:
  160. ```yaml
  161. kind: resource
  162. name: database_schema_ddl
  163. type: text
  164. description: "Core table definitions and constraints."
  165. mimeType: text/x-sql
  166. text: |
  167. CREATE TABLE customers (
  168. id SERIAL PRIMARY KEY,
  169. name VARCHAR(255) NOT NULL,
  170. email VARCHAR(255) UNIQUE NOT NULL
  171. );
  172. ---
  173. kind: resource
  174. name: database_schema
  175. type: file
  176. description: "PostgreSQL schema definition."
  177. path: "./schema.sql"
  178. ---
  179. kind: resourceTemplate
  180. name: server_logs
  181. type: file
  182. description: "Application log files."
  183. uriTemplate: "file:///var/log/{path}"
  184. allowedPaths:
  185. - "/var/log"
  186. ```
  187. For more details on configuring resources and resource templates, see
  188. [Resources](https://mcp-toolbox.dev/documentation/configuration/resources/).
  189. ---
  190. ## Install & Run the Toolbox server
  191. You can run Toolbox directly with a [configuration file](#quick-start-custom-tools):
  192. ```sh
  193. npx @toolbox-sdk/server --config tools.yaml
  194. ```
  195. This runs the latest version of the Toolbox server with your configuration file.
  196. > [!NOTE]
  197. > This method is optimized for convenience rather than performance.
  198. > For a more standard and reliable installation, please use the binary
  199. > or container image as described in [Install & Run the Toolbox server](#install--run-the-toolbox-server).
  200. ### Install Toolbox
  201. For the latest version, check the [releases page][releases] and use the
  202. following instructions for your OS and CPU architecture.
  203. [releases]: https://github.com/googleapis/mcp-toolbox/releases
  204. <details open>
  205. <summary>Binary</summary>
  206. To install Toolbox as a binary:
  207. <!-- {x-release-please-start-version} -->
  208. > <details>
  209. > <summary>Linux (AMD64)</summary>
  210. >
  211. > To install Toolbox as a binary on Linux (AMD64):
  212. >
  213. > ```sh
  214. > # see releases page for other versions
  215. > export VERSION=1.17.0
  216. > curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/linux/amd64/toolbox
  217. > chmod +x toolbox
  218. > ```
  219. >
  220. > </details>
  221. > <details>
  222. > <summary>macOS (Apple Silicon)</summary>
  223. >
  224. > To install Toolbox as a binary on macOS (Apple Silicon):
  225. >
  226. > ```sh
  227. > # see releases page for other versions
  228. > export VERSION=1.17.0
  229. > curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/arm64/toolbox
  230. > chmod +x toolbox
  231. > ```
  232. >
  233. > </details>
  234. > <details>
  235. > <summary>macOS (Intel)</summary>
  236. >
  237. > To install Toolbox as a binary on macOS (Intel):
  238. >
  239. > ```sh
  240. > # see releases page for other versions
  241. > export VERSION=1.17.0
  242. > curl -L -o toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/darwin/amd64/toolbox
  243. > chmod +x toolbox
  244. > ```
  245. >
  246. > </details>
  247. > <details>
  248. > <summary>Windows (Command Prompt)</summary>
  249. >
  250. > To install Toolbox as a binary on Windows (Command Prompt):
  251. >
  252. > ```cmd
  253. > :: see releases page for other versions
  254. > set VERSION=1.17.0
  255. > curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/amd64/toolbox.exe"
  256. > ```
  257. >
  258. > </details>
  259. > <details>
  260. > <summary>Windows (PowerShell)</summary>
  261. >
  262. > To install Toolbox as a binary on Windows (PowerShell):
  263. >
  264. > ```powershell
  265. > # see releases page for other versions
  266. > $VERSION = "1.17.0"
  267. > curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/amd64/toolbox.exe"
  268. > ```
  269. >
  270. > </details>
  271. > <details>
  272. > <summary>Windows ARM64 (Command Prompt)</summary>
  273. >
  274. > To install Toolbox as a binary on Windows ARM64 (Command Prompt):
  275. >
  276. > ```cmd
  277. > :: see releases page for other versions
  278. > set VERSION=1.17.0
  279. > curl -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v%VERSION%/windows/arm64/toolbox.exe"
  280. > ```
  281. >
  282. > </details>
  283. > <details>
  284. > <summary>Windows ARM64 (PowerShell)</summary>
  285. >
  286. > To install Toolbox as a binary on Windows ARM64 (PowerShell):
  287. >
  288. > ```powershell
  289. > # see releases page for other versions
  290. > $VERSION = "1.17.0"
  291. > curl.exe -o toolbox.exe "https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/windows/arm64/toolbox.exe"
  292. > ```
  293. >
  294. > </details>
  295. </details>
  296. <details>
  297. <summary>Container image</summary>
  298. You can also install Toolbox as a container:
  299. ```sh
  300. # see releases page for other versions
  301. export VERSION=1.17.0
  302. docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION
  303. ```
  304. </details>
  305. <details>
  306. <summary>Homebrew</summary>
  307. To install Toolbox using Homebrew on macOS or Linux:
  308. ```sh
  309. brew install mcp-toolbox
  310. ```
  311. </details>
  312. <details>
  313. <summary>Compile from source</summary>
  314. To install from source, ensure you have the latest version of
  315. [Go installed](https://go.dev/doc/install), and then run the following command:
  316. ```sh
  317. go install github.com/googleapis/mcp-toolbox@v1.17.0
  318. ```
  319. <!-- {x-release-please-end} -->
  320. </details>
  321. <details>
  322. <summary>Gemini CLI</summary>
  323. Check out the [Gemini CLI extensions](https://geminicli.com/extensions/) to install prebuilt tools for specific databases like AlloyDB, BigQuery, and Cloud SQL directly into Gemini CLI.
  324. ```sh
  325. # Install Gemini CLI
  326. npm install -g @google/gemini-cli
  327. # Install the extension
  328. gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgres
  329. # Run Gemini CLI
  330. gemini
  331. ```
  332. Interact with your custom tools using natural language through the Gemini CLI.
  333. ```sh
  334. # Install the extension
  335. gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox
  336. ```
  337. </details>
  338. ### Run Toolbox
  339. [Configure](#quick-start-custom-tools) a `tools.yaml` to define your tools, and then
  340. execute `toolbox` to start the server:
  341. <details open>
  342. <summary>Binary</summary>
  343. To run Toolbox from binary:
  344. ```sh
  345. ./toolbox --config "tools.yaml"
  346. ```
  347. > ⓘ Note
  348. > Toolbox enables dynamic reloading by default. To disable, use the
  349. > `--disable-reload` flag.
  350. </details>
  351. <details>
  352. <summary>Container image</summary>
  353. To run the server after pulling the [container image](#install-toolbox):
  354. ```sh
  355. export VERSION=0.24.0 # Use the version you pulled
  356. docker run -p 5000:5000 \
  357. -v $(pwd)/tools.yaml:/app/tools.yaml \
  358. us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION \
  359. --config "/app/tools.yaml"
  360. ```
  361. > ⓘ Note
  362. > The `-v` flag mounts your local `tools.yaml` into the container, and `-p` maps
  363. > the container's port `5000` to your host's port `5000`.
  364. </details>
  365. <details>
  366. <summary>Source</summary>
  367. To run the server directly from source, navigate to the project root directory
  368. and run:
  369. ```sh
  370. go run .
  371. ```
  372. > ⓘ Note
  373. > This command runs the project from source, and is more suitable for development
  374. > and testing. It does **not** compile a binary into your `$GOPATH`. If you want
  375. > to compile a binary instead, refer the [Developer
  376. > Documentation](./DEVELOPER.md#building-the-binary).
  377. </details>
  378. <details>
  379. <summary>Homebrew</summary>
  380. If you installed Toolbox using [Homebrew](https://brew.sh/), the `toolbox`
  381. binary is available in your system path. You can start the server with the same
  382. command:
  383. ```sh
  384. toolbox --config "tools.yaml"
  385. ```
  386. </details>
  387. <details>
  388. <summary>NPM</summary>
  389. To run Toolbox directly without manually downloading the binary (requires Node.js):
  390. ```sh
  391. npx @toolbox-sdk/server --config tools.yaml
  392. ```
  393. </details>
  394. <details>
  395. <summary>Gemini CLI</summary>
  396. After installing a [Gemini CLI extensions](https://geminicli.com/extensions/), the prebuilt tools will be available during use.
  397. ```sh
  398. # Run Gemini CLI
  399. gemini
  400. # List extensions
  401. /extensions list
  402. # List MCP servers
  403. /mcp list
  404. ```
  405. </details>
  406. You can use `toolbox help` for a full list of flags! To stop the server, send a
  407. terminate signal (`ctrl+c` on most platforms).
  408. For more detailed documentation on deploying to different environments, check
  409. out the resources in the [Deploy Toolbox
  410. section](https://mcp-toolbox.dev/documentation/deploy-to/)
  411. ---
  412. ## Connect to Toolbox
  413. Once your Toolbox server is up and running, you can load tools into your MCP-compatible client or
  414. application.
  415. ### MCP Client
  416. Add the following configuration to your MCP client configuration:
  417. ```json
  418. {
  419. "mcpServers": {
  420. "toolbox": {
  421. "type": "http",
  422. "url": "http://127.0.0.1:5000/mcp",
  423. }
  424. }
  425. }
  426. ```
  427. If you would like to connect to a specific toolset, replace url with "http://127.0.0.1:5000/mcp/{toolset_name}".
  428. ### Toolbox SDKs: Integrate with your Application
  429. Toolbox Client SDKs provide the easy-to-use building blocks and advanced features for connecting your custom applications to the MCP Toolbox server. See below the list of Client SDKs for using various frameworks:
  430. <details open>
  431. <summary>Python (<a href="https://github.com/googleapis/mcp-toolbox-sdk-python">Github</a>)</summary>
  432. <br>
  433. <blockquote>
  434. <details open>
  435. <summary>Core</summary>
  436. 1. Install [Toolbox Core SDK][toolbox-core]:
  437. ```bash
  438. pip install toolbox-core
  439. ```
  440. 1. Load tools:
  441. ```python
  442. from toolbox_core import ToolboxClient
  443. # update the url to point to your server
  444. async with ToolboxClient("http://127.0.0.1:5000") as client:
  445. # these tools can be passed to your application!
  446. tools = await client.load_toolset("toolset_name")
  447. ```
  448. For more detailed instructions on using the Toolbox Core SDK, see the
  449. [project's README][toolbox-core-readme].
  450. [toolbox-core]: https://pypi.org/project/toolbox-core/
  451. [toolbox-core-readme]: https://github.com/googleapis/mcp-toolbox-sdk-python/tree/main/packages/toolbox-core/README.md
  452. </details>
  453. <details>
  454. <summary>LangChain / LangGraph</summary>
  455. 1. Install [Toolbox LangChain SDK][toolbox-langchain]:
  456. ```bash
  457. pip install toolbox-langchain
  458. ```
  459. 1. Load tools:
  460. ```python
  461. from toolbox_langchain import ToolboxClient
  462. # update the url to point to your server
  463. async with ToolboxClient("http://127.0.0.1:5000") as client:
  464. # these tools can be passed to your application!
  465. tools = client.load_toolset()
  466. ```
  467. For more detailed instructions on using the Toolbox LangChain SDK, see the
  468. [project's README][toolbox-langchain-readme].
  469. [toolbox-langchain]: https://pypi.org/project/toolbox-langchain/
  470. [toolbox-langchain-readme]: https://github.com/googleapis/mcp-toolbox-sdk-python/blob/main/packages/toolbox-langchain/README.md
  471. </details>
  472. <details>
  473. <summary>LlamaIndex</summary>
  474. 1. Install [Toolbox Llamaindex SDK][toolbox-llamaindex]:
  475. ```bash
  476. pip install toolbox-llamaindex
  477. ```
  478. 1. Load tools:
  479. ```python
  480. from toolbox_llamaindex import ToolboxClient
  481. # update the url to point to your server
  482. async with ToolboxClient("http://127.0.0.1:5000") as client:
  483. # these tools can be passed to your application!
  484. tools = client.load_toolset()
  485. ```
  486. For more detailed instructions on using the Toolbox Llamaindex SDK, see the
  487. [project's README][toolbox-llamaindex-readme].
  488. [toolbox-llamaindex]: https://pypi.org/project/toolbox-llamaindex/
  489. [toolbox-llamaindex-readme]: https://github.com/googleapis/genai-toolbox-llamaindex-python/blob/main/README.md
  490. </details>
  491. </details>
  492. </blockquote>
  493. <details>
  494. <summary>Javascript/Typescript (<a href="https://github.com/googleapis/mcp-toolbox-sdk-js">Github</a>)</summary>
  495. <br>
  496. <blockquote>
  497. <details open>
  498. <summary>Core</summary>
  499. 1. Install [Toolbox Core SDK][toolbox-core-js]:
  500. ```bash
  501. npm install @toolbox-sdk/core
  502. ```
  503. 1. Load tools:
  504. ```javascript
  505. import { ToolboxClient } from '@toolbox-sdk/core';
  506. // update the url to point to your server
  507. const URL = 'http://127.0.0.1:5000';
  508. let client = new ToolboxClient(URL);
  509. // these tools can be passed to your application!
  510. const tools = await client.loadToolset('toolsetName');
  511. ```
  512. For more detailed instructions on using the Toolbox Core SDK, see the
  513. [project's README][toolbox-core-js-readme].
  514. [toolbox-core-js]: https://www.npmjs.com/package/@toolbox-sdk/core
  515. [toolbox-core-js-readme]: https://github.com/googleapis/mcp-toolbox-sdk-js/blob/main/packages/toolbox-core/README.md
  516. </details>
  517. <details>
  518. <summary>LangChain / LangGraph</summary>
  519. 1. Install [Toolbox Core SDK][toolbox-core-js]:
  520. ```bash
  521. npm install @toolbox-sdk/core
  522. ```
  523. 2. Load tools:
  524. ```javascript
  525. import { ToolboxClient } from '@toolbox-sdk/core';
  526. // update the url to point to your server
  527. const URL = 'http://127.0.0.1:5000';
  528. let client = new ToolboxClient(URL);
  529. // these tools can be passed to your application!
  530. const toolboxTools = await client.loadToolset('toolsetName');
  531. // Define the basics of the tool: name, description, schema and core logic
  532. const getTool = (toolboxTool) => tool(currTool, {
  533. name: toolboxTool.getName(),
  534. description: toolboxTool.getDescription(),
  535. schema: toolboxTool.getParamSchema()
  536. });
  537. // Use these tools in your Langchain/Langraph applications
  538. const tools = toolboxTools.map(getTool);
  539. ```
  540. </details>
  541. <details>
  542. <summary>Genkit</summary>
  543. 1. Install [Toolbox Core SDK][toolbox-core-js]:
  544. ```bash
  545. npm install @toolbox-sdk/core
  546. ```
  547. 2. Load tools:
  548. ```javascript
  549. import { ToolboxClient } from '@toolbox-sdk/core';
  550. import { genkit } from 'genkit';
  551. // Initialise genkit
  552. const ai = genkit({
  553. plugins: [
  554. googleAI({
  555. apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
  556. })
  557. ],
  558. model: googleAI.model('gemini-3.8-flash'),
  559. });
  560. // update the url to point to your server
  561. const URL = 'http://127.0.0.1:5000';
  562. let client = new ToolboxClient(URL);
  563. // these tools can be passed to your application!
  564. const toolboxTools = await client.loadToolset('toolsetName');
  565. // Define the basics of the tool: name, description, schema and core logic
  566. const getTool = (toolboxTool) => ai.defineTool({
  567. name: toolboxTool.getName(),
  568. description: toolboxTool.getDescription(),
  569. schema: toolboxTool.getParamSchema()
  570. }, toolboxTool)
  571. // Use these tools in your Genkit applications
  572. const tools = toolboxTools.map(getTool);
  573. ```
  574. </details>
  575. <details>
  576. <summary>ADK</summary>
  577. 1. Install [Toolbox ADK SDK][toolbox-adk-js]:
  578. ```bash
  579. npm install @toolbox-sdk/adk
  580. ```
  581. 2. Load tools:
  582. ```javascript
  583. import { ToolboxClient } from '@toolbox-sdk/adk';
  584. // update the url to point to your server
  585. const URL = 'http://127.0.0.1:5000';
  586. let client = new ToolboxClient(URL);
  587. // these tools can be passed to your application!
  588. const tools = await client.loadToolset('toolsetName');
  589. ```
  590. For more detailed instructions on using the Toolbox ADK SDK, see the
  591. [project's README][toolbox-adk-js-readme].
  592. [toolbox-adk-js]: https://www.npmjs.com/package/@toolbox-sdk/adk
  593. [toolbox-adk-js-readme]:
  594. https://github.com/googleapis/mcp-toolbox-sdk-js/blob/main/packages/toolbox-adk/README.md
  595. </details>
  596. </details>
  597. </blockquote>
  598. <details>
  599. <summary>Go (<a href="https://github.com/googleapis/mcp-toolbox-sdk-go">Github</a>)</summary>
  600. <br>
  601. <blockquote>
  602. <details>
  603. <summary>Core</summary>
  604. 1. Install [Toolbox Go SDK][toolbox-go]:
  605. ```bash
  606. go get github.com/googleapis/mcp-toolbox-sdk-go
  607. ```
  608. 2. Load tools:
  609. ```go
  610. package main
  611. import (
  612. "github.com/googleapis/mcp-toolbox-sdk-go/core"
  613. "context"
  614. )
  615. func main() {
  616. // Make sure to add the error checks
  617. // update the url to point to your server
  618. URL := "http://127.0.0.1:5000";
  619. ctx := context.Background()
  620. client, err := core.NewToolboxClient(URL)
  621. // Framework agnostic tools
  622. tools, err := client.LoadToolset("toolsetName", ctx)
  623. }
  624. ```
  625. For more detailed instructions on using the Toolbox Go SDK, see the
  626. [project's README][toolbox-core-go-readme].
  627. [toolbox-go]: https://pkg.go.dev/github.com/googleapis/mcp-toolbox-sdk-go/core
  628. [toolbox-core-go-readme]: https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/core/README.md
  629. </details>
  630. <details>
  631. <summary>LangChain Go</summary>
  632. 1. Install [Toolbox Go SDK][toolbox-go]:
  633. ```bash
  634. go get github.com/googleapis/mcp-toolbox-sdk-go
  635. ```
  636. 2. Load tools:
  637. ```go
  638. package main
  639. import (
  640. "context"
  641. "encoding/json"
  642. "github.com/googleapis/mcp-toolbox-sdk-go/core"
  643. "github.com/tmc/langchaingo/llms"
  644. )
  645. func main() {
  646. // Make sure to add the error checks
  647. // update the url to point to your server
  648. URL := "http://127.0.0.1:5000"
  649. ctx := context.Background()
  650. client, err := core.NewToolboxClient(URL)
  651. // Framework agnostic tool
  652. tool, err := client.LoadTool("toolName", ctx)
  653. // Fetch the tool's input schema
  654. inputschema, err := tool.InputSchema()
  655. var paramsSchema map[string]any
  656. _ = json.Unmarshal(inputschema, &paramsSchema)
  657. // Use this tool with LangChainGo
  658. langChainTool := llms.Tool{
  659. Type: "function",
  660. Function: &llms.FunctionDefinition{
  661. Name: tool.Name(),
  662. Description: tool.Description(),
  663. Parameters: paramsSchema,
  664. },
  665. }
  666. }
  667. ```
  668. </details>
  669. <details>
  670. <summary>Genkit</summary>
  671. 1. Install [Toolbox Go SDK][toolbox-go]:
  672. ```bash
  673. go get github.com/googleapis/mcp-toolbox-sdk-go
  674. ```
  675. 2. Load tools:
  676. ```go
  677. package main
  678. import (
  679. "context"
  680. "log"
  681. "github.com/firebase/genkit/go/genkit"
  682. "github.com/googleapis/mcp-toolbox-sdk-go/core"
  683. "github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
  684. )
  685. func main() {
  686. // Make sure to add the error checks
  687. // Update the url to point to your server
  688. URL := "http://127.0.0.1:5000"
  689. ctx := context.Background()
  690. g := genkit.Init(ctx)
  691. client, err := core.NewToolboxClient(URL)
  692. // Framework agnostic tool
  693. tool, err := client.LoadTool("toolName", ctx)
  694. // Convert the tool using the tbgenkit package
  695. // Use this tool with Genkit Go
  696. genkitTool, err := tbgenkit.ToGenkitTool(tool, g)
  697. if err != nil {
  698. log.Fatalf("Failed to convert tool: %v\n", err)
  699. }
  700. log.Printf("Successfully converted tool: %s", genkitTool.Name())
  701. }
  702. ```
  703. </details>
  704. <details>
  705. <summary>Go GenAI</summary>
  706. 1. Install [Toolbox Go SDK][toolbox-go]:
  707. ```bash
  708. go get github.com/googleapis/mcp-toolbox-sdk-go
  709. ```
  710. 2. Load tools:
  711. ```go
  712. package main
  713. import (
  714. "context"
  715. "encoding/json"
  716. "github.com/googleapis/mcp-toolbox-sdk-go/core"
  717. "google.golang.org/genai"
  718. )
  719. func main() {
  720. // Make sure to add the error checks
  721. // Update the url to point to your server
  722. URL := "http://127.0.0.1:5000"
  723. ctx := context.Background()
  724. client, err := core.NewToolboxClient(URL)
  725. // Framework agnostic tool
  726. tool, err := client.LoadTool("toolName", ctx)
  727. // Fetch the tool's input schema
  728. inputschema, err := tool.InputSchema()
  729. var schema *genai.Schema
  730. _ = json.Unmarshal(inputschema, &schema)
  731. funcDeclaration := &genai.FunctionDeclaration{
  732. Name: tool.Name(),
  733. Description: tool.Description(),
  734. Parameters: schema,
  735. }
  736. // Use this tool with Go GenAI
  737. genAITool := &genai.Tool{
  738. FunctionDeclarations: []*genai.FunctionDeclaration{funcDeclaration},
  739. }
  740. }
  741. ```
  742. </details>
  743. <details>
  744. <summary>OpenAI Go</summary>
  745. 1. Install [Toolbox Go SDK][toolbox-go]:
  746. ```bash
  747. go get github.com/googleapis/mcp-toolbox-sdk-go
  748. ```
  749. 2. Load tools:
  750. ```go
  751. package main
  752. import (
  753. "context"
  754. "encoding/json"
  755. "github.com/googleapis/mcp-toolbox-sdk-go/core"
  756. openai "github.com/openai/openai-go"
  757. )
  758. func main() {
  759. // Make sure to add the error checks
  760. // Update the url to point to your server
  761. URL := "http://127.0.0.1:5000"
  762. ctx := context.Background()
  763. client, err := core.NewToolboxClient(URL)
  764. // Framework agnostic tool
  765. tool, err := client.LoadTool("toolName", ctx)
  766. // Fetch the tool's input schema
  767. inputschema, err := tool.InputSchema()
  768. var paramsSchema openai.FunctionParameters
  769. _ = json.Unmarshal(inputschema, &paramsSchema)
  770. // Use this tool with OpenAI Go
  771. openAITool := openai.ChatCompletionToolParam{
  772. Function: openai.FunctionDefinitionParam{
  773. Name: tool.Name(),
  774. Description: openai.String(tool.Description()),
  775. Parameters: paramsSchema,
  776. },
  777. }
  778. }
  779. ```
  780. </details>
  781. <details open>
  782. <summary>ADK Go</summary>
  783. 1. Install [Toolbox Go SDK][toolbox-go]:
  784. ```bash
  785. go get github.com/googleapis/mcp-toolbox-sdk-go
  786. ```
  787. 1. Load tools:
  788. ```go
  789. package main
  790. import (
  791. "github.com/googleapis/mcp-toolbox-sdk-go/tbadk"
  792. "context"
  793. )
  794. func main() {
  795. // Make sure to add the error checks
  796. // Update the url to point to your server
  797. URL := "http://127.0.0.1:5000"
  798. ctx := context.Background()
  799. client, err := tbadk.NewToolboxClient(URL)
  800. if err != nil {
  801. return fmt.Sprintln("Could not start Toolbox Client", err)
  802. }
  803. // Use this tool with ADK Go
  804. tool, err := client.LoadTool("toolName", ctx)
  805. if err != nil {
  806. return fmt.Sprintln("Could not load Toolbox Tool", err)
  807. }
  808. }
  809. ```
  810. For more detailed instructions on using the Toolbox Go SDK, see the
  811. [project's README][toolbox-core-go-readme].
  812. </details>
  813. </details>
  814. </blockquote>
  815. </details>
  816. ---
  817. ## Additional Features
  818. ### Test tools with the Toolbox UI
  819. To launch Toolbox's interactive UI, use the `--ui` flag. This allows you to test
  820. tools and toolsets with features such as authorized parameters. To learn more,
  821. visit [Toolbox UI](https://mcp-toolbox.dev/documentation/configuration/toolbox-ui/).
  822. ```sh
  823. ./toolbox --ui
  824. ```
  825. ### Telemetry
  826. Toolbox emits traces and metrics via OpenTelemetry. Use `--telemetry-otlp=<endpoint>`
  827. to export to any OTLP-compatible backend like Google Cloud Monitoring, Agnost AI, or
  828. others. See the [telemetry docs](https://mcp-toolbox.dev/documentation/monitoring/export_telemetry/) for details.
  829. ### Generate Agent Skills
  830. The `skills-generate` command allows you to convert a **toolset** into an **Agent Skill** compatible with the [Agent Skill specification](https://agentskills.io/specification). This is useful for distributing tools as portable skill packages.
  831. ```bash
  832. toolbox --config tools.yaml skills-generate \
  833. --name "my-skill" \
  834. --toolset "my_toolset" \
  835. --description "A skill containing multiple tools"
  836. ```
  837. Once generated, you can install the skill into the Gemini CLI:
  838. ```bash
  839. gemini skills install ./skills/my-skill
  840. ```
  841. For more details, see the [Generating Skills guide](https://mcp-toolbox.dev/documentation/configuration/skills/generating/). To serve a skill you already have over MCP, see [Serving Skills over MCP](https://mcp-toolbox.dev/documentation/configuration/skills/serving/).
  842. The repository also ships ready-to-use Agent Skills (e.g. maintainer workflows). See [`skills/`](./skills/README.md) for the catalog and install instructions.
  843. ---
  844. ## Versioning
  845. MCP Toolbox for Databases follows [Semantic Versioning](https://semver.org/).
  846. The Public API includes the Toolbox Server (CLI, configuration manifests, and pre-built toolsets) and the Client SDKs.
  847. - **Major versions** are incremented for breaking changes, such as incompatible CLI or manifest changes.
  848. - **Minor versions** are incremented for new features, including modifications to pre-built toolsets or beta features.
  849. - **Patch versions** are incremented for backward-compatible bug fixes.
  850. For more details, including our [Container Tagging Policy](https://mcp-toolbox.dev/reference/versioning/#container-tagging-policy), see our [Full Versioning Policy](https://mcp-toolbox.dev/reference/versioning/).
  851. ---
  852. ## Contributing
  853. Contributions are welcome. Please, see the [CONTRIBUTING](CONTRIBUTING.md) guide to get started.
  854. For technical details on setting up a environment for developing on Toolbox itself, see the [DEVELOPER](DEVELOPER.md) guide.
  855. Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. See [Contributor Code of Conduct](CODE_OF_CONDUCT.md) for more information.
  856. ---
  857. ## Community
  858. Join our [Discord community](https://discord.gg/GQrFB3Ec3W) to connect with our developers!

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.