tRPC-Agent-Go

https://trpc-group.github.io/trpc-agent-go/
Admin
tRPC-Agent-Go is an autonomous multi-Agent framework in Go that enables developers to build...
Tokens:1,110,932
Snippets:6,453
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run Function Tool and MCP Tool examples

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Run the Function Tool example by entering the examples/tool directory and executing go run . . For the MCP tool example, enter examples/mcp_tool, start the external server in streamalbe_server with go run main.go in the background, then run the main program with the -model flag set to deepseek-v4-flash.

```shell
cd examples/tool
go run .
```

```shell
cd examples/mcp_tool

# Start the external server.
cd streamalbe_server && go run main.go &

# Run the main program.
go run main.go -model="deepseek-v4-flash"
```

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

### Streamable function tool with weather streaming example

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Shows how to define a streamable function tool with input/output structs, implement a streaming function that sends chunks via tool.StreamWriter, create the tool with function.NewStreamableFunctionTool, and consume the stream using StreamableCall and reader.Recv. The example simulates latency with time.Sleep and handles io.EOF to end the stream.

```go
// 1. Define input and output structures.
type weatherInput struct {
    Location string `json:"location" jsonschema:"description=Location to query e.g. city name or coordinates"`
}

type weatherOutput struct {
    Weather string `json:"weather"`
}

// 2. Implement the streaming tool function.
func getStreamableWeather(input weatherInput) *tool.StreamReader {
    stream := tool.NewStream(10)
    go func() {
        defer stream.Writer.Close()

        // Simulate progressively returning weather data.
        result := "Sunny, 25°C in " + input.Location
        for i := 0; i < len(result); i++ {
            chunk := tool.StreamChunk{
                Content: weatherOutput{
                    Weather: result[i : i+1],
                },
                Metadata: tool.Metadata{CreatedAt: time.Now()},
            }

            if closed := stream.Writer.Send(chunk, nil); closed {
                break
            }
            time.Sleep(10 * time.Millisecond) // Simulate latency.
        }
    }()

    return stream.Reader
}

// 3. Create the streaming tool.
weatherStreamTool := function.NewStreamableFunctionTool[weatherInput, weatherOutput](
    getStreamableWeather,
    function.WithName("get_weather_stream"),
    function.WithDescription("Get weather information as a stream."),
)

// 4. Use the streaming tool.
reader, err := weatherStreamTool.StreamableCall(ctx, jsonArgs)
if err != nil {
    return err
}

// Receive streaming data.
for {
    chunk, err := reader.Recv()
    if err == io.EOF {
        break // End of stream.
    }
    if err != nil {
        return err
    }

    // Process each chunk.
    fmt.Printf("Received: %v\n", chunk.Content)
}
reader.Close()

```

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

### Register toolsearch plugin with Toolboxes and Runner

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Register the toolsearch plugin on a Runner, group deferred tools into namespaced Toolboxes, and inject the catalog into the system prompt. Preset tools are always advertised; deferred tools are loaded on demand via tool_search. The example caps search results to 5 and namespaces toolboxes to avoid collisions.

```go
import (
    "trpc.group/trpc-go/trpc-agent-go/agent/llmagent"
    "trpc.group/trpc-go/trpc-agent-go/plugin/toolsearch"
    "trpc.group/trpc-go/trpc-agent-go/runner"
    "trpc.group/trpc-go/trpc-agent-go/tool"
)

ag := llmagent.New("assistant",
    llmagent.WithModel(modelInstance),
    // Preset tools are always available; deferred tools are loaded on demand.
    llmagent.WithTools(presetTools),
    llmagent.WithInstruction(`
You can browse deferred tools in this catalog and load them via tool_search:
{deferred_tools_section}
`),
)

ts := toolsearch.New(
    presetTools,
    toolsearch.WithToolboxes([]toolsearch.Toolbox{
        {
            Name:        "billing",
            Description: "Invoices, payments and refunds.",
            Tools:       billingTools,
        },
        {
            Name:        "crm",
            Description: "Customer, contact and opportunity management.",
            Tools:       crmTools,
        },
    }),
    toolsearch.WithMaxResults(5), // cap the number of tools returned per search
)

r := runner.NewRunner("app", ag, runner.WithPlugins(ts))
```

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

