MCP Toolbox for Databases

https://googleapis.github.io/genai-toolbox/
Admin
The MCP Toolbox for Databases is a comprehensive set of tools and quickstarts designed for...
Tokens:298,405
Snippets:2,211
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install Langgraph and Langchain-Google-VertexAI

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

Installs additional dependencies required for agent development, specifically 'langgraph' for building stateful, multi-agent applications and 'langchain-google-vertexai' for integrating with Google Vertex AI.

```bash
# TODO(developer): replace with correct package if needed

pip install langgraph langchain-google-vertexai
```

--------------------------------

### Install BigQuery Client Library for Python

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

Installs the necessary Python client library for interacting with Google BigQuery. This is a prerequisite for using BigQuery with the GenAI Toolbox in Python.

```bash
pip install google-cloud-bigquery
```

--------------------------------

### Install Go SDK

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

Installs the MCP Toolbox SDK for Go. This command fetches and installs the necessary SDK package to manage Toolbox interactions.

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

--------------------------------

### Define Toolset in tools.yaml

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

Adds a 'toolsets' section to 'tools.yaml' to group specific tools under a named set, such as 'my-toolset'. This is required for agent examples that load toolsets.

```yaml
# Add this to your tools.yaml if using load_toolset("my-toolset")
# Ensure it's at the same indentation level as 'sources:' and 'tools:'
kind: toolsets
name: my-toolset
tools:
    - search-hotels-by-name
    - search-hotels-by-location
    - book-hotel
    - update-hotel
    - cancel-hotel
```

--------------------------------

### Install Go Dependencies

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

This command ensures that all necessary Go modules and their dependencies are downloaded and managed for the project. It's a standard step before building or running Go applications.

```bash
go mod tidy

```

--------------------------------

### LlamaIndex Agent Workflow with GoogleGenAI for Hotel Assistant

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This example shows how to build a hotel assistant using LlamaIndex's AgentWorkflow. It utilizes GoogleGenAI for the language model and loads tools from a Toolbox server. The workflow processes user messages and prints the responses.

```python
import asyncio
import os

from llama_index.core.agent.workflow import AgentWorkflow

from llama_index.core.workflow import Context

# TODO(developer): replace this with another import if needed

from llama_index.llms.google_genai import GoogleGenAI

# from llama_index.llms.anthropic import Anthropic

from toolbox_llamaindex import ToolboxClient

prompt = """
  You're a helpful hotel assistant. You handle hotel searching, booking and
  cancellations. When the user searches for a hotel, mention it's name, id,
  location and price tier. Always mention hotel ids while performing any
  searches. This is very important for any operations. For any bookings or
  cancellations, please provide the appropriate confirmation. Be sure to
  update checkin or checkout dates if mentioned by the user.
  Don't ask for confirmations from the user.
"""

queries = [
    "Find hotels in Basel with Basel in it's name.",
    "Can you book the Hilton Basel for me?",
    "Oh wait, this is too expensive. Please cancel it and book the Hyatt Regency instead.",
    "My check in dates would be from April 10, 2024 to April 19, 2024.",
]

async def main():
    # TODO(developer): replace this with another model if needed
    llm = GoogleGenAI(
        model="gemini-2.0-flash-001",
        vertexai_config={"location": "us-central1"},
    )
    # llm = GoogleGenAI(
    #     api_key=os.getenv("GOOGLE_API_KEY"),
    #     model="gemini-2.0-flash-001",
    # )
    # llm = Anthropic(
    #   model="claude-3-7-sonnet-latest",
    #   api_key=os.getenv("ANTHROPIC_API_KEY")
    # )

    # Load the tools from the Toolbox server
    client = ToolboxClient("http://127.0.0.1:5000")
    tools = await client.aload_toolset()

    agent = AgentWorkflow.from_tools_or_functions(
        tools,
        llm=llm,
        system_prompt=prompt,
    )
    ctx = Context(agent)
    for query in queries:
        response = await agent.arun(user_msg=query, ctx=ctx)
        print(f"---- {query} ----")
        print(str(response))

asyncio.run(main())

```

--------------------------------

### Run Toolbox Server

Source: https://googleapis.github.io/genai-toolbox/getting-started/mcp_quickstart

Starts the Toolbox server, which will load and serve the tools defined in the specified YAML configuration file. This command requires the Toolbox binary to be executable and the tools.yaml file to be present.

```bash
./toolbox --tools-file "tools.yaml"
```

--------------------------------

### Install Core Toolbox SDK

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs the core SDK package for interacting with the Toolbox. This is a prerequisite for using Toolbox functionalities.

```bash
npm install @toolbox-sdk/core

```

--------------------------------

### Run Toolbox Server with Looker

Source: https://googleapis.github.io/genai-toolbox/samples/looker/looker_mcp_inspector

Starts the Toolbox server using the prebuilt Looker tools. This command assumes that the `toolbox` binary is executable and the Looker environment variables are set.

```shell
./toolbox --prebuilt looker
```

--------------------------------

### Authenticate with Google Cloud SDK

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

Authenticates your local environment with Google Cloud using Application Default Credentials (ADC). This command opens a browser for you to log in and authorize access.

```bash
gcloud auth login --update-adc
```

