diff --git a/temp 1.md b/temp 1.md
new file mode 100644
index 00000000000..e663f9c822b
--- /dev/null
+++ b/temp 1.md
@@ -0,0 +1,1061 @@
+
+
+# MCP Toolbox for Databases
+
+
+
+[](https://googleapis.github.io/genai-toolbox/)
+[](https://discord.gg/Dmm69peqjh)
+[](https://medium.com/@mcp_toolbox)
+[](https://goreportcard.com/report/github.com/googleapis/genai-toolbox)
+
+> [!NOTE]
+> MCP Toolbox for Databases is currently in beta, and may see breaking
+> changes until the first stable release (v1.0).
+
+MCP Toolbox for Databases is an open source MCP server for databases. It enables
+you to develop tools easier, faster, and more securely by handling the complexities
+such as connection pooling, authentication, and more.
+
+This README provides a brief overview. For comprehensive details, see the [full
+documentation](https://googleapis.gi thub.io/genai-toolbox/).
+
+> [!NOTE]
+> This solution was originally named “Gen AI Toolbox for Databases” as
+> its initial development predated MCP, but was renamed to align with recently
+> added MCP compatibility.
+
+
+## Table of Contents
+
+
+
+- [Why Toolbox?](#why-toolbox)
+- [General Architecture](#general-architecture)
+- [Getting Started](#getting-started)
+ - [Installing the server](#installing-the-server)
+ - [Running the server](#running-the-server)
+ - [Integrating your application](#integr ating-your-application)
+ - [Using Toolbox with Gemini CLI Extensions](#using-toolbox-with-gemini-cli-extensions)
+- [Configuration](#configuration)
+ - [Sources](#sources)
+ - [Tools](#tools)
+ - [Toolsets](#toolsets)
+ - [Prompts](#prompts)
+- [Versioning](#versioning)
+ - [Pre-1.0.0 Versioning](#pre-100-versioning)
+ - [Post-1.0.0 Versioning](#post-100-versioning)
+- [Contributing](#contributing)
+- [Community](#community)
+
+
+
+## Why Toolbox?
+
+Toolbox helps you build Gen AI tools that let your agents access data in your
+database. Toolbox provides:
+
+- **Simplified development**: Integrate tools to your agent in less than 10
+ lines of code, reuse tools between multiple agents or frameworks, and deploy
+ new versions of tools more easily.
+- **Better performance**: Best practices such as connection pooling,
+ authentication, and more.
+- **Enhanced security**: Integrated auth for more secure access to your data
+- **End-to-end observability**: Out of the box metrics and tracing with built-in
+ support for OpenTelemetry.
+
+**⚡ Supercharge Your Workflow with an AI Database Assistant ⚡**
+
+Stop context-switching and let your AI assistant become a true co-developer. By
+[connecting your IDE to your databases with MCP Toolbox][connect-ide], you can
+delegate complex and time-consuming database tasks, allowing you to build faster
+and focus on what matters. This isn't just about code completion; it's about
+giving your AI the context it needs to handle the entire development lifecycle.
+
+Here’s how it will save you time:
+
+- **Query in Plain English**: Interact with your data using natural language
+ right from your IDE. Ask complex questions like, *"How many orders were
+ delivered in 2024, and what items were in them?"* without writing any SQL.
+- **Automate Database Management**: Simply describe your data needs, and let the
+ AI assistant manage your database for you. It can handle generating queries,
+ creating tables, adding indexes, and more.
+- **Generate Context-Aware Code**: Empower your AI assistant to generate
+ application code and tests with a deep understanding of your real-time
+ database schema. This accelerates the development cycle by ensuring the
+ generated code is directly usable.
+- **Slash Development Overhead**: Radically reduce the time spent on manual
+ setup and boilerplate. MCP Toolbox helps streamline lengthy database
+ configurations, repetitive code, and error-prone schema migrations.
+
+Learn [how to connect your AI tools (IDEs) to Toolbox using MCP][connect-ide].
+
+[connect-ide]: https:// googl eapis.github.io/genai-toolbox/how-to/connect-ide/
+
+## General Architecture
+
+Toolbox sits between your application's orchestration framework and your
+database, providing a control plane that is used to modify, distribute, or
+invoke tools. It simplifies the management of your tools by providing you with a
+centralized location to store and update tools, allowing you to share tools
+between agents and applications and update those tools without necessarily
+redeploying your application.
+
+
+
+
+
+## Getting Started
+
+### Quickstart: Running Toolbox using NPX
+
+You can run Toolbox directly with a [configuration file](#configuration):
+
+```sh
+npx @toolbox-sdk/server --tools-file tools.yaml
+```
+
+This runs the latest version of the toolbox server with your configuration file.
+
+> [!NOTE]
+> This method should only be used for non-production use cases such as
+> experimentation. For any production use-cases, please consider [Installing the
+> server](#installing-the-server) and then [running it](#running-the-server).
+
+### Installing the server
+
+For the latest version, check the [releases page][releases] and use the
+following instructions for your OS and CPU architecture.
+
+[releases]: https://github.com/googleapis/genai-toolbox/releases
+
+
+Binary
+
+To install Toolbox as a binary:
+
+
+>
+> Linux (AMD64)
+>
+> To install Toolbox as a binary on Linux (AMD64):
+>
+> ```sh
+> # see releases page for other versions
+> export VERSION=0.27.0
+> curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
+> chmod +x toolbox
+> ```
+>
+>
+>
+> macOS (Apple Silicon)
+>
+> To install Toolbox as a binary on macOS (Apple Silicon):
+>
+> ```sh
+> # see releases page for other versions
+> export VERSION=0.27.0
+> curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/darwin/arm64/toolbox
+> chmod +x toolbox
+> ```
+>
+>
+>
+> macOS (Intel)
+>
+> To install Toolbox as a binary on macOS (Intel):
+>
+> ```sh
+> # see releases page for other versions
+> export VERSION=0.27.0
+> curl -L -o toolbox https://storage.googleapis.com/genai-toolbox/v$VERSION/darwin/amd64/toolbox
+> chmod +x toolbox
+> ```
+>
+>
+>
+> Windows (Command Prompt)
+>
+> To install Toolbox as a binary on Windows (Command Prompt):
+>
+> ```cmd
+> :: see releases page for other versions
+> set VERSION=0.27.0
+> curl -o toolbox.exe "https://storage.googleapis.com/genai-toolbox/v%VERSION%/windows/amd64/toolbox.exe"
+> ```
+>
+>
+>
+> Windows (PowerShell)
+>
+> To install Toolbox as a binary on Windows (PowerShell):
+>
+> ```powershell
+> # see releases page for other versions
+> $VERSION = "0.27.0"
+> curl.exe -o toolbox.exe "https://storage.googleapis.com/genai-toolbox/v$VERSION/windows/amd64/toolbox.exe"
+> ```
+>
+>
+
+
+
+Container image
+You can also install Toolbox as a container:
+
+```sh
+# see releases page for other versions
+export VERSION=0.27.0
+docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION
+```
+
+
+
+
+Homebrew
+
+To install Toolbox using Homebrew on macOS or Linux:
+
+```sh
+brew install mcp-toolbox
+```
+
+
+
+
+Compile from source
+
+To install from source, ensure you have the latest version of
+[Go installed](https://go.dev/doc/install), and then run the following command:
+
+```sh
+go install github.com/googleapis/genai-toolbox@v0.27.0
+```
+
+
+
+
+
+Gemini CLI Extensions
+
+To install Gemini CLI Extensions for MCP Toolbox, run the following command:
+
+```sh
+gemini extensions install https://github.com/gemini-cli-extensions/mcp-toolbox
+```
+
+
+
+### Running the server
+
+[Configure](#configuration) a `tools.yaml` to define your tools, and then
+execute `toolbox` to start the server:
+
+
+Binary
+
+To run Toolbox from binary:
+
+```sh
+./toolbox --tools-file "tools.yaml"
+```
+
+> ⓘ Note
+> Toolbox enables dynamic reloading by default. To disable, use the
+> `--disable-reload` flag.
+
+
+
+
+
+Container image
+
+To run the server after pulling the [container image](#installing-the-server):
+
+```sh
+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 \
+--tools-file "/app/tools.yaml"
+```
+
+> ⓘ Note
+> The `-v` flag mounts your local `tools.yaml` into the container, and `-p` maps
+> the container's port `5000` to your host's port `5000`.
+
+
+
+
+
+Source
+
+To run the server directly from source, navigate to the project root directory
+and run:
+
+```sh
+go run .
+```
+
+> ⓘ Note
+> This command runs the project from source, and is more suitable for development
+> and testing. It does **not** compile a binary into your `$GOPATH`. If you want
+> to compile a binary instead, refer the [Developer
+> Documentation](./DEVELOPER.md#building-the-binary).
+
+
+
+
+
+Homebrew
+
+If you installed Toolbox using [Homebrew](https://brew.sh/), the `toolbox`
+binary is available in your system path. You can start the server with the same
+command:
+
+```sh
+toolbox --tools-file "tools.yaml"
+```
+
+
+
+
+NPM
+
+To run Toolbox directly without manually downloading the binary (requires Node.js):
+```sh
+npx @toolbox-sdk/server --tools-file tools.yaml
+```
+
+
+
+
+
+Gemini CLI
+
+Interact with your custom tools using natural language. Check
+[gemini-cli-extensions/mcp-toolbox](https://github.com/gemini-cli-extensions/mcp-toolbox)
+for more information.
+
+
+
+You can use `toolbox help` for a full list of flags! To stop the server, send a
+terminate signal (`ctrl+c` on most platforms).
+
+For more detailed documentation on deploying to different environments, check
+out the resources in the [How-to
+section](https://googleapis.github.io/genai-toolbox/how-to/)
+
+### Integrating your application
+
+Once your server is up and running, you can load the tools into your
+application. See below the list of Client SDKs for using various frameworks:
+
+
+ Python (Github)
+
+
+
+
+ Core
+
+1. Install [Toolbox Core SDK][toolbox-core]:
+
+ ```bash
+ pip install toolbox-core
+ ```
+
+1. Load tools:
+
+ ```python
+ 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")
+ ```
+
+For more detailed instructions on using the Toolbox Core SDK, see the
+[project's README][toolbox-core-readme].
+
+[toolbox-core]: https://pypi.org/project/toolbox-core/
+[toolbox-core-readme]: https://github.com/googleapis/mcp-toolbox-sdk-python/tree/main/packages/toolbox-core/README.md
+
+
+
+ LangChain / LangGraph
+
+1. Install [Toolbox LangChain SDK][toolbox-langchain]:
+
+ ```bash
+ pip install toolbox-langchain
+ ```
+
+1. Load tools:
+
+ ```python
+ 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()
+ ```
+
+ For more detailed instructions on using the Toolbox LangChain SDK, see the
+ [project's README][toolbox-langchain-readme].
+
+ [toolbox-langchain]: https://pypi.org/project/toolbox-langchain/
+ [toolbox-langchain-readme]: https://github.com/googleapis/mcp-toolbox-sdk-python/blob/main/packages/toolbox-langchain/README.md
+
+
+
+ LlamaIndex
+
+1. Install [Toolbox Llamaindex SDK][toolbox-llamaindex]:
+
+ ```bash
+ pip install toolbox-llamaindex
+ ```
+
+1. Load tools:
+
+ ```python
+ 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()
+ ```
+
+ For more detailed instructions on using the Toolbox Llamaindex SDK, see the
+ [project's README][toolbox-llamaindex-readme].
+
+ [toolbox-llamaindex]: https://pypi.org/project/toolbox-llamaindex/
+ [toolbox-llamaindex-readme]: https://github.com/googleapis/genai-toolbox-llamaindex-python/blob/main/README.md
+
+
+
+
+
+ Javascript/Typescript (Github)
+
+
+
+
+ Core
+
+1. Install [Toolbox Core SDK][toolbox-core-js]:
+
+ ```bash
+ npm install @toolbox-sdk/core
+ ```
+
+1. Load tools:
+
+ ```javascript
+ 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');
+ ```
+
+ For more detailed instructions on using the Toolbox Core SDK, see the
+ [project's README][toolbox-core-js-readme].
+
+ [toolbox-core-js]: https://www.npmjs.com/package/@toolbox-sdk/core
+ [toolbox-core-js-readme]: https://github.com/googleapis/mcp-toolbox-sdk-js/blob/main/packages/toolbox-core/README.md
+
+
+
+ LangChain / LangGraph
+
+1. Install [Toolbox Core SDK][toolbox-core-js]:
+
+ ```bash
+ npm install @toolbox-sdk/core
+ ```
+
+2. Load tools:
+
+ ```javascript
+ 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. Install [Toolbox Core SDK][toolbox-core-js]:
+
+ ```bash
+ npm install @toolbox-sdk/core
+ ```
+
+2. Load tools:
+
+ ```javascript
+ 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. Install [Toolbox ADK SDK][toolbox-adk-js]:
+
+ ```bash
+ npm install @toolbox-sdk/adk
+ ```
+
+2. Load tools:
+
+ ```javascript
+ 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');
+ ```
+
+ For more detailed instructions on using the Toolbox ADK SDK, see the
+ [project's README][toolbox-adk-js-readme].
+
+ [toolbox-adk-js]: https://www.npmjs.com/package/@toolbox-sdk/adk
+ [toolbox-adk-js-readme]:
+ https://github.com/googleapis/mcp-toolbox-sdk-js/blob/main/packages/toolbox-adk/README.md
+
+
+
+
+
+ Go (Github)
+
+
+
+
+ Core
+
+1. Install [Toolbox Go SDK][toolbox-go]:
+
+ ```bash
+ go get github.com/googleapis/mcp-toolbox-sdk-go
+ ```
+
+2. Load tools:
+
+ ```go
+ package main
+
+ import (
+ "github.com/googleapis/mcp-toolbox-sdk-go/core"
+ "context"
+ )
+
+ func main() {
+ // Make sure to add the error checks
+ // update the url to point to your server
+ URL := "http://127.0.0.1:5000";
+ ctx := context.Background()
+
+ client, err := core.NewToolboxClient(URL)
+
+ // Framework agnostic tools
+ tools, err := client.LoadToolset("toolsetName", ctx)
+ }
+ ```
+
+ For more detailed instructions on using the Toolbox Go SDK, see the
+ [project's README][toolbox-core-go-readme].
+
+ [toolbox-go]: https://pkg.go.dev/github.com/googleapis/mcp-toolbox-sdk-go/core
+ [toolbox-core-go-readme]: https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/core/README.md
+
+
+
+ LangChain Go
+
+1. Install [Toolbox Go SDK][toolbox-go]:
+
+ ```bash
+ go get github.com/googleapis/mcp-toolbox-sdk-go
+ ```
+
+2. Load tools:
+
+ ```go
+ package main
+
+ import (
+ "context"
+ "encoding/json"
+
+ "github.com/googleapis/mcp-toolbox-sdk-go/core"
+ "github.com/tmc/langchaingo/llms"
+ )
+
+ func main() {
+ // Make sure to add the error checks
+ // update the url to point to your server
+ URL := "http://127.0.0.1:5000"
+ ctx := context.Background()
+
+ client, err := core.NewToolboxClient(URL)
+
+ // Framework agnostic tool
+ tool, err := client.LoadTool("toolName", ctx)
+
+ // Fetch the tool's input schema
+ inputschema, err := tool.InputSchema()
+
+ var paramsSchema map[string]any
+ _ = json.Unmarshal(inputschema, ¶msSchema)
+
+ // Use this tool with LangChainGo
+ langChainTool := llms.Tool{
+ Type: "function",
+ Function: &llms.FunctionDefinition{
+ Name: tool.Name(),
+ Description: tool.Description(),
+ Parameters: paramsSchema,
+ },
+ }
+ }
+
+ ```
+
+
+
+ Genkit
+
+1. Install [Toolbox Go SDK][toolbox-go]:
+
+ ```bash
+ go get github.com/googleapis/mcp-toolbox-sdk-go
+ ```
+
+2. Load tools:
+
+ ```go
+ 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. Install [Toolbox Go SDK][toolbox-go]:
+
+ ```bash
+ go get github.com/googleapis/mcp-toolbox-sdk-go
+ ```
+
+2. Load tools:
+
+ ```go
+ package main
+
+ import (
+ "context"
+ "encoding/json"
+
+ "github.com/googleapis/mcp-toolbox-sdk-go/core"
+ "google.golang.org/genai"
+ )
+
+ func main() {
+ // Make sure to add the error checks
+ // Update the url to point to your server
+ URL := "http://127.0.0.1:5000"
+ ctx := context.Background()
+
+ client, err := core.NewToolboxClient(URL)
+
+ // Framework agnostic tool
+ tool, err := client.LoadTool("toolName", ctx)
+
+ // Fetch the tool's input schema
+ inputschema, err := tool.InputSchema()
+
+ var schema *genai.Schema
+ _ = json.Unmarshal(inputschema, &schema)
+
+ funcDeclaration := &genai.FunctionDeclaration{
+ Name: tool.Name(),
+ Description: tool.Description(),
+ Parameters: schema,
+ }
+
+ // Use this tool with Go GenAI
+ genAITool := &genai.Tool{
+ FunctionDeclarations: []*genai.FunctionDeclaration{funcDeclaration},
+ }
+ }
+ ```
+
+
+
+ OpenAI Go
+
+1. Install [Toolbox Go SDK][toolbox-go]:
+
+ ```bash
+ go get github.com/googleapis/mcp-toolbox-sdk-go
+ ```
+
+2. Load tools:
+
+ ```go
+ package main
+
+ import (
+ "context"
+ "encoding/json"
+
+ "github.com/googleapis/mcp-toolbox-sdk-go/core"
+ openai "github.com/openai/openai-go"
+ )
+
+ func main() {
+ // Make sure to add the error checks
+ // Update the url to point to your server
+ URL := "http://127.0.0.1:5000"
+ ctx := context.Background()
+
+ client, err := core.NewToolboxClient(URL)
+
+ // Framework agnostic tool
+ tool, err := client.LoadTool("toolName", ctx)
+
+ // Fetch the tool's input schema
+ inputschema, err := tool.InputSchema()
+
+ var paramsSchema openai.FunctionParameters
+ _ = json.Unmarshal(inputschema, ¶msSchema)
+
+ // 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][toolbox-go]:
+
+ ```bash
+ go get github.com/googleapis/mcp-toolbox-sdk-go
+ ```
+
+1. Load tools:
+
+ ```go
+ package main
+
+ import (
+ "github.com/googleapis/mcp-toolbox-sdk-go/tbadk"
+ "context"
+ )
+
+ func main() {
+ // Make sure to add the error checks
+ // Update the url to point to your server
+ URL := "http://127.0.0.1:5000"
+ ctx := context.Background()
+ client, err := tbadk.NewToolboxClient(URL)
+ if err != nil {
+ return fmt.Sprintln("Could not start Toolbox Client", err)
+ }
+
+ // Use this tool with ADK Go
+ tool, err := client.LoadTool("toolName", ctx)
+ if err != nil {
+ return fmt.Sprintln("Could not load Toolbox Tool", err)
+ }
+ }
+ ```
+
+ For more detailed instructions on using the Toolbox Go SDK, see the
+ [project's README][toolbox-core-go-readme].
+
+
+
+
+
+
+
+### Using Toolbox with Gemini CLI Extensions
+
+[Gemini CLI extensions][gemini-cli-extensions] provide tools to interact
+directly with your data sources from command line. Below is a list of Gemini CLI
+extensions that are built on top of **Toolbox**. They allow you to interact with
+your data sources through pre-defined or custom tools with natural language.
+Click into the link to see detailed instructions on their usage.
+
+To use **custom** tools with Gemini CLI:
+
+- [MCP Toolbox](https://github.com/gemini-cli-extensions/mcp-toolbox)
+
+To use [prebuilt tools][prebuilt] with Gemini CLI:
+
+- [AlloyDB for PostgreSQL](https://github.com/gemini-cli-extensions/alloydb)
+- [AlloyDB for PostgreSQL
+ Observability](https://github.com/gemini-cli-extensions/alloydb-observability)
+- [BigQuery Data
+ Analytics](https://github.com/gemini-cli-extensions/bigquery-data-analytics)
+- [BigQuery Conversational
+ Analytics](https://github.com/gemini-cli-extensions/bigquery-conversational-analytics)
+- [Cloud SQL for
+ MySQL](https://github.com/gemini-cli-extensions/cloud-sql-mysql)
+- [Cloud SQL for MySQL
+ Observability](https://github.com/gemini-cli-extensions/cloud-sql-mysql-observability)
+- [Cloud SQL for
+ PostgreSQL](https://github.com/gemini-cli-extensions/cloud-sql-postgresql)
+- [Cloud SQL for PostgreSQL
+ Observability](https://github.com/gemini-cli-extensions/cloud-sql-postgresql-observability)
+- [Cloud SQL for SQL
+ Server](https://github.com/gemini-cli-extensions/cloud-sql-sqlserver)
+- [Cloud SQL for SQL Server
+ Observability](https://github.com/gemini-cli-extensions/cloud-sql-sqlserver-observability)
+- [Looker](https://github.com/gemini-cli-extensions/looker)
+- [Dataplex](https://github.com/gemini-cli-extensions/dataplex)
+- [MySQL](https://github.com/gemini-cli-extensions/mysql)
+- [PostgreSQL](https://github.com/gemini-cli-extensions/postgres)
+- [Spanner](https://github.com/gemini-cli-extensions/spanner)
+- [Firestore](https://github.com/gemini-cli-extensions/firestore-native)
+- [SQL Server](https://github.com/gemini-cli-extensions/sql-server)
+
+[prebuilt]: https://googleapis.github.io/genai-toolbox/reference/prebuilt-tools/
+[gemini-cli-extensions]:
+ https://github.com/google-gemini/gemini-cli/blob/main/docs/extensions/index.md
+
+## Configuration
+
+The primary way to configure Toolbox is through the `tools.yaml` file. If you
+have multiple files, you can tell toolbox which to load with the `--tools-file
+tools.yaml` flag.
+
+You can find more detailed reference documentation to all resource types in the
+[Resources](https://googleapis.github.io/genai-toolbox/resources/).
+
+### Sources
+
+The `sources` section of your `tools.yaml` defines what data sources your
+Toolbox should have access to. Most tools will have at least one source to
+execute against.
+
+```yaml
+kind: sources
+name: my-pg-source
+type: postgres
+host: 127.0.0.1
+port: 5432
+database: toolbox_db
+user: toolbox_user
+password: my-password
+```
+
+For more details on configuring different types of sources, see the
+[Sources](https://googleapis.github.io/genai-toolbox/resources/sources).
+
+### Tools
+
+The `tools` section of a `tools.yaml` define the actions an agent can take: what
+type of tool it is, which source(s) it affects, what parameters it uses, etc.
+
+```yaml
+kind: tools
+name: search-hotels-by-name
+type: postgres-sql
+source: my-pg-source
+description: Search for hotels based on name.
+parameters:
+ - name: name
+ type: string
+ description: The name of the hotel.
+statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';
+```
+
+For more details on configuring different types of tools, see the
+[Tools](https://googleapis.github.io/genai-toolbox/resources/tools).
+
+### Toolsets
+
+The `toolsets` section of your `tools.yaml` allows you to define groups of tools
+that you want to be able to load together. This can be useful for defining
+different groups based on agent or application.
+
+```yaml
+toolsets:
+ my_first_toolset:
+ - my_first_tool
+ - my_second_tool
+ my_second_toolset:
+ - my_second_tool
+ - my_third_tool
+```
+
+You can load toolsets by name:
+
+```python
+# This will load all tools
+all_tools = client.load_toolset()
+
+# This will only load the tools listed in 'my_second_toolset'
+my_second_toolset = client.load_toolset("my_second_toolset")
+```
+
+### Prompts
+
+The `prompts` section of a `tools.yaml` defines prompts that can be used for
+interactions with LLMs.
+
+```yaml
+prompts:
+ code_review:
+ description: "Asks the LLM to analyze code quality and suggest improvements."
+ messages:
+ - content: "Please review the following code for quality, correctness, and potential improvements: \n\n{{.code}}"
+ arguments:
+ - name: "code"
+ description: "The code to review"
+```
+
+For more details on configuring prompts, see the
+[Prompts](https://googleapis.github.io/gnai-toolbox/resources/prompts).
+
+## Versioning
+
+This project uses [semantic versioning](htts://semver.org/) (`MAJOR.MINOR.PATCH`).
+Since the project is in a pre-release stage (version `0.x.y`), we follow the
+standard conventions for initial development:
+
+### Pre-1.0.0 Versioning
+
+While the major version is `0`, the public API should be considered unstable.
+The version will be incremented as follows:
+
+- **`0.MINOR.PATCH`**: The **MINOR** version is incremented when we add
+ new functionality or make breaking, incompatible API changes.
+- **`0.MINOR.PATCH`**: The **PATCH** version is incremented for
+ backward-compatible bug fixes.
+
+### Post-1.0.0 Versioning
+
+Once the project reaches a stable `1.0.0` release, the version number
+**`MAJOR.MINOR.PATCH`** will follow the more common convention:
+
+- **`MAJOR`**: Incremented for incompatible API changes.
+- **`MINOR`**: Incremented for new, backward-compatible functionality.
+- **`PATCH`**: Incremented for backward-compatible bug fixes.
+
+The public API that this applies to is the CLI associated with Toolbox, the
+interactions with official SDKs, and the definitions in the `tools.yaml` file.
+
+## Contributing
+
+Contributions are welcome. Please, see the [CONTRIBUTING](CONTRIBUTING.md)
+to get started.
+
+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_ONDUCT.md) for more information.
+
+## Community
+
+Join our [discord community](https://discord.gg/GQr3Ec3W) to connect with our developers!