go-utcp

go-utcp is the Go implementation of the Universal Tool Calling Protocol (UTCP). It provides a single client-side abstraction for discovering, describing, searching, invoking, and streaming tools exposed through heterogeneous providers and transports.

The project is designed for applications that need to connect an agent, service, workflow engine, or automation runtime to many kinds of tools without coupling application logic to every transport individually.

Table of contents

• What is UTCP?
• Why go-utcp?
• Core concepts
• Features
• Requirements
• Installation
• Quick start
• Architecture
• Providers
• Provider configuration
• Variables and secrets
• Tool discovery
• Searching tools
• Calling tools
• Streaming
• Dynamic provider registration
• Transport matrix
• HTTP
• OpenAPI
• CLI
• SSE
• Streamable HTTP
• WebSocket
• gRPC
• GraphQL
• TCP
• UDP
• WebRTC
• MCP
• Text providers
• CodeMode
• Security
• Error handling
• Context cancellation
• Testing
• Examples
• Development
• Project layout
• Performance
• Troubleshooting
• FAQ
• Contributing
• License

What is UTCP?

UTCP is a protocol and architectural approach for exposing tools to software that needs to call them. A tool has metadata describing what it does, how it should be called, and which provider exposes it. A client can discover that metadata and invoke the tool without needing to implement provider-specific business logic at every call site.

The important idea is separation of concerns:

1. Providers expose capabilities.
2. The UTCP client discovers those capabilities.
3. A local repository stores tool metadata.
4. Search selects relevant tools.
5. The client dispatches calls to the appropriate transport.
6. The provider performs the operation.
7. Results are returned through one Go API.

This makes UTCP useful as infrastructure for AI agents, automation platforms, developer tools, integration services, and ordinary backend applications.

Why go-utcp?

A typical integration layer accumulates one SDK per remote system. An application may need separate code for HTTP APIs, CLIs, gRPC services, GraphQL APIs, WebSockets, MCP servers, and local utilities. go-utcp provides a common abstraction above those transports.

Instead of writing application logic such as:

if provider is HTTP -> use HTTP client
if provider is gRPC -> use gRPC client
if provider is MCP -> use MCP SDK
if provider is CLI -> start process

your application can work with:

result, err := client.CallTool(ctx, "provider.tool", args)

The transport-specific behavior stays below the tool-calling API.

Core concepts

Provider