--------------------------------

### Install Google ADK SDK

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs the Google ADK (Agent Development Kit) SDK. This SDK is used for building and deploying agents on Google Cloud.

```bash
npm install @google/adk

```

--------------------------------

### Basic Server Configuration Example

Source: https://googleapis.github.io/genai-toolbox/reference/cli

Example of starting the toolbox server with a custom port and specifying a tools file for configuration.

```bash
./toolbox --tools-file "tools.yaml" --port 8080
```

--------------------------------

### Install ADK SDK

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs the ADK (Agent Development Kit) SDK package. This SDK is used for developing and managing agents.

```bash
npm install @toolbox-sdk/adk

```

--------------------------------

### Install Google Generative AI SDK

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs the official Google Generative AI SDK. This package provides access to Google's generative AI models.

```bash
npm install @google/genai

```

--------------------------------

### ADK Agent Setup with ToolboxToolset

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This code snippet sets up the necessary components for an ADK (Agent Development Kit) agent. It configures environment variables for Google Cloud project and location, and initializes a ToolboxToolset to load tools from a server.

```python
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
from google.adk.tools.toolbox_toolset import ToolboxToolset
from google.genai import types # For constructing message content

import os
os.environ['GOOGLE_GENAI_USE_VERTEXAI'] = 'True'

# TODO(developer): Replace 'YOUR_PROJECT_ID' with your Google Cloud Project ID

os.environ['GOOGLE_CLOUD_PROJECT'] = 'YOUR_PROJECT_ID'

# TODO(developer): Replace 'us-central1' with your Google Cloud Location (region)

os.environ['GOOGLE_CLOUD_LOCATION'] = 'us-central1'

# --- Load Tools from Toolbox ---

# TODO(developer): Ensure the Toolbox server is running at http://127.0.0.1:5000
toolset = ToolboxToolset(server_url="http://127.0.0.1:5000")

```

--------------------------------

### Install Google Generative AI SDK

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart

Installs the Google Generative AI SDK for Python. This package is necessary for interacting with Google's generative AI models.

```bash
pip install google-genai
```

--------------------------------

### Run Go Agent Application

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

This command executes the Go agent application, typically named 'hotelagent.go'. It starts the application and allows you to observe its behavior and output, such as responses from the LLM agent.

```bash
go run hotelagent.go

```

--------------------------------

### Install Langchain Dependencies

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart

Installs necessary Langchain packages, including 'langgraph' and 'langchain-google-vertexai', for agent development. This setup is for integrating with Google Vertex AI.

```python
# TODO(developer): replace with correct package if needed

pip install langgraph langchain-google-vertexai

# pip install langchain-google-genai

# pip install langchain-anthropic
```

--------------------------------

### Initialize GenAI Agent and Run Queries in Go

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

This snippet demonstrates the complete workflow of setting up an LLM agent using the GenAI Toolbox SDK. It includes loading tools, configuring the Gemini model, creating the agent, setting up a session service, and running queries against the agent in SSE streaming mode. Dependencies include the MCP Toolbox SDK and the genai package.

```go
// Load the tools using the MCP Toolbox SDK.
toolsetName := "my-toolset"
mcpTools, err := toolboxClient.LoadToolset(toolsetName, ctx)
if err != nil {
	log.Fatalf("Failed to load MCP toolset '%s': %v\nMake sure your Toolbox server is running.", toolsetName, err)
}

// Set up the Gemini Model
model, err := gemini.NewModel(ctx, "gemini-2.5-flash", &genai.ClientConfig{
	APIKey: genaiKey,
})
if err != nil {
	log.Fatalf("Failed to create model: %v", err)
}

// Type Cast the ToolboxTools
tools := make([]tool.Tool, len(mcpTools))
for i := range mcpTools {
	tools[i] = &mcpTools[i]
}

// Create an llm agent
llmagent, err := llmagent.New(llmagent.Config{
	Name:        "hotel_assistant",
	Model:       model,
	Description: "Agent to answer questions about hotels.",
	Instruction: systemPrompt,
	Tools:       tools,
})
if err != nil {
	log.Fatalf("Failed to create agent: %v", err)
}

appName := "hotel_assistant"
userID := "user-123"

// Create a session service
sessionService := session.InMemoryService()
resp, err := sessionService.Create(ctx, &session.CreateRequest{
	AppName: appName,
	UserID:  userID,
})
if err != nil {
	log.Fatalf("Failed to create the session service: %v", err)
}
session := resp.Session

// Configure the runner
r, err := runner.New(runner.Config{
	AppName:        appName,
	Agent:          llmagent,
	SessionService: sessionService,
})
if err != nil {
	log.Fatalf("Failed to create runner: %v", err)
}

// Loop through queries to the llm agent
for i, query := range queriesAdk {
	fmt.Printf("\n=== Query %d: %s ===\n", i+1, query)
	userMsg := genai.NewContentFromText(query, genai.RoleUser)

	streamingMode := agent.StreamingModeSSE
	for event, err := range r.Run(ctx, userID, session.ID(), userMsg, agent.RunConfig{
		StreamingMode: streamingMode,
	}) {
		if err != nil {
			fmt.Printf("\nAGENT_ERROR: %v\n", err)
		} else {
			if event.LLMResponse.Content != nil {
				for _, p := range event.LLMResponse.Content.Parts {
					// if its running in streaming mode, don't print the non partial llmResponses
					if streamingMode != agent.StreamingModeSSE || event.LLMResponse.Partial {
						fmt.Print(p.Text)
					}
				}
			}
		}
	}

	fmt.Println("\n" + strings.Repeat("-", 80) + "\n")
}

```