### Custom FilterFunc: allow tools with names starting with safe_

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Custom filter function that only allows tools whose names start with "safe_". Option 1 applies the filter directly to runner.Run; Option 2 configures the agent with the same filter via llmagent.WithToolFilter.

```go
// Option 1:
// Custom filter: only allow tools with names starting with "safe_"
filter := func(ctx context.Context, t tool.Tool) bool {
    declaration := t.Declaration()
    if declaration == nil {
        return false
    }
    return strings.HasPrefix(declaration.Name, "safe_")
}

eventChan, err := runner.Run(ctx, userID, sessionID, message,
    agent.WithToolFilter(filter),
)

// Option 2:
agent := llmagent.New("ai-assistant",
    llmagent.WithModel(model),
    llmagent.WithInstruction("You are a helpful AI assistant that can use various tools to help users."),
    llmagent.WithTools([]tool.Tool{
        calculatorTool, timeTool, searchTool,
    }),
    llmagent.WithToolSets([]tool.ToolSet{
        stdioToolSet, sseToolSet, streamableToolSet,
    }),
    llmagent.WithToolFilter(filter),


```

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

### Create and initialize an MCP ToolSet (STDIO)

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Create an MCP ToolSet using STDIO transport, optionally filter tools, initialize it, and attach it to an LLMAgent. The Init call fails fast on connection or tool-loading errors. The tool filter is optional and uses the include filter for the names "echo" and "add".

```go
import "trpc.group/trpc-go/trpc-agent-go/tool/mcp"

// Create an MCP ToolSet (STDIO example).
mcpToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "stdio",           // Transport method.
        Command:   "go",              // Command to execute.
        Args:      []string{"run", "./stdio_server/main.go"},
        Timeout:   10 * time.Second,
    },
    mcp.WithToolFilterFunc(tool.NewIncludeToolNamesFilter("echo", "add")), // Optional: tool filter.
)

// (Optional but recommended) Explicitly initialize MCP: connect + initialize + list tools.
if err := mcpToolSet.Init(ctx); err != nil {
    log.Fatalf("failed to initialize MCP toolset: %v", err)
}

// Integrate into an Agent.
agent := llmagent.New("mcp-assistant",
    llmagent.WithModel(model),
    llmagent.WithToolSets([]tool.ToolSet{mcpToolSet}))

```

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

### Create Agent and Integrate Tools with MCP ToolSets

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Creates an Agent with function tools, a built-in DuckDuckGo tool, and MCP ToolSets for stdio, SSE, and streamable HTTP transports. Each MCP ToolSet is initialized with a 10-second timeout and returns an error if initialization fails. The Agent is configured with a model, instruction, and both single tools and ToolSets.

```go
import (
    "trpc.group/trpc-go/trpc-agent-go/agent/llmagent"
    "trpc.group/trpc-go/trpc-agent-go/tool"
    "trpc.group/trpc-go/trpc-agent-go/tool/function"
    "trpc.group/trpc-go/trpc-agent-go/tool/duckduckgo"
    "trpc.group/trpc-go/trpc-agent-go/tool/mcp"
)

// Create function tools.
calculatorTool := function.NewFunctionTool(calculator,
    function.WithName("calculator"),
    function.WithDescription("Perform basic mathematical operations."))

timeTool := function.NewFunctionTool(getCurrentTime,
    function.WithName("current_time"),
    function.WithDescription("Get the current time."))

// Create a built-in tool.
searchTool := duckduckgo.NewTool()

// Create MCP ToolSets (examples for different transports).
stdioToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "stdio",
        Command:   "python",
        Args:      []string{"-m", "my_mcp_server"},
        Timeout:   10 * time.Second,
    },
)
if err := stdioToolSet.Init(ctx); err != nil {
    return fmt.Errorf("failed to initialize stdio MCP toolset: %w", err)
}

sseToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "sse",
        ServerURL: "http://localhost:8080/sse",
        Timeout:   10 * time.Second,
    },
)
if err := sseToolSet.Init(ctx); err != nil {
    return fmt.Errorf("failed to initialize sse MCP toolset: %w", err)
}

streamableToolSet := mcp.NewMCPToolSet(
    mcp.ConnectionConfig{
        Transport: "streamable_http",
        ServerURL: "http://localhost:3000/mcp",
        Timeout:   10 * time.Second,
    },
)
if err := streamableToolSet.Init(ctx); err != nil {
    return fmt.Errorf("failed to initialize streamable MCP toolset: %w", err)
}

// Create an Agent and integrate all tools.
agent := llmagent.New("ai-assistant",
    llmagent.WithModel(model),
    llmagent.WithInstruction("You are a helpful AI assistant that can use various tools to help users."),
    // Add single tools (Tool interface).
    llmagent.WithTools([]tool.Tool{
        calculatorTool, timeTool, searchTool,
    }),
    // Add ToolSets (ToolSet interface).
    llmagent.WithToolSets([]tool.ToolSet{
        stdioToolSet, sseToolSet, streamableToolSet,
    }),
)

```

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

