Trpc Agent Go

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 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
• 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)

Production Observability

// Start Langfuse integration
clean, _ := langfuse.Start(ctx)
defer clean(ctx)