--------------------------------

### Install ADK and Toolbox Core Libraries

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/ai-nl

This pip command installs the necessary Python libraries, 'toolbox-core' and 'google-adk', required for interacting with the Toolbox server and AlloyDB using the ADK.

```shell
! pip install toolbox-core --quiet
! pip install google-adk --quiet
```

--------------------------------

### Semantic Search for Product Recommendations (PostgreSQL)

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/mcp_quickstart

This tool utilizes vector embeddings in PostgreSQL to find products most relevant to a user's query based on meaning, not just keywords. It requires the `alloydb_pg_source` and takes a user query string as input, returning top product recommendations.

```yaml
kind: tools
name: search-product-recommendations
type: postgres-sql
source: alloydb-pg-source
description: >-
  Search for products based on user needs.
  Use this tool to search for products. This tool requires the user's needs.
parameters:
  - name: query
    type: string
    description: The product characteristics
statement: |
  SELECT
    product_id,
    name,
    description,
    ROUND(CAST(price AS numeric), 2) as price
  FROM
    products
  ORDER BY
    embedding('gemini-embedding-001', $1)::vector <=> embedding
  LIMIT 5;
```

--------------------------------

### Initialize and Run Chatbot with OpenAI Tools (Go)

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

Sets up an OpenAI client, initializes the Toolbox client, loads custom tools, and then processes a series of user queries. It manages the conversation flow by appending messages, making chat completion requests, handling tool calls, and updating the message history.

```go
func main() {
	// Setup
	ctx := context.Background()
	toolboxURL := "http://localhost:5000"
	openAIClient := openai.NewClient()

	// Initialize the MCP Toolbox client.
	toolboxClient, err := core.NewToolboxClient(toolboxURL)
	if err != nil {
		log.Fatalf("Failed to create Toolbox client: %v", err)
	}

	// Load the tools using the MCP Toolbox SDK.

tools, err := toolboxClient.LoadToolset("my-toolset", ctx)
	if err != nil {
		log.Fatalf("Failed to load tool : %v\nMake sure your Toolbox server is running and the tool is configured.", err)
	}

	openAITools := make([]openai.ChatCompletionToolUnionParam, len(tools))

toolsMap := make(map[string]*core.ToolboxTool, len(tools))

	for i, tool := range tools {
		// Convert the Toolbox tool into the openAI FunctionDeclaration format.
	openAITools[i] = ConvertToOpenAITool(tool)
		// Add tool to a map for lookup later
	toolsMap[tool.Name()] = tool

	}

	params := openai.ChatCompletionNewParams{
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.SystemMessage(systemPrompt),
		},
		Tools: openAITools,
		Seed:  openai.Int(0),
		Model: openai.ChatModelGPT4o,
	}

	for _, query := range queries {

		params.Messages = append(params.Messages, openai.UserMessage(query))

		// Make initial chat completion request
		completion, err := openAIClient.Chat.Completions.New(ctx, params)
		if err != nil {
			panic(err)
		}

		toolCalls := completion.Choices[0].Message.ToolCalls

		// Return early if there are no tool calls
		if len(toolCalls) == 0 {
			log.Println("No function call")
		}

		// If there was a function call, continue the conversation
		params.Messages = append(params.Messages, completion.Choices[0].Message.ToParam())
		for _, toolCall := range toolCalls {

			toolName := toolCall.Function.Name
			toolToInvoke := toolsMap[toolName]

			var args map[string]any
			err := json.Unmarshal([]byte(toolCall.Function.Arguments), &args)
			if err != nil {
				panic(err)
			}

			result, err := toolToInvoke.Invoke(ctx, args)
			if err != nil {
				log.Fatal("Could not invoke tool", err)
			}

			params.Messages = append(params.Messages, openai.ToolMessage(result.(string), toolCall.ID))
		}

		completion, err = openAIClient.Chat.Completions.New(ctx, params)
		if err != nil {
			panic(err)
		}

		params.Messages = append(params.Messages, openai.AssistantMessage(query))

		fmt.Println("\n", completion.Choices[0].Message.Content)

	}

}
```

--------------------------------

### Install AlloyDB and SQLAlchemy Dependencies

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/ai-nl

Installs necessary Python packages for connecting to AlloyDB and interacting with databases using SQLAlchemy. This includes the AlloyDB connector, SQLAlchemy, Vertex AI, asyncio, and greenlet.

```python
%pip install \
  google-cloud-alloydb-connector[asyncpg]==1.4.0 \
  sqlalchemy==2.0.36 \
  vertexai==1.70.0 \
  asyncio==3.4.3 \
  greenlet==3.1.1 \
  --quiet
```

--------------------------------

### Insert Sample Data into AlloyDB Tables

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/mcp_quickstart

