tRPC-Agent-Go English | 中文 tRPC-Agent-Go is a Go framework for building production agent systems. It provides LLM agents, graph workflows, tool calling, session and memory state, knowledge retrieval, agent self-evolution, evaluation, and OpenTelemetry observability in one Go-native stack. Use it when you want agent applications that fit Go services: concurrent, observable, easy to deploy, and read
Tools
Tools
No tool list yet. Remote servers get one after the first health check.
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
Does Trpc Agent Go need an API key?
No required environment variable is listed on this record.
What transport does Trpc Agent Go use?
Trpc Agent Go runs locally over stdio.
When was Trpc Agent Go last checked?
Last checked 2026-11-09. tRPC-Agent-Go English | 中文 tRPC-Agent-Go is a Go framework for building production agent systems. It provides LLM agents, graph workflows, tool calling, session and memory state, knowledge retrieval, agent self-evolution, evaluation, and OpenTelemetry observability in one Go-native stack. Use it when you want agent applications that fit Go services: concurrent, observable, easy to deploy, and read
From the publisher
Documentation
tRPC-Agent-Go is a Go framework for building production agent systems.
It provides LLM agents, graph workflows, tool calling, session and memory
state, knowledge retrieval, agent self-evolution, evaluation, and OpenTelemetry
observability in one Go-native stack.
Use it when you want agent applications that fit Go services: concurrent,
observable, easy to deploy, and ready to integrate with A2A, AG-UI, and MCP.
Why tRPC-Agent-Go?
Go-Native Agent Runtime: Streaming runners, context cancellation, and
service-friendly APIs
GraphAgent: Type-safe graph workflows with multi-conditional routing,
functionally equivalent to LangGraph for Go
Multi-Agent Collaboration: Chain, parallel, and cycle-based workflows
Rich Tool Ecosystem: Function tools, MCP tools, web search, code
execution, and custom services
Persistent State: Session, memory, artifacts, and knowledge retrieval
Agent Skills: Reusable SKILL.md workflows with safe execution
Agent Self-Evolution: Hermes-style session reviews that extract, gate,
and publish reusable SKILL.md workflows
Prompt Caching: Automatic cost optimization with 90% savings on cached content
Evaluation & Benchmarks: Eval sets + metrics to measure quality over time
Key features
01. A Go framework for building production agent systems with graph workflows, tools, memory, A2A, AG-UI, MCP, evaluation, and observability
02. tRPC-Agent-Go English | 中文 tRPC-Agent-Go is a Go framework for building production agent systems
03. It provides LLM agents, graph workflows, tool calling, session and memory state, knowledge retrieval, agent self-evolution, evaluation, and OpenTelemetry observability in one Go-native stack
04. Use it when you want agent applications that fit Go services: concurrent, observable, easy to deploy, and read
05. <div align="center">
Use cases
01. Customer Support Bots - Intelligent agents that understand context and solve complex queries
02. Data Analysis Assistants - Agents that query databases, generate reports, and provide insights
03. DevOps Automation - Smart deployment, monitoring, and incident response systems
04. Business Process Automation - Multi-step workflows with human-in-the-loop capabilities
05. Research & Knowledge Management - RAG-powered agents for document analysis and Q&A
Protocol Integration: AG-UI for frontends, A2A for agent
interoperability, and MCP for tools
Production Observability: OpenTelemetry tracing, metrics, and Langfuse
examples
Use Cases
Perfect for building:
Customer Support Bots - Intelligent agents that understand context and solve complex queries
Data Analysis Assistants - Agents that query databases, generate reports, and provide insights
DevOps Automation - Smart deployment, monitoring, and incident response systems
Business Process Automation - Multi-step workflows with human-in-the-loop capabilities
Research & Knowledge Management - RAG-powered agents for document analysis and Q&A
Key Features
Multi-Agent Orchestration
// Chain agents for complex workflows
pipeline := chainagent.New("pipeline",
chainagent.WithSubAgents([]agent.Agent{
analyzer, processor, reporter,
}))
// Or run them in parallel
parallel := parallelagent.New("concurrent",
parallelagent.WithSubAgents(tasks))
Advanced Memory System
// Persistent memory with search
memory := memorysvc.NewInMemoryService()
agent := llmagent.New("assistant",
llmagent.WithTools(memory.Tools()),
llmagent.WithModel(model))
// Memory service managed at runner level
runner := runner.NewRunner("app", agent,
runner.WithMemoryService(memory))
// Agents remember context across sessions
Rich Tool Integration
// Any function becomes a tool
calculator := function.NewFunctionTool(
calculate,
function.WithName("calculator"),
function.WithDescription("Math operations"))
// MCP protocol support
mcpTool := mcptool.New(serverConn)
// Skills are folders with a SKILL.md spec.
repo, _ := skill.NewFSRepository("./skills")
// Let the agent load and run skills on demand.
tools := []tool.Tool{
skilltool.NewLoadTool(repo),
skilltool.NewRunTool(repo, localexec.New()),
}
NewFSRepository also accepts an HTTP(S) URL (for example, a .zip or
.tar.gz archive). The payload is downloaded and cached locally (set
SKILLS_CACHE_DIR to override the cache location).
NewFSRepository also accepts multiple roots, which is useful for
combining shared skills with user-private skills. In a long-lived
process, call repo.Refresh() after installing, deleting, or renaming a
skill so the next turn sees the updated skill set.
If you wire Skills through LLMAgent with llmagent.WithCodeExecutor(...),
consider also setting
llmagent.WithEnableCodeExecutionResponseProcessor(false) so Markdown fenced
code blocks embedded in assistant text do not auto-execute while skill_run is
enabled.
Ready to dive into tRPC-Agent-Go? Our documentation covers everything from basic concepts to advanced techniques, helping you build powerful AI applications with confidence. Whether you're new to AI agents or an experienced developer, you'll find detailed guides, practical examples, and best practices to accelerate your development journey.
Blog
These blog posts cover the framework overview, core capabilities, and engineering practices—read as needed:
The demo above shows a tRPC-Agent-Go service streaming agent events to an
AG-UI client while the agent plans, calls tools, and updates the interface.
Prerequisites
Go 1.21 or later
LLM provider API key (OpenAI, DeepSeek, etc.)
5 minutes to build your first intelligent agent
Run the Example
Get started in 3 simple steps:
# 1. Clone and setup
git clone https://github.com/trpc-group/trpc-agent-go.git
cd trpc-agent-go
# 2. Configure your LLM
export OPENAI_API_KEY="your-api-key-here"
export OPENAI_BASE_URL="your-base-url-here" # Optional
# 3. Run your first agent!
cd examples/runner
go run . -model="gpt-4o-mini" -streaming=true
What you'll see:
Interactive chat with your AI agent
Real-time streaming responses
Tool usage (calculator + time tools)
Multi-turn conversations with memory
Try asking: "What's the current time? Then calculate 15 * 23 + 100"
Basic Usage
package main
import (
"context"
"fmt"
"log"
"trpc.group/trpc-go/trpc-agent-go/agent/llmagent"
"trpc.group/trpc-go/trpc-agent-go/model"
"trpc.group/trpc-go/trpc-agent-go/model/openai"
"trpc.group/trpc-go/trpc-agent-go/runner"
"trpc.group/trpc-go/trpc-agent-go/tool"
"trpc.group/trpc-go/trpc-agent-go/tool/function"
)
func main() {
// Create model.
modelInstance := openai.New("deepseek-chat",
openai.WithVariant(openai.VariantDeepSeek),
)
// Create tool.
calculatorTool := function.NewFunctionTool(
calculator,
function.WithName("calculator"),
function.WithDescription("Execute addition, subtraction, multiplication, and division. "+
"Parameters: a, b are numeric values, op takes values add/sub/mul/div; "+
"returns result as the calculation result."),
)
// Enable streaming output.
genConfig := model.GenerationConfig{
Stream: true,
}
// Create Agent.
agent := llmagent.New("assistant",
llmagent.WithModel(modelInstance),
llmagent.WithTools([]tool.Tool{calculatorTool}),
llmagent.WithGenerationConfig(genConfig),
)
// Create Runner.
runner := runner.NewRunner("calculator-app", agent)
// Execute conversation.
ctx := context.Background()
events, err := runner.Run(ctx,
"user-001",
"session-001",
model.NewUserMessage("Calculate what 2+3 equals"),
)
if err != nil {
log.Fatal(err)
}
// Process event stream.
for event := range events {
if event.Object == "chat.completion.chunk" {
fmt.Print(event.Response.Choices[0].Delta.Content)
}
}
fmt.Println()
}
func calculator(ctx context.Context, req calculatorReq) (calculatorRsp, error) {
var result float64
switch req.Op {
case "add", "+":
result = req.A + req.B
case "sub", "-":
result = req.A - req.B
case "mul", "*":
result = req.A * req.B
case "div", "/":
result = req.A / req.B
default:
return calculatorRsp{}, fmt.Errorf("invalid operation: %s", req.Op)
}
return calculatorRsp{Result: result}, nil
}
type calculatorReq struct {
A float64 `json:"A" jsonschema:"description=First integer operand,required"`
B float64 `json:"B" jsonschema:"description=Second integer operand,required"`
Op string `json:"Op" jsonschema:"description=Operation type,enum=add,enum=sub,enum=mul,enum=div,required"`
}
type calculatorRsp struct {
Result float64 `json:"result"`
}
Dynamic Agent per Request
Sometimes your Agent must be created per request (for example: different
prompt, model, tools, sandbox instance). In that case, you can let Runner build
a fresh Agent for every Run(...):
r := runner.NewRunnerWithAgentFactory(
"my-app",
"assistant",
func(ctx context.Context, ro agent.RunOptions) (agent.Agent, error) {
// Use ro to build an Agent for this request.
a := llmagent.New("assistant",
llmagent.WithInstruction(ro.Instruction),
)
return a, nil
},
)
events, err := r.Run(ctx,
"user-001",
"session-001",
model.NewUserMessage("Hello"),
agent.WithInstruction("You are a helpful assistant."),
)
_ = events
_ = err
Stop / Cancel a Run
If you want to interrupt a running agent, cancel the context you passed to
Runner.Run (recommended). This stops model calls and tool calls safely and
lets the runner clean up.
Important: do not just “break” your event loop and walk away — the agent
goroutine may keep running and can block on channel writes. Always cancel, then
keep draining the event channel until it is closed.
Option A: Ctrl+C (terminal programs)
Convert Ctrl+C into context cancellation:
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()
events, err := r.Run(ctx, userID, sessionID, message)
if err != nil {
return err
}
for range events {
// Drain until the runner stops (ctx canceled or run completed).
}
Option B: Cancel from your code
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
events, err := r.Run(ctx, userID, sessionID, message)
if err != nil {
return err
}
go func() {
time.Sleep(2 * time.Second)
cancel()
}()
for range events {
// Keep draining until the channel is closed.
}
Option C: Cancel by requestID (for servers / background runs)
GraphAgent – demonstrates building and executing complex, conditional
workflows using the graph and agent/graph packages. It shows
how to construct a graph-based agent, manage state safely, implement
conditional routing, and orchestrate execution with the Runner.
Multi-conditional fan-out routing:
// Return multiple branch keys and run targets in parallel.
sg := graph.NewStateGraph(schema)
sg.AddNode("router", func(ctx context.Context, s graph.State) (any, error) {
return nil, nil
})
sg.AddNode("A", func(ctx context.Context, s graph.State) (any, error) {
return graph.State{"a": 1}, nil
})
sg.AddNode("B", func(ctx context.Context, s graph.State) (any, error) {
return graph.State{"b": 1}, nil
})
sg.SetEntryPoint("router")
sg.AddMultiConditionalEdges(
"router",
func(ctx context.Context, s graph.State) ([]string, error) {
return []string{"goA", "goB"}, nil
},
map[string]string{"goA": "A", "goB": "B"}, // Path map or ends map
)
sg.SetFinishPoint("A").SetFinishPoint("B")
Skills are folders with a SKILL.md spec + optional docs/scripts.
Built-in tools: skill_load, skill_list_docs, skill_select_docs,
skill_run, and (when the executor supports interactive sessions)
skill_exec, skill_write_stdin, skill_poll_session,
skill_kill_session.
skill_run is the default one-shot command runner in an isolated
workspace.
skill_exec and the session tools cover interactive stdin/TTY flows
without inlining full scripts into the prompt. They are registered
only when the code executor exposes InteractiveProgramRunner
(or falls back to a local engine that does).
skill.NewFSRepository(...) can scan multiple roots, such as a shared
skills directory plus a user-private directory. Use
(*skill.FSRepository).Refresh() after skill installation or removal
in long-lived processes.
Prefer using skill_run only for commands required by the selected skill
docs, not for generic shell exploration.
When LLMAgent uses WithCodeExecutor(...) only to support skill_run,
disable the response code execution processor with
llmagent.WithEnableCodeExecutionResponseProcessor(false). The
skill-focused examples (examples/skill, examples/skillrun,
examples/skilldynamicschema, and
examples/structuredoutputskills) follow this pattern so fenced code
blocks embedded in assistant text do not auto-execute.
examples/skillfind demonstrates a real end-to-end discovery flow:
the model uses a built-in skill-find skill to search the public web,
install a public GitHub skill into a user-private directory, refresh
the repository, and use the new skill in the same conversation.
Local execution stays off by default and can be enabled explicitly
when you want to run an installed skill.
Provides various tool capabilities (Function, MCP, DuckDuckGo, etc.).
session
Manages user session state and events.
memory
Records user long-term memory and personalized information.
knowledge
Implements RAG knowledge retrieval capabilities.
planner
Provides Agent planning and reasoning capabilities.
artifact
Stores and retrieves versioned files produced by agents and tools (images, reports, etc.).
skill
Loads and executes reusable Agent Skills defined by SKILL.md.
evolution
Reviews completed sessions and publishes reusable procedures as managed Agent Skills.
event
Defines event types and streaming payloads used across Runner and servers.
evaluation
Evaluates agents on eval sets using pluggable metrics and stores results.
server
Exposes HTTP servers (Gateway, AG-UI, A2A) for integration and UIs.
telemetry
OpenTelemetry tracing and metrics instrumentation.
Using Built-in Agents
For most applications you do not need to implement the agent.Agent
interface yourself. The framework already ships with several ready-to-use
agents that you can compose like Lego bricks:
Agent
Purpose
LLMAgent
Wraps an LLM chat-completion model as an agent.
ChainAgent
Executes sub-agents sequentially.
ParallelAgent
Executes sub-agents concurrently and merges output.
CycleAgent
Loops over a planner + executor until stop signal.
Multi-Agent Collaboration Example
// 1. Create a base LLM agent.
base := llmagent.New(
"assistant",
llmagent.WithModel(openai.New("gpt-4o-mini")),
)
// 2. Create a second LLM agent with a different instruction.
translator := llmagent.New(
"translator",
llmagent.WithInstruction("Translate everything to French"),
llmagent.WithModel(openai.New("gpt-3.5-turbo")),
)
// 3. Combine them in a chain.
pipeline := chainagent.New(
"pipeline",
chainagent.WithSubAgents([]agent.Agent{base, translator}),
)
// 4. Run through the runner for sessions & telemetry.
run := runner.NewRunner("demo-app", pipeline)
events, _ := run.Run(ctx, "user-1", "sess-1",
model.NewUserMessage("Hello!"))
for ev := range events { /* ... */ }
The composition API lets you nest chains, cycles, or parallels to build complex
workflows without low-level plumbing.
Contributing
We love contributions! Join our growing community of developers building the future of AI agents.
Share your use cases - inspire others with your agent applications
Quick Contribution Setup
# Fork & clone the repo
git clone https://github.com/YOUR_USERNAME/trpc-agent-go.git
cd trpc-agent-go
# Run tests to ensure everything works
go test ./...
go vet ./...
# Make your changes and submit a PR!
Please readCONTRIBUTING.md for detailed guidelines and coding standards.
Acknowledgements
Enterprise Validation
Special thanks to Tencent's business units including Tencent Yuanbao, Tencent Video, Tencent News, IMA, and QQ Music for their invaluable support and real-world validation. Production usage drives framework excellence!
Open Source Inspiration
Inspired by amazing frameworks like ADK, Agno, CrewAI, AutoGen, and many others. Standing on the shoulders of giants!
Star History
License
Licensed under the Apache 2.0 License - see LICENSE file for details.
