Universal Tool Calling Protocol

Modern, flexible, and scalable standard for tool integration

UTCP is a revolutionary protocol that supports HTTP, WebSocket, gRPC, and more, making AI-tool interactions incredibly simple.

Get Started Learn More

Core Features

πŸš€

Scalability

Handle large numbers of tools and providers without performance compromise

πŸ”—

Interoperability

Support for HTTP, WebSocket, gRPC, CLI, and more protocols

✨

Ease of Use

Simple and intuitive API design, developer-friendly

⚑

High Performance

Direct tool calls with low latency and high efficiency

πŸ”’

Security

Complete authentication and permission control

πŸ“

Standards

Follow industry standards for compatibility

Architecture

Understanding UTCP design philosophy and architecture

Design Philosophy

UTCP is a descriptive manual, not a middleman proxy. It tells the agent about the tool's native endpoint and how to call it, then gets out of the way.

{
  "name": "weather-api",
  "type": "http",
  "endpoint": "https://api.weather.com/v1",
  "methods": {
    "get_weather": {
      "method": "GET",
      "path": "/weather/{city}",
      "parameters": {
        "city": {
          "type": "string",
          "required": true
        }
      }
    }
  }
}

Architecture Benefits

  • Direct Calls: Eliminate middleware, reduce latency
  • Native Integration: No wrapping, use existing APIs directly
  • Efficient Transfer: Structured data, reduced overhead

Supported Provider Types

UTCP supports multiple communication protocols for different scenarios

🌐

HTTP Provider

Standard REST API calls, the most common protocol type

GET /api/v1/users
Authorization: Bearer token
Content-Type: application/json
πŸ”„

WebSocket Provider

Real-time bidirectional communication for streaming data

ws://localhost:8080/stream
{
  "type": "subscribe",
  "channel": "updates"
}
⚑

gRPC Provider

High-performance RPC calls for microservice architecture

service UserService {
  rpc GetUser(UserRequest) 
    returns (UserResponse);
}
πŸ’»

CLI Provider

Command-line tool integration for existing CLI programs

$ utcp-cli execute \
  --tool "git" \
  --args "status --porcelain"

Real-world Examples

See UTCP in action in real projects

πŸ€–

AI Assistant Tool Integration

Enable AI assistants to call various external tools and services

  • Weather Query Tool
  • Calendar Management
  • Email Sending
  • Data Analytics
πŸ”„

Automation Workflows

Build complex automation processes and workflow systems

  • CI/CD Pipeline
  • Data Processing Pipeline
  • Report Generation
  • Monitoring & Alerting
πŸŒ‰

API Gateway

Unified management and calling of different API services

  • Request Routing
  • Load Balancing
  • Authentication & Authorization
  • Monitoring & Analytics

UTCP vs MCP Comparison

Understanding the different approaches to agent-tool integration

The Middleman vs Manual Philosophies

MCP "Middleman" Approach

Positions itself as the "USB-C for AI Agents" β€” a universal adapter that all tools must plug into

  • Forces all traffic through a new protocol layer
  • Requires writing "wrappers" for existing tools
  • Needs to reinvent solutions for auth, security, and other infrastructure
  • Creates "wrapper tax": additional infrastructure overhead

UTCP "Manual" Approach

Acts as a "manual" that describes how to call tools directly using their native interfaces

  • Provides all necessary information to call native APIs directly
  • Gets out of the way after tool discovery
  • Leverages existing infrastructure for auth, security, etc.
  • Eliminates wrapper tax and infrastructure overhead

Feature Comparison

Feature MCP UTCP
Architecture Agents ↔ MCP Server ↔ Tool Agent ↔ Tool (Direct)
Integration Approach Wraps existing tools Describes how to call existing tools
Network Hops Double (Agent β†’ MCP β†’ Tool) Single (Agent β†’ Tool)
Protocol Support HTTP Streaming HTTP, WebSockets, gRPC, CLI, etc.
Implementation Complexity High (requires wrapper servers) Low (simple JSON definitions)
Performance Additional overhead due to proxy Direct, native performance

When to Choose Each Protocol

Choose MCP When:

  • You need strict standardization across all tools
  • You're building a closed ecosystem where you control all components
  • You're willing to invest in building and maintaining wrapper servers

Choose UTCP When:

  • You want to leverage existing APIs without building wrappers
  • You need to support diverse communication protocols
  • You value direct, efficient communication
  • You prioritize low implementation overhead
  • You want to minimize infrastructure costs

Quick Start Guide

Get up and running with UTCP in minutes

1

Step 1: Install SDK

Choose and install the UTCP SDK for your preferred language

TypeScript/JavaScript

npm install typescript-utcp
# or
yarn add typescript-utcp

Python

pip install python-utcp
2

Step 2: Tool Discovery

Discover tools from UTCP providers via their discovery endpoints

# Tool discovery via UTCP endpoint
import { UTCPClient } from 'typescript-utcp';

const client = new UTCPClient();
const tools = await client.discover('https://api.example.com/utcp');
console.log('Available tools:', tools);
3

Step 3: Call Tools Directly

Call tools directly using their native protocols (HTTP, WebSocket, gRPC, etc.)

HTTP Example

# Direct HTTP API call
const result = await client.callTool({
  provider: 'https://api.example.com',
  tool: 'weather-api',
  method: 'getCurrentWeather',
  parameters: { city: 'New York' }
});
console.log(result);

WebSocket Example

# Real-time WebSocket communication
const stream = await client.callStreamingTool({
  provider: 'wss://api.example.com',
  tool: 'chat-service',
  method: 'streamChat',
  parameters: { message: 'Hello!' }
});

stream.on('data', (data) => console.log(data));
4

Step 4: Provider Setup (Optional)

Create your own UTCP provider to expose tools to others

# Create UTCP provider configuration
{
  "utcp": {
    "version": "1.0",
    "name": "My Tool Provider",
    "description": "A collection of useful tools",
    "tools": {
      "weather-api": {
        "name": "Weather API",
        "description": "Get current weather data",
        "provider": {
          "type": "http",
          "base_url": "https://api.weather.com/v1",
          "authentication": {
            "type": "api_key",
            "header": "X-API-Key"
          }
        },
        "methods": {
          "getCurrentWeather": {
            "method": "GET",
            "path": "/current",
            "parameters": {
              "city": {
                "type": "string",
                "required": true,
                "description": "City name"
              }
            }
          }
        }
      }
    }
  }
}

Frequently Asked Questions

Answers to your questions about UTCP

How is UTCP different from other protocols?

+

UTCP focuses on tool calling scenarios with simpler integration and better performance.

How do I get started with UTCP?

+

Start with our quick start guide and you'll be up and running in minutes.

What programming languages does UTCP support?

+

Currently supports JavaScript, Python, Go, and other mainstream languages.