Populates the previously created 'categories', 'products', 'customers', 'cart', and 'cart_items' tables with sample data. This includes product details with embeddings, customer information, and initial cart contents for testing purposes.

```sql
INSERT INTO categories (category_id, name) VALUES
(1, 'Flowers'),
(2, 'Vases');

INSERT INTO products (product_id, name, description, price, category_id, embedding) VALUES
(1, 'Rose', 'A beautiful red rose', 2.50, 1, embedding('gemini-embedding-001', 'A beautiful red rose')),
(2, 'Tulip', 'A colorful tulip', 1.50, 1, embedding('gemini-embedding-001', 'A colorful tulip')),
(3, 'Glass Vase', 'A transparent glass vase', 10.00, 2, embedding('gemini-embedding-001', 'A transparent glass vase')),
(4, 'Ceramic Vase', 'A handmade ceramic vase', 15.00, 2, embedding('gemini-embedding-001', 'A handmade ceramic vase'));

INSERT INTO customers (customer_id, name, email) VALUES
(1, 'John Doe', 'john.doe@example.com'),
(2, 'Jane Smith', 'jane.smith@example.com');

INSERT INTO cart (cart_id, customer_id) VALUES
(1, 1),
(2, 2);

INSERT INTO cart_items (cart_id, product_id, quantity, price) VALUES
(1, 1, 2, 2.50),
(1, 3, 1, 10.00),
(2, 2, 5, 1.50);
```

--------------------------------

### Initialize Connection Pool and Run Setup - Python

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/ai-nl

This Python code snippet demonstrates how to initialize an asynchronous connection pool using `init_connection_pool` and then calls the `run_setup` function to execute the necessary database setup queries. This is the entry point for setting up the database environment.

```python
pool = await init_connection_pool(connector, database_name)
await run_setup(pool)
```

--------------------------------

### Initialize GenAI and Toolbox Clients in Go

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

This Go code snippet demonstrates the initialization of both the Google GenAI client and the MCP Toolbox client. It requires an API key for GenAI and a URL for the Toolbox server. Error handling is included for client creation and tool loading.

```go
package main

import (
	"context"
	"log"
	"os"

	"github.com/googleapis/genai-go/genai"
	"github.com/googleapis/mcp-toolbox-sdk-go/core"
)

func main() {
	// Setup
	ctx := context.Background()
	apiKey := os.Getenv("GOOGLE_API_KEY")
	toolboxURL := "http://localhost:5000"

	// Initialize the Google GenAI client using the explicit ClientConfig.
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		APIKey: apiKey,
	})
	if err != nil {
		log.Fatalf("Failed to create Google GenAI client: %v", err)
	}

	// Initialize the MCP Toolbox client.
	toolboxClient, err := core.NewToolboxClient(toolboxURL)
	if err != nil {
		log.Fatalf("Failed to create Toolbox client: %v", err)
	}

	// Load the tool using the MCP Toolbox SDK.
	tools, err := toolboxClient.LoadToolset("my-toolset", ctx)
	if err != nil {
		log.Fatalf("Failed to load tools: %v\nMake sure your Toolbox server is running and the tool is configured.", err)
	}

	// ... rest of the code
}
```

--------------------------------

### Run MCP Inspector

Source: https://googleapis.github.io/genai-toolbox/getting-started/mcp_quickstart

Launches the MCP Inspector, a tool for inspecting and interacting with Model Context Protocol (MCP) services. It requires Node.js and npm to be installed. The inspector will provide a session token for authentication.

```bash
npx @modelcontextprotocol/inspector
```

--------------------------------

### Run Gemini-CLI

Source: https://googleapis.github.io/genai-toolbox/samples/looker/looker_gemini

Launches the Gemini-CLI tool from a GitHub repository. It prompts the user to download necessary components and then allows logging in and interacting with configured MCP servers.

```shell
npx https://github.com/google-gemini/gemini-cli
```

--------------------------------

### Run Hotel Agent with User Queries in Python

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This Python code demonstrates how to run the configured hotel agent. It initializes a new session, defines a list of user queries covering hotel search, booking, and cancellation scenarios, and then iterates through these queries. For each query, it sends the content to the agent runner and prints the text responses received from the agent. The script uses asyncio for asynchronous execution.

```python
async def main():
    # Create a new session for the interaction.
    session = await session_service.create_session(
        state={}, app_name='hotel_agent', user_id='123'
    )

    # --- Define Queries and Run the Agent ---
    queries = [
        "Find hotels in Basel with Basel in it's name.",
        "Can you book the Hilton Basel for me?",
        "Oh wait, this is too expensive. Please cancel it and book the Hyatt Regency instead.",
        "My check in dates would be from April 10, 2024 to April 19, 2024.",
    ]

    for query in queries:
        content = types.Content(role='user', parts=[types.Part(text=query)])
        events = runner.run(session_id=session.id,
                            user_id='123', new_message=content)

        responses = (
          part.text
          for event in events
          for part in event.content.parts
          if part.text is not None
        )

        for text in responses:
          print(text)

import asyncio
if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Asynchronous Database Setup - Python

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/ai-nl

This Python function `run_setup` uses the `google-cloud-alloydb-connector` library to establish an asynchronous connection to the database. It iterates through a list of SQL queries and executes them, committing the changes upon completion. This is used to initialize the database schema.

```python
from google.cloud.alloydb.connector import AsyncConnector

