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.mdLangChain / 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.mdLlamaIndex
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
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.mdLangChain / 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
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.mdLangChain 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].