### Hybrid Pattern Graph Creation

Source: https://trpc-group.github.io/trpc-agent-go/graph?q=

Hybrid pattern example: creates a state graph with the given schema. The code is incomplete in the source, showing only the import and graph creation.

```go
import (
    "trpc.group/trpc-go/trpc-agent-go/agent"
    "trpc.group/trpc-go/trpc-agent-go/agent/chainagent"
    "trpc.group/trpc-go/trpc-agent-go/agent/graphagent"
    "trpc.group/trpc-go/trpc-agent-go/graph"
)

sg := graph.NewStateGraph(schema)

```

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

### mcp_list_servers output with description

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Example output of the mcp_list_servers tool showing the server description field. The description is optional; when omitted, the output simply does not include a description property.

```json
{
  "servers": [
    {
      "name": "local_stdio_code",
      "transport": "stdio",
      "description": "Project management, documentation, and calendar tools."
    }
  ]
}
```

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

### Create a Function Tool with calculator and integrate into an Agent

Source: https://trpc-group.github.io/trpc-agent-go/tool

Shows how to define a Go function as a tool, wrap it with function.NewFunctionTool, and integrate it into an agent using llmagent.New. The function uses jsonschema tags for argument descriptions and returns a map with the result.

```go
import "trpc.group/trpc-go/trpc-agent-go/tool/function"

// 1. Define a tool function.
func calculator(ctx context.Context, req struct {
    Operation string  `json:"operation" jsonschema:"description=Operation type e.g. add/multiply"`
    A         float64 `json:"a" jsonschema:"description=First operand"`
    B         float64 `json:"b" jsonschema:"description=Second operand"`
}) (map[string]interface{}, error) {
    switch req.Operation {
    case "add":
        return map[string]interface{}{"result": req.A + req.B}, nil
    case "multiply":
        return map[string]interface{}{"result": req.A * req.B}, nil
    default:
        return nil, fmt.Errorf("unsupported operation: %s", req.Operation)
    }
}

// 2. Create the tool.
calculatorTool := function.NewFunctionTool(
    calculator,
    function.WithName("calculator"),
    function.WithDescription("Perform mathematical operations."),
)

// 3. Integrate into an Agent.
agent := llmagent.New("math-assistant",
    llmagent.WithModel(model),
    llmagent.WithTools([]tool.Tool{calculatorTool}))
```

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

### Per-Agent Filtering with agent.InvocationFromContext

Source: https://trpc-group.github.io/trpc-agent-go/tool?q=

Per-agent filtering: uses agent.InvocationFromContext to get the current Agent name and only allows tools listed in agentAllowedTools for that Agent. Falls back to allowing all tools when context is missing or the Agent has no entry.

```go
// Define allowed tools for each Agent
agentAllowedTools := map[string]map[string]bool{
    "math-agent": {
        "calculator": true,
    },
    "time-agent": {
        "time_tool": true,
    },
}

// Custom filter function: filter based on current Agent name
filter := func(ctx context.Context, t tool.Tool) bool {
    declaration := t.Declaration()
    if declaration == nil {
        return false
    }
    toolName := declaration.Name

    // Get current Agent information from context
    inv, ok := agent.InvocationFromContext(ctx)
    if !ok || inv == nil {
        return true // fallback: allow all tools
    }

    agentName := inv.AgentName

    // Check if this tool is in the current Agent's allowed list
    allowedTools, exists := agentAllowedTools[agentName]
    if !exists {
        return true // fallback: allow all tools
    }

    return allowedTools[toolName]
}

eventChan, err := runner.Run(ctx, userID, sessionID, message,
    agent.WithToolFilter(filter),
)


```
Tokens:
Raw