# Create table and insert data
async def run_setup(pool):
  async with pool.connect() as db_conn:
    for query in setup_queries:
      await db_conn.execute(sqlalchemy.text(query))
    await db_conn.commit()
```

--------------------------------

### Example Usage of Firestore Get Rules Tool

Source: https://googleapis.github.io/genai-toolbox/resources/tools/firestore/firestore-get-rules

This example demonstrates how to configure and use the firestore-get-rules tool. It specifies the tool type, a source name for Firestore, and a descriptive text for the LLM.

```yaml
kind: tools
name: get_firestore_rules
type: firestore-get-rules
source: my-firestore-source
description: Use this tool to retrieve the active Firestore security rules.

```

--------------------------------

### Configure Toolbox Tools (tools.yaml)

Source: https://googleapis.github.io/genai-toolbox/getting-started/mcp_quickstart

Defines the configuration for Toolbox, including data sources and tools. This example configures a PostgreSQL source and several SQL-based tools for hotel management. Sensitive information like passwords should ideally be managed via environment variables.

```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
---
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 || '%';
---
kind: tools
name: search-hotels-by-location
type: postgres-sql
source: my-pg-source
description: Search for hotels based on location.
parameters:
  - name: location
    type: string
    description: The location of the hotel.
statement: SELECT * FROM hotels WHERE location ILIKE '%' || $1 || '%';
---
kind: tools
name: book-hotel
type: postgres-sql
source: my-pg-source
description: >-
   Book a hotel by its ID. If the hotel is successfully booked, returns a NULL, raises an error if not.
parameters:
  - name: hotel_id
    type: string
    description: The ID of the hotel to book.
statement: UPDATE hotels SET booked = B'1' WHERE id = $1;
---
kind: tools
name: update-hotel
type: postgres-sql
source: my-pg-source
description: >-
  Update a hotel's check-in and check-out dates by its ID. Returns a message
  indicating  whether the hotel was successfully updated or not.
parameters:
  - name: hotel_id
    type: string
    description: The ID of the hotel to update.
  - name: checkin_date
    type: string
    description: The new check-in date of the hotel.
  - name: checkout_date
    type: string
    description: The new check-out date of the hotel.
statement: >-
  UPDATE hotels SET checkin_date = CAST($2 as date), checkout_date = CAST($3
  as date) WHERE id = $1;
---
kind: tools
name: cancel-hotel
type: postgres-sql
source: my-pg-source
description: Cancel a hotel by its ID.
parameters:
  - name: hotel_id
    type: string
    description: The ID of the hotel to cancel.
statement: UPDATE hotels SET booked = B'0' WHERE id = $1;
---
kind: toolsets
name: my-toolset
tools:
  - search-hotels-by-name
  - search-hotels-by-location
  - book-hotel
  - update-hotel
  - cancel-hotel
```

--------------------------------

### Define and Configure Hotel Agent with Python

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This Python code defines the prompt for a hotel assistant agent, configures the agent with a specific model and description, and initializes session and artifact services. It then sets up a runner to manage agent interactions. The agent is designed to handle hotel searching, booking, and cancellations, with specific instructions on mentioning hotel IDs and updating dates.

```python
prompt = """
  You're a helpful hotel assistant. You handle hotel searching, booking and
  cancellations. When the user searches for a hotel, mention it's name, id,
  location and price tier. Always mention hotel ids while performing any
  searches. This is very important for any operations. For any bookings or
  cancellations, please provide the appropriate confirmation. Be sure to
  update checkin or checkout dates if mentioned by the user.
  Don't ask for confirmations from the user.
"""

# --- Configure the Agent ---

root_agent = Agent(
    model='gemini-2.0-flash-001',
    name='hotel_agent',
    description='A helpful AI assistant that can search and book hotels.',
    instruction=prompt,
    tools=[toolset], # Pass the loaded toolset
)

# --- Initialize Services for Running the Agent ---
session_service = InMemorySessionService()
artifacts_service = InMemoryArtifactService()

runner = Runner(
    app_name='hotel_agent',
    agent=root_agent,
    artifact_service=artifacts_service,
    session_service=session_service,
)
```

--------------------------------

### Get Serverless Spark Batch Example

Source: https://googleapis.github.io/genai-toolbox/resources/tools/serverless-spark/serverless-spark-get-batch

This example demonstrates how to configure and use the serverless-spark-get-batch tool to retrieve a specific batch job. It specifies the tool type, source, and a descriptive text for the LLM.

```yaml
kind: tools
name: get_my_batch
type: serverless-spark-get-batch
source: my-serverless-spark-source
description: Use this tool to get a serverless spark batch.

```

--------------------------------

### Configure BigQuery Tools in tools.yaml

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

Defines BigQuery data sources and SQL-based tools for hotel operations. Replace 'YOUR_PROJECT_ID' and 'YOUR_DATASET_NAME' with your actual BigQuery project and dataset. Authentication is handled via Application Default Credentials (ADC).

```yaml
kind: sources
name: my-bigquery-source
type: bigquery
project: YOUR_PROJECT_ID
location: us
---
kind: tools
name: search-hotels-by-name
type: bigquery-sql
source: my-bigquery-source
description: Search for hotels based on name.
parameters:
    - name: name
      type: string
      description: The name of the hotel.
