mirror of
https://github.com/googleapis/genai-toolbox.git
synced 2026-02-03 03:35:02 -05:00
Compare commits
3 Commits
docs-py-sd
...
migrate-go
| Author | SHA1 | Date | |
|---|---|---|---|
|
be98d1337e | ||
|
|
4aed8b5bcb | ||
|
|
51a1f71c59 |
@@ -7,6 +7,41 @@ description: >
|
||||
---
|
||||
|
||||
|
||||
## Overview
|
||||
|
||||
|
||||
|
||||
# MCP Toolbox SDKs for Go
|
||||
|
||||
[](https://opensource.org/licenses/Apache-2.0)
|
||||
[](https://googleapis.github.io/genai-toolbox/)
|
||||
[](https://discord.gg/Dmm69peqjh)
|
||||
[](https://medium.com/@mcp_toolbox)
|
||||
[](https://goreportcard.com/report/github.com/googleapis/mcp-toolbox-sdk-go)
|
||||
[](https://img.shields.io/github/v/release/googleapis/mcp-toolbox-sdk-go)
|
||||
[](https://img.shields.io/github/go-mod/go-version/googleapis/mcp-toolbox-sdk-go)
|
||||
|
||||
This repository contains the Go SDK designed to seamlessly integrate the
|
||||
functionalities of the [MCP
|
||||
Toolbox](https://github.com/googleapis/genai-toolbox) into your Gen AI
|
||||
applications. The SDK allow you to load tools defined in Toolbox and use them
|
||||
as standard Go tools within popular orchestration frameworks
|
||||
or your custom code.
|
||||
|
||||
This simplifies the process of incorporating external functionalities (like
|
||||
Databases or APIs) managed by Toolbox into your GenAI applications.
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [Overview](#overview)
|
||||
- [Which Package Should I Use?](#which-package-should-i-use)
|
||||
- [Available Packages](#available-packages)
|
||||
- [Getting Started](#getting-started)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## Overview
|
||||
|
||||
The MCP Toolbox service provides a centralized way to manage and expose tools
|
||||
@@ -22,4 +57,58 @@ The Go SDK act as clients for that service. They handle the communication needed
|
||||
By using the SDK, you can easily leverage your Toolbox-managed tools directly
|
||||
within your Go applications or AI orchestration frameworks.
|
||||
|
||||
## Which Package Should I Use?
|
||||
|
||||
Choosing the right package depends on how you are building your application:
|
||||
|
||||
- [`core`](https://github.com/googleapis/mcp-toolbox-sdk-go/tree/main/core):
|
||||
This is a framework agnostic way to connect the tools to popular frameworks
|
||||
like Google GenAI, LangChain, etc.
|
||||
|
||||
- [`tbadk`](https://github.com/googleapis/mcp-toolbox-sdk-go/tree/main/tbadk):
|
||||
This package provides a way to connect tools to ADK Go.
|
||||
|
||||
- [`tbgenkit`](https://github.com/googleapis/mcp-toolbox-sdk-go/tree/main/tbgenkit):
|
||||
This package provides a functionality to convert the Tool fetched using the core package
|
||||
into a Genkit Go compatible tool.
|
||||
|
||||
## Available Packages
|
||||
|
||||
This repository hosts the following Go packages. See the package-specific
|
||||
README for detailed installation and usage instructions:
|
||||
|
||||
| Package | Target Use Case | Integration | Path | Details (README) |
|
||||
| :------ | :----------| :---------- | :---------------------- | :---------- |
|
||||
| `core` | Framework-agnostic / Custom applications | Use directly / Custom | `core/` | 📄 [View README](https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/core/README.md) |
|
||||
| `tbadk` | ADK Go | Use directly | `tbadk/` | 📄 [View README](https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/tbadk/README.md) |
|
||||
| `tbgenkit` | Genkit Go | Along with core | `tbgenkit/` | 📄 [View README](https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/tbgenkit/README.md) |
|
||||
|
||||
## Getting Started
|
||||
|
||||
To get started using Toolbox tools with an application, follow these general steps:
|
||||
|
||||
1. **Set up and Run the Toolbox Service:**
|
||||
|
||||
Before using the SDKs, you need the MCP Toolbox server running. Follow
|
||||
the instructions here: [**Toolbox Getting Started
|
||||
Guide**](https://github.com/googleapis/genai-toolbox?tab=readme-ov-file#getting-started)
|
||||
|
||||
2. **Install the Appropriate SDK:**
|
||||
|
||||
Choose the package based on your needs (see "[Which Package Should I Use?](#which-package-should-i-use)" above)
|
||||
Use this command to install the SDK module
|
||||
|
||||
```bash
|
||||
# For the core, framework-agnostic SDK
|
||||
go get github.com/googleapis/mcp-toolbox-sdk-go
|
||||
```
|
||||
|
||||
3. **Use the SDK:**
|
||||
|
||||
Consult the README for your chosen package (linked in the "[Available
|
||||
Packages](#available-packages)" section above) for detailed instructions on
|
||||
how to connect the client, load tool definitions, invoke tools, configure
|
||||
authentication/binding, and integrate them into your application or
|
||||
framework.
|
||||
|
||||
[Github](https://github.com/googleapis/mcp-toolbox-sdk-go)
|
||||
148
docs/en/sdks/go-sdk/tbgenkit/_index.md
Normal file
148
docs/en/sdks/go-sdk/tbgenkit/_index.md
Normal file
@@ -0,0 +1,148 @@
|
||||
---
|
||||
title: "tbGenkit Package"
|
||||
linkTitle: "tbGenkit"
|
||||
type: docs
|
||||
weight: 1
|
||||
---
|
||||
|
||||
|
||||
|
||||
# MCP Toolbox TBGenkit Package
|
||||
|
||||
[](https://opensource.org/licenses/Apache-2.0)
|
||||
|
||||
This package allows you to seamlessly integrate the functionalities of
|
||||
[Toolbox](https://github.com/googleapis/genai-toolbox) allowing you to load and
|
||||
use tools defined in the service as standard Genkit Tools within your Genkit Go
|
||||
applications.
|
||||
|
||||
This simplifies integrating external functionalities (like APIs, databases, or
|
||||
custom logic) managed by the Toolbox into your workflows, especially those
|
||||
involving Large Language Models (LLMs).
|
||||
|
||||
|
||||
<!-- TOC ignore:true -->
|
||||
<!-- TOC -->
|
||||
|
||||
- [Installation](#installation)
|
||||
- [Quickstart](#quickstart)
|
||||
- [Convert Toolbox Tool to a Genkit Tool](#convert-toolbox-tool-to-a-genkit-tool)
|
||||
- [Contributing](#contributing)
|
||||
- [License](#license)
|
||||
- [Support](#support)
|
||||
- [Samples for Reference](#samples-for-reference)
|
||||
<!-- /TOC -->
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
go get github.com/googleapis/mcp-toolbox-sdk-go
|
||||
```
|
||||
This SDK is supported on Go version 1.24.4 and higher.
|
||||
|
||||
## Quickstart
|
||||
|
||||
For more information on how to load a ToolboxTool, see [the core package](https://github.com/googleapis/mcp-toolbox-sdk-go/tree/main/core)
|
||||
|
||||
## Convert Toolbox Tool to a Genkit Tool
|
||||
|
||||
```go
|
||||
"github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
|
||||
|
||||
func main() {
|
||||
// Assuming the toolbox tool is loaded
|
||||
// Make sure to add error checks for debugging
|
||||
ctx := context.Background()
|
||||
g, err := genkit.Init(ctx)
|
||||
|
||||
genkitTool, err := tbgenkit.ToGenkitTool(toolboxTool, g)
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
For end-to-end example on how to use Toolbox with Genkit Go, check out the [/samples/](https://github.com/googleapis/mcp-toolbox-sdk-go/tree/main/tbgenkit/samples) folder
|
||||
|
||||
# Contributing
|
||||
|
||||
Contributions are welcome! Please refer to the [DEVELOPER.md](/DEVELOPER.md)
|
||||
file for guidelines on how to set up a development environment and run tests.
|
||||
|
||||
# License
|
||||
|
||||
This project is licensed under the Apache License 2.0. See the
|
||||
[LICENSE](https://github.com/googleapis/mcp-toolbox-sdk-go/blob/main/LICENSE) file for details.
|
||||
|
||||
# Support
|
||||
|
||||
If you encounter issues or have questions, check the existing [GitHub Issues](https://github.com/googleapis/genai-toolbox/issues) for the main Toolbox project.
|
||||
|
||||
# Samples for Reference
|
||||
|
||||
<details>
|
||||
<summary>Genkit Go</summary>
|
||||
|
||||
```go
|
||||
//This sample contains a complete example on how to integrate MCP Toolbox Go SDK with Genkit Go using the tbgenkit package.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log"
|
||||
|
||||
"github.com/googleapis/mcp-toolbox-sdk-go/core"
|
||||
"github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
|
||||
|
||||
"github.com/firebase/genkit/go/ai"
|
||||
"github.com/firebase/genkit/go/genkit"
|
||||
"github.com/firebase/genkit/go/plugins/googlegenai"
|
||||
)
|
||||
|
||||
func main() {
|
||||
ctx := context.Background()
|
||||
toolboxClient, err := core.NewToolboxClient("http://127.0.0.1:5000")
|
||||
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 tools: %v\nMake sure your Toolbox server is running and the tool is configured.", err)
|
||||
}
|
||||
|
||||
// Initialize genkit
|
||||
g := genkit.Init(ctx,
|
||||
genkit.WithPlugins(&googlegenai.GoogleAI{}),
|
||||
genkit.WithDefaultModel("googleai/gemini-1.5-flash"),
|
||||
)
|
||||
|
||||
// Convert your tool to a Genkit tool.
|
||||
genkitTools := make([]ai.Tool, len(tools))
|
||||
for i, tool := range tools {
|
||||
newTool, err := tbgenkit.ToGenkitTool(tool, g)
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to convert tool: %v\n", err)
|
||||
}
|
||||
genkitTools[i] = newTool
|
||||
}
|
||||
|
||||
toolRefs := make([]ai.ToolRef, len(genkitTools))
|
||||
|
||||
for i, tool := range genkitTools {
|
||||
toolRefs[i] = tool
|
||||
}
|
||||
|
||||
// Generate llm response using prompts and tools.
|
||||
resp, err := genkit.Generate(ctx, g,
|
||||
ai.WithPrompt("Find hotels in Basel with Basel in it's name."),
|
||||
ai.WithTools(toolRefs...),
|
||||
)
|
||||
if err != nil {
|
||||
log.Fatalf("%v\n", err)
|
||||
}
|
||||
fmt.Println(resp.Text())
|
||||
}
|
||||
```
|
||||
|
||||
</details>
|
||||
@@ -22,36 +22,4 @@ These Python SDKs act as clients for that service. They handle the communication
|
||||
By using these SDKs, you can easily leverage your Toolbox-managed tools directly
|
||||
within your Python applications or AI orchestration frameworks.
|
||||
|
||||
## Which Package Should I Use?
|
||||
|
||||
Choosing the right package depends on how you are building your application:
|
||||
|
||||
* [`toolbox-langchain`](langchain):
|
||||
Use this package if you are building your application using the LangChain or
|
||||
LangGraph frameworks. It provides tools that are directly compatible with the
|
||||
LangChain ecosystem (`BaseTool` interface), simplifying integration.
|
||||
* [`toolbox-llamaindex`](llamaindex):
|
||||
Use this package if you are building your application using the LlamaIndex framework.
|
||||
It provides tools that are directly compatible with the
|
||||
LlamaIndex ecosystem (`BaseTool` interface), simplifying integration.
|
||||
* [`toolbox-core`](core):
|
||||
Use this package if you are not using LangChain/LangGraph or any other
|
||||
orchestration framework, or if you need a framework-agnostic way to interact
|
||||
with Toolbox tools (e.g., for custom orchestration logic or direct use in
|
||||
Python scripts).
|
||||
|
||||
## Available Packages
|
||||
|
||||
This repository hosts the following Python packages. See the package-specific
|
||||
README for detailed installation and usage instructions:
|
||||
|
||||
| Package | Target Use Case | Integration | Path | Details (README) | PyPI Status |
|
||||
| :------ | :---------- | :---------- | :---------------------- | :---------- | :---------
|
||||
| `toolbox-core` | Framework-agnostic / Custom applications | Use directly / Custom | `packages/toolbox-core/` | 📄 [View README](https://github.com/googleapis/mcp-toolbox-sdk-python/blob/main/packages/toolbox-core/README.md) |  |
|
||||
| `toolbox-langchain` | LangChain / LangGraph applications | LangChain / LangGraph | `packages/toolbox-langchain/` | 📄 [View README](https://github.com/googleapis/mcp-toolbox-sdk-python/blob/main/packages/toolbox-langchain/README.md) |  |
|
||||
| `toolbox-llamaindex` | LlamaIndex applications | LlamaIndex | `packages/toolbox-llamaindex/` | 📄 [View README](https://github.com/googleapis/mcp-toolbox-sdk-python/blob/main/packages/toolbox-llamaindex/README.md) |  |
|
||||
|
||||
|
||||
{{< notice note >}}
|
||||
Source code for [python-sdk](https://github.com/googleapis/mcp-toolbox-sdk-python)
|
||||
{{< /notice >}}
|
||||
[Github](https://github.com/googleapis/mcp-toolbox-sdk-python)
|
||||
@@ -1,279 +0,0 @@
|
||||
---
|
||||
title: "Adk"
|
||||
type: docs
|
||||
weight: 8
|
||||
description: >
|
||||
MCP Toolbox ADK SDK for integrating functionalities of MCP Toolbox into your apps.
|
||||
---
|
||||
|
||||
## Overview
|
||||
|
||||
The `toolbox-adk` package provides a Python interface to the MCP Toolbox service, enabling you to load and invoke tools from your own applications.
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
pip install toolbox-adk
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
The primary entry point is the `ToolboxToolset`, which loads tools from a remote Toolbox server and adapts them for use with ADK agents.
|
||||
|
||||
{{< notice note>}}
|
||||
The `ToolboxToolset` in this package mirrors the `ToolboxToolset` in the [`adk-python`](https://github.com/google/adk-python) package. The `adk-python` version is a shim that delegates all functionality to this implementation.
|
||||
{{< /notice >}}
|
||||
|
||||
```python
|
||||
from toolbox_adk import ToolboxToolset
|
||||
from google.adk.agents import Agent
|
||||
|
||||
# Create the Toolset
|
||||
toolset = ToolboxToolset(
|
||||
server_url="http://127.0.0.1:5000"
|
||||
)
|
||||
|
||||
# Use in your ADK Agent
|
||||
agent = Agent(tools=[toolset])
|
||||
```
|
||||
|
||||
## Transport Protocols
|
||||
|
||||
The SDK supports multiple transport protocols for communicating with the Toolbox server. By default, the client uses the latest supported version of the **Model Context Protocol (MCP)**.
|
||||
|
||||
You can explicitly select a protocol using the `protocol` option during toolset initialization. This is useful if you need to use the native Toolbox HTTP protocol or pin the client to a specific legacy version of MCP.
|
||||
|
||||
{{< notice note>}}
|
||||
* **Native Toolbox Transport**: This uses the service's native **REST over HTTP** API.
|
||||
* **MCP Transports**: These options use the **Model Context Protocol over HTTP**.
|
||||
{{< /notice >}}
|
||||
|
||||
### Supported Protocols
|
||||
|
||||
| Constant | Description |
|
||||
| :--- | :--- |
|
||||
| `Protocol.MCP` | **(Default)** Alias for the default MCP version (currently `2025-06-18`). |
|
||||
| `Protocol.TOOLBOX` | The native Toolbox HTTP protocol. |
|
||||
| `Protocol.MCP_v20251125` | MCP Protocol version 2025-11-25. |
|
||||
| `Protocol.MCP_v20250618` | MCP Protocol version 2025-06-18. |
|
||||
| `Protocol.MCP_v20250326` | MCP Protocol version 2025-03-26. |
|
||||
| `Protocol.MCP_v20241105` | MCP Protocol version 2024-11-05. |
|
||||
|
||||
### Example
|
||||
|
||||
If you wish to use the native Toolbox protocol:
|
||||
|
||||
```python
|
||||
from toolbox_adk import ToolboxToolset
|
||||
from toolbox_core.protocol import Protocol
|
||||
|
||||
toolset = ToolboxToolset(
|
||||
server_url="http://127.0.0.1:5000",
|
||||
protocol=Protocol.TOOLBOX
|
||||
)
|
||||
```
|
||||
|
||||
If you want to pin the MCP Version 2025-03-26:
|
||||
|
||||
```python
|
||||
from toolbox_adk import ToolboxToolset
|
||||
from toolbox_core.protocol import Protocol
|
||||
|
||||
toolset = ToolboxToolset(
|
||||
server_url="http://127.0.0.1:5000",
|
||||
protocol=Protocol.MCP_v20250326
|
||||
)
|
||||
```
|
||||
|
||||
{{< notice tip>}}
|
||||
By default, it uses **Toolbox Identity** (no authentication), which is suitable for local development.
|
||||
|
||||
For production environments (Cloud Run, GKE) or accessing protected resources, see the [Authentication](#authentication) section for strategies like Workload Identity or OAuth2.
|
||||
{{< /notice >}}
|
||||
|
||||
## Authentication
|
||||
|
||||
The `ToolboxToolset` requires credentials to authenticate with the Toolbox server. You can configure these credentials using the `CredentialStrategy` factory methods.
|
||||
|
||||
The strategies handle two main types of authentication:
|
||||
* **Client-to-Server**: Securing the connection to the Toolbox server (e.g., Workload Identity, API keys).
|
||||
* **User Identity**: Authenticating the end-user for specific tools (e.g., 3-legged OAuth).
|
||||
|
||||
### 1. Workload Identity (ADC)
|
||||
*Recommended for Cloud Run, GKE, or local development with `gcloud auth login`.*
|
||||
|
||||
Uses the agent's Application Default Credentials (ADC) to generate an OIDC token. This is the standard way for one service to authenticate to another on Google Cloud.
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy, ToolboxToolset
|
||||
|
||||
# target_audience: The URL of your Toolbox server
|
||||
creds = CredentialStrategy.workload_identity(target_audience="https://my-toolbox-service.run.app")
|
||||
|
||||
toolset = ToolboxToolset(
|
||||
server_url="https://my-toolbox-service.run.app",
|
||||
credentials=creds
|
||||
)
|
||||
```
|
||||
|
||||
### 2. User Identity (OAuth2)
|
||||
*Recommended for tools that act on behalf of the user.*
|
||||
|
||||
Configures the ADK-native interactive 3-legged OAuth flow to get consent and credentials from the end-user at runtime. This strategy is passed to the `ToolboxToolset` just like any other credential strategy.
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy, ToolboxToolset
|
||||
|
||||
creds = CredentialStrategy.user_identity(
|
||||
client_id="YOUR_CLIENT_ID",
|
||||
client_secret="YOUR_CLIENT_SECRET",
|
||||
scopes=["https://www.googleapis.com/auth/cloud-platform"]
|
||||
)
|
||||
|
||||
# The toolset will now initiate OAuth flows when required by tools
|
||||
toolset = ToolboxToolset(
|
||||
server_url="...",
|
||||
credentials=creds
|
||||
)
|
||||
```
|
||||
|
||||
### 3. API Key
|
||||
*Use a static API key passed in a specific header (default: `X-API-Key`).*
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy
|
||||
|
||||
# Default header: X-API-Key
|
||||
creds = CredentialStrategy.api_key(key="my-secret-key")
|
||||
|
||||
# Custom header
|
||||
creds = CredentialStrategy.api_key(key="my-secret-key", header_name="X-My-Header")
|
||||
```
|
||||
|
||||
### 4. HTTP Bearer Token
|
||||
*Manually supply a static bearer token.*
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy
|
||||
|
||||
creds = CredentialStrategy.manual_token(token="your-static-bearer-token")
|
||||
```
|
||||
|
||||
### 5. Manual Google Credentials
|
||||
*Use an existing `google.auth.credentials.Credentials` object.*
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy
|
||||
import google.auth
|
||||
|
||||
creds_obj, _ = google.auth.default()
|
||||
creds = CredentialStrategy.manual_credentials(credentials=creds_obj)
|
||||
```
|
||||
|
||||
### 6. Toolbox Identity (No Auth)
|
||||
*Use this if your Toolbox server does not require authentication (e.g., local development).*
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy
|
||||
|
||||
creds = CredentialStrategy.toolbox_identity()
|
||||
```
|
||||
|
||||
### 7. Native ADK Integration
|
||||
*Convert ADK-native `AuthConfig` or `AuthCredential` objects.*
|
||||
|
||||
```python
|
||||
from toolbox_adk import CredentialStrategy
|
||||
|
||||
# From AuthConfig
|
||||
creds = CredentialStrategy.from_adk_auth_config(auth_config)
|
||||
|
||||
# From AuthCredential + AuthScheme
|
||||
creds = CredentialStrategy.from_adk_credentials(auth_credential, scheme)
|
||||
```
|
||||
|
||||
### 8. Tool-Specific Authentication
|
||||
*Resolve authentication tokens dynamically for specific tools.*
|
||||
|
||||
Some tools may define their own authentication requirements (e.g., Salesforce OAuth, GitHub PAT) via `authSources` in their schema. You can provide a mapping of getters to resolve these tokens at runtime.
|
||||
|
||||
```python
|
||||
async def get_salesforce_token():
|
||||
# Fetch token from secret manager or reliable source
|
||||
return "sf-access-token"
|
||||
|
||||
toolset = ToolboxToolset(
|
||||
server_url="...",
|
||||
auth_token_getters={
|
||||
"salesforce-auth": get_salesforce_token, # Async callable
|
||||
"github-pat": lambda: "my-pat-token" # Sync callable or static lambda
|
||||
}
|
||||
)
|
||||
```
|
||||
|
||||
## Advanced Configuration
|
||||
|
||||
### Additional Headers
|
||||
|
||||
You can inject custom headers into every request made to the Toolbox server. This is useful for passing tracing IDs, API keys, or other metadata.
|
||||
|
||||
```python
|
||||
toolset = ToolboxToolset(
|
||||
server_url="...",
|
||||
additional_headers={
|
||||
"X-Trace-ID": "12345",
|
||||
"X-My-Header": lambda: get_dynamic_header_value() # Can be a callable
|
||||
}
|
||||
)
|
||||
```
|
||||
|
||||
### Global Parameter Binding
|
||||
|
||||
Bind values to tool parameters globally across all loaded tools. These values will be **fixed** and **hidden** from the LLM.
|
||||
|
||||
* **Schema Hiding**: The bound parameters are removed from the tool schema sent to the model, simplifying the context window.
|
||||
* **Auto-Injection**: The values are automatically injected into the tool arguments during execution.
|
||||
|
||||
```python
|
||||
toolset = ToolboxToolset(
|
||||
server_url="...",
|
||||
bound_params={
|
||||
# 'region' will be removed from the LLM schema and injected automatically
|
||||
"region": "us-central1",
|
||||
"api_key": lambda: get_api_key() # Can be a callable
|
||||
}
|
||||
)
|
||||
```
|
||||
|
||||
### Usage with Hooks
|
||||
|
||||
You can attach `pre_hook` and `post_hook` functions to execute logic before and after every tool invocation.
|
||||
|
||||
{{< notice note>}}
|
||||
The `pre_hook` can modify `context.arguments` to dynamically alter the inputs passed to the tool.
|
||||
{{< /notice >}}
|
||||
|
||||
```python
|
||||
from google.adk.tools.tool_context import ToolContext
|
||||
from typing import Any, Dict, Optional
|
||||
|
||||
async def log_start(context: ToolContext, args: Dict[str, Any]):
|
||||
print(f"Starting tool with args: {args}")
|
||||
# context is the ADK ToolContext
|
||||
# Example: Inject or modify arguments
|
||||
# args["user_id"] = "123"
|
||||
|
||||
async def log_end(context: ToolContext, args: Dict[str, Any], result: Optional[Any], error: Optional[Exception]):
|
||||
print("Finished tool execution")
|
||||
# Inspect result or error
|
||||
if error:
|
||||
print(f"Tool failed: {error}")
|
||||
else:
|
||||
print(f"Tool succeeded with result: {result}")
|
||||
|
||||
toolset = ToolboxToolset(
|
||||
server_url="...",
|
||||
pre_hook=log_start,
|
||||
post_hook=log_end
|
||||
)
|
||||
```
|
||||
Reference in New Issue
Block a user