statement: SELECT * FROM `YOUR_DATASET_NAME.hotels` WHERE LOWER(name) LIKE LOWER(CONCAT('%', @name, '%'));
---
kind: tools
name: search-hotels-by-location
type: bigquery-sql
source: my-bigquery-source
description: Search for hotels based on location.
parameters:
    - name: location
      type: string
      description: The location of the hotel.
statement: SELECT * FROM `YOUR_DATASET_NAME.hotels` WHERE LOWER(location) LIKE LOWER(CONCAT('%', @location, '%'));
---
kind: tools
name: book-hotel
type: bigquery-sql
source: my-bigquery-source
description: >-
    Book a hotel by its ID. If the hotel is successfully booked, returns a NULL, raises an error if not.
parameters:
    - name: hotel_id
      type: integer
      description: The ID of the hotel to book.
statement: UPDATE `YOUR_DATASET_NAME.hotels` SET booked = TRUE WHERE id = @hotel_id;
---
kind: tools
name: update-hotel
type: bigquery-sql
source: my-bigquery-source
description: >-
    Update a hotel's check-in and check-out dates by its ID. Returns a message indicating whether the hotel was successfully updated or not.
parameters:
    - name: checkin_date
      type: string
      description: The new check-in date of the hotel.
    - name: checkout_date
      type: string
      description: The new check-out date of the hotel.
    - name: hotel_id
      type: integer
      description: The ID of the hotel to update.
statement: >-
    UPDATE `YOUR_DATASET_NAME.hotels` SET checkin_date = PARSE_DATE('%Y-%m-%d', @checkin_date), checkout_date = PARSE_DATE('%Y-%m-%d', @checkout_date) WHERE id = @hotel_id;
---
kind: tools
name: cancel-hotel
type: bigquery-sql
source: my-bigquery-source
description: Cancel a hotel by its ID.
parameters:
    - name: hotel_id
      type: integer
      description: The ID of the hotel to cancel.
statement: UPDATE `YOUR_DATASET_NAME.hotels` SET booked = FALSE WHERE id = @hotel_id;
```

--------------------------------

### Initialize and Run Chatbot with Gemini Tools (Go)

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_go

Sets up a Gemini client and the MCP Toolbox client, then processes a series of user queries using the ADK (Agent Development Kit). It defines a system prompt for a hotel assistant and iterates through predefined queries, simulating a conversation with tool interactions.

```go
package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/googleapis/mcp-toolbox-sdk-go/tbadk"
	"google.golang.org/adk/agent"
	"google.golang.org/adk/agent/llmagent"
	"google.golang.org/adk/model/gemini"
	"google.golang.org/adk/runner"
	"google.golang.org/adk/session"
	"google.golang.org/adk/tool"
	"google.golang.org/genai"
)

const systemPrompt = `
You're a helpful hotel assistant. You handle hotel searching, booking, and
cancellations. When the user searches for a hotel, mention its name, id,
location and price tier. Always mention hotel ids while performing any
searches. This is very important for any operations. For any bookings or
cancellations, please provide the appropriate confirmation. Be sure to
update checkin or checkout dates if mentioned by the user.
Don't ask for confirmations from the user.
`

var queriesAdk = []string{
	"Find hotels in Basel. ",
	"Find hotels with Basel in its name.",
	"Can you book the hotel Hilton Basel for me?",
	"Oh wait, this is too expensive. Please cancel it.",
	"Please book the Hyatt Regency instead.",
	"My check in dates would be from April 10, 2024 to April 19, 2024.",
}

func main() {
	genaiKey := os.Getenv("GEMINI_API_KEY")
	toolboxURL := "http://localhost:5000"
	ctx := context.Background()

	// Initialize the MCP Toolbox client.
	toolboxClient, err := tbadk.NewToolboxClient(toolboxURL)
	if err != nil {
		log.Fatalf("Failed to create MCP Toolbox client: %v", err)
	}

	// ... rest of the ADK initialization and execution ...
}
```

--------------------------------

### Download GenAI Toolbox Binary

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/mcp_quickstart

Downloads the latest version of the GenAI Toolbox binary using `curl`. Users need to specify the operating system and CPU architecture (e.g., 'linux/amd64') and the desired version.

```bash
export OS="linux/amd64" # one of linux/amd64, darwin/arm64, darwin/amd64, or windows/amd64
export VERSION="0.27.0"
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/$OS/toolbox
```

--------------------------------

### Install GenkitJS Dependencies

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs GenkitJS and its Google AI plugin. GenkitJS is a framework for building AI-powered applications.

```bash
npm install genkit @genkit-ai/googleai

```

--------------------------------

### Langchain Agent with VertexAI for Hotel Assistant

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This snippet demonstrates creating a ReAct agent using Langchain and VertexAI for a hotel assistant. It loads tools from a Toolbox server and processes user queries sequentially. The agent uses a MemorySaver for checkpointers.

```python
from langchain_google_genai import ChatVertexAI

from langgraph.checkpoint.memory import MemorySaver

from toolbox_langchain import ToolboxClient

prompt = """
  You're a helpful hotel assistant. You handle hotel searching, booking and
  cancellations. When the user searches for a hotel, mention it's name, id,
  location and price tier. Always mention hotel ids while performing any
  searches. This is very important for any operations. For any bookings or
  cancellations, please provide the appropriate confirmation. Be sure to
  update checkin or checkout dates if mentioned by the user.
  Don't ask for confirmations from the user.
"""

queries = [
    "Find hotels in Basel with Basel in its name.",
    "Can you book the Hilton Basel for me?",
    "Oh wait, this is too expensive. Please cancel it and book the Hyatt Regency instead.",
    "My check in dates would be from April 10, 2024 to April 19, 2024.",
]

async def main():
    # TODO(developer): replace this with another model if needed
    model = ChatVertexAI(model_name="gemini-2.0-flash-001")
    # model = ChatGoogleGenerativeAI(model="gemini-2.0-flash-001")
    # model = ChatAnthropic(model="claude-3-5-sonnet-20240620")

    # Load the tools from the Toolbox server
    client = ToolboxClient("http://127.0.0.1:5000")
    tools = await client.aload_toolset()

    agent = create_react_agent(model, tools, checkpointer=MemorySaver())

    config = {"configurable": {"thread_id": "thread-1"}}
    for query in queries:
        inputs = {"messages": [("user", prompt + query)]}
        response = await agent.ainvoke(inputs, stream_mode="values", config=config)
        print(response["messages"][-1].content)

asyncio.run(main())

```

--------------------------------

### Install LlamaIndex Dependencies

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs LlamaIndex and its Google AI and workflow integrations. LlamaIndex is a data framework for LLM applications.

```bash
npm install llamaindex @llamaindex/google @llamaindex/workflow

```

--------------------------------

### Natural Language to SQL (NL2SQL) for Product Queries (AlloyDB)

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/mcp_quickstart

This tool translates natural language questions about products or brands into SQL queries for an AlloyDB cluster. It requires the `alloydb_ai_nl` extension and a pre-configured semantic layer named `flower_shop`. The tool is configured using `alloydb-ai-nl` type and `alloydb_pg_source`.

```yaml
kind: tools
name: ask-questions-about-products
type: alloydb-ai-nl
source: alloydb-pg-source
nlConfig: flower_shop
description: >-
  Ask questions related to products or brands.
  Use this tool to ask questions about products or brands.
  Always SELECT the IDs of objects when generating queries.
```

--------------------------------

### Create ReAct Agent with LangChain and Vertex AI (Python)

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This snippet shows how to set up a ReAct agent using LangChain's prebuilt create_react_agent function and ChatVertexAI for interacting with Vertex AI models. It serves as a foundation for building more complex agentic workflows.

```python
import asyncio
from langgraph.prebuilt import create_react_agent

# TODO(developer): replace this with another import if needed

from langchain_google_vertexai import ChatVertexAI

```

--------------------------------

### Install LlamaIndex LLM Anthropic

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart

Installs the LlamaIndex Anthropic LLM integration package. This is a prerequisite for using Anthropic models with LlamaIndex.

```bash
pip install llama-index-llms-anthropic
```

--------------------------------

### Install LangChain Dependencies

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart_js

Installs LangChain and its Google Generative AI integration. LangChain is a framework for developing applications powered by language models.

```bash
npm install langchain @langchain/google-genai

```

--------------------------------

### Install Core SDK for Toolbox

Source: https://googleapis.github.io/genai-toolbox/getting-started/local_quickstart

Installs the core SDK package for Toolbox integration using pip. This is a foundational package for Toolbox functionalities.

```python
pip install toolbox-core
```

--------------------------------

### Start Toolbox Server

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/ai-nl

This shell command starts the Toolbox server in the background using a specified tools file and port. It configures the server to log debug information in JSON format and redirects output to a log file.

```shell
TOOLS_FILE_PATH = f"/content/{tools_file_name}"

# Start a toolbox server
! nohup {TOOLBOX_BINARY_PATH} --tools-file {TOOLS_FILE_PATH}  --log-level debug --logging-format json -p {SERVER_PORT} > toolbox.log 2>&1 &
```

--------------------------------

### Structured Queries for Shopping Cart Management (PostgreSQL)

Source: https://googleapis.github.io/genai-toolbox/samples/alloydb/mcp_quickstart

These tools execute predefined PostgreSQL SQL statements for managing shopping cart information. They are ideal for common, structured queries like accessing cart details, adding items, and removing items. These tools require a `tools.yaml` configuration.

```yaml
kind: tools
name: access-cart-information
type: postgres-sql
source: alloydb-pg-source
description: >-
  List items in customer cart.
  Use this tool to list items in a customer cart. This tool requires the cart ID.
parameters:
  - name: cart_id
    type: integer
    description: The id of the cart.
statement: |
  SELECT
    p.name AS product_name,
    ci.quantity,
    ci.price AS item_price,
    (ci.quantity * ci.price) AS total_item_price,
    c.created_at AS cart_created_at,
    ci.product_id AS product_id
  FROM
    cart_items ci JOIN cart c ON ci.cart_id = c.cart_id
    JOIN products p ON ci.product_id = p.product_id
  WHERE
    c.cart_id = $1;
---
kind: tools
name: add-to-cart
type: postgres-sql
source: alloydb-pg-source
description: >-
  Add items to customer cart using the product ID and product prices from the product list.
  Use this tool to add items to a customer cart.
  This tool requires the cart ID, product ID, quantity, and price.
parameters:
  - name: cart_id
    type: integer
    description: The id of the cart.
  - name: product_id
    type: integer
    description: The id of the product.
  - name: quantity
    type: integer
    description: The quantity of items to add.
  - name: price
    type: float
    description: The price of items to add.
statement: |
  INSERT INTO
    cart_items (cart_id, product_id, quantity, price)
  VALUES($1,$2,$3,$4);
---
kind: tools
name: delete-from-cart
type: postgres-sql
source: alloydb-pg-source
description: >-
  Remove products from customer cart.
  Use this tool to remove products from a customer cart.
  This tool requires the cart ID and product ID.
parameters:
  - name: cart_id
    type: integer
    description: The id of the cart.
  - name: product_id
    type: integer
    description: The id of the product.
statement: |
  DELETE FROM
    cart_items
  WHERE
    cart_id = $1 AND product_id = $2;
```

--------------------------------

### Create Hotel Agent with GenAI and Toolbox Client (Python)

Source: https://googleapis.github.io/genai-toolbox/samples/bigquery/local_quickstart

This snippet demonstrates how to create a hotel agent using Google's genai client and the toolbox_core library. It sets up tools for hotel searching, booking, and cancellations, and processes user queries through a loop, handling function calls and tool responses.

```python
import asyncio

from google import genai
from google.genai.types import (
    Content,
    FunctionDeclaration,
    GenerateContentConfig,
    Part,
    Tool,
)

from toolbox_core import ToolboxClient

prompt = """
  You're a helpful hotel assistant. You handle hotel searching, booking and
  cancellations. When the user searches for a hotel, mention it's name, id, 
  location and price tier. Always mention hotel id while performing any
  searches. This is very important for any operations. For any bookings or
  cancellations, please provide the appropriate confirmation. Be sure to
  update checkin or checkout dates if mentioned by the user.
  Don't ask for confirmations from the user.
"""

queries = [
    "Find hotels in Basel with Basel in it's name.",
    "Please book the hotel Hilton Basel for me.",
    "This is too expensive. Please cancel it.",
    "Please book Hyatt Regency for me",
    "My check in dates for my booking would be from April 10, 2024 to April 19, 2024.",
]

async def run_application():
    async with ToolboxClient("<http://127.0.0.1:5000>") as toolbox_client:

        # The toolbox_tools list contains Python callables (functions/methods) designed for LLM tool-use
        # integration. While this example uses Google's genai client, these callables can be adapted for
        # various function-calling or agent frameworks. For easier integration with supported frameworks
        # (https://github.com/googleapis/mcp-toolbox-python-sdk/tree/main/packages), use the
        # provided wrapper packages, which handle framework-specific boilerplate.
        toolbox_tools = await toolbox_client.load_toolset("my-toolset")
        genai_client = genai.Client(
            vertexai=True, project="project-id", location="us-central1"
        )

        genai_tools = [
            Tool(
                function_declarations=[
                    FunctionDeclaration.from_callable_with_api_option(callable=tool)
                ]
            )
            for tool in toolbox_tools
        ]
        history = []
        for query in queries:
            user_prompt_content = Content(
                role="user",
                parts=[Part.from_text(text=query)],
            )
            history.append(user_prompt_content)

            response = genai_client.models.generate_content(
                model="gemini-2.0-flash-001",
                contents=history,
                config=GenerateContentConfig(
                    system_instruction=prompt,
                    tools=genai_tools,
                ),
            )
            history.append(response.candidates[0].content)
            function_response_parts = []
            for function_call in response.function_calls:
                fn_name = function_call.name
                # The tools are sorted alphabetically
                if fn_name == "search-hotels-by-name":
                    function_result = await toolbox_tools[3](**function_call.args)
                elif fn_name == "search-hotels-by-location":
                    function_result = await toolbox_tools[2](**function_call.args)
                elif fn_name == "book-hotel":
                    function_result = await toolbox_tools[0](**function_call.args)
                elif fn_name == "update-hotel":
                    function_result = await toolbox_tools[4](**function_call.args)
                elif fn_name == "cancel-hotel":
                    function_result = await toolbox_tools[1](**function_call.args)
                else:
                    raise ValueError("Function name not present.")
                function_response = {"result": function_result}
                function_response_part = Part.from_function_response(
                    name=function_call.name,
                    response=function_response,
                )
                function_response_parts.append(function_response_part)

            if function_response_parts:
                tool_response_content = Content(role="tool", parts=function_response_parts)
                history.append(tool_response_content)

            response2 = genai_client.models.generate_content(
                model="gemini-2.0-flash-001",
                contents=history,
                config=GenerateContentConfig(
                    tools=genai_tools,
                ),
            )
            final_model_response_content = response2.candidates[0].content
            history.append(final_model_response_content)
            print(response2.text)

asyncio.run(run_application())

```
Tokens:
Raw