Agent Docs

Getting Started

Three steps to your first agent interaction:

{
  "jsonrpc": "2.0",
  "method": "a2a/sendMessage",
  "id": "1",
  "params": {
    "skill": "live_prices",
    "message": {
      "role": "user",
      "parts": [{ "type": "text", "text": "Get prices" }]
    }
  }
}

const res = await fetch("https://rmassistanthub.io/api/a2a", {
  method: "POST",
  headers: { "Content-Type": "application/json", "Authorization": "Bearer JWT" },
  body: JSON.stringify({ jsonrpc: "2.0", method: "a2a/sendMessage", id: "1",
    params: { skill: "live_prices", message: { role: "user", parts: [{ type: "text", text: "prices" }] } } }),
});
const data = await res.json();

import aiohttp, asyncio
async def main():
    async with aiohttp.ClientSession() as s:
        async with s.post("https://rmassistanthub.io/api/a2a",
            json={"jsonrpc":"2.0","method":"a2a/sendMessage","id":"1",
                "params":{"skill":"live_prices","message":{"role":"user","parts":[{"type":"text","text":"prices"}]}}},
            headers={"Authorization":"Bearer JWT"}) as r:
            print(await r.json())
asyncio.run(main())

curl -X POST https://rmassistanthub.io/api/a2a \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT" \
  -d '{"jsonrpc":"2.0","method":"a2a/sendMessage","id":"1","params":{"skill":"live_prices","message":{"role":"user","parts":[{"type":"text","text":"Get prices"}]}}}'

A2A Protocol Reference

Google-compliant Agent-to-Agent protocol over JSON-RPC 2.0.

Discovery

JSON-RPC Methods

Available Skills

sendMessage Params

{
  "skill": "live_prices",         // skill ID (see table above)
  "sessionId": "optional-uuid",   // groups tasks into sessions
  "message": {
    "role": "user",
    "parts": [
      { "type": "text", "text": "query text" },
      { "type": "data", "data": { "key": "value" } }
    ]
  },
  "acceptPayment": {              // for premium skills
    "txHash": "0x..."             // USDC tx hash on Base
  }
}

x402 Payment Flow

Premium skills are gated with the x402 HTTP payment protocol. USDC on Base (chain 8453).

402 Response Headers

Retry with Payment Proof

// After sending USDC on Base, retry with tx hash:
headers: {
  "x-402-tx-hash": "0xabc123...",
  "Authorization": "Bearer YOUR_JWT"
}

SDK Auto-Payment (JS)

Not on npm yet — this will be @rmassistanthub/sdk. Do not install @assistant-hub/sdk: that name belongs to an unrelated project. Until it ships, send the payment and the x-402-tx-hash header yourself as shown above.

import { X402Client } from "@rmassistanthub/sdk";
const x402 = new X402Client({ baseUrl: "https://rmassistanthub.io", privateKey: "0x..." });
const result = await x402.sendTask("crypto_research", { question: "BTC outlook?" });
// Automatically intercepts 402, signs USDC tx, retries

Receipts

Every verified payment generates a cryptographic receipt at GET /api/receipts with HMAC-SHA256 integrity hash.

Webhooks

Receive real-time HTTPS notifications when events occur.

Supported Events

Registration

POST /api/webhooks
Authorization: Bearer YOUR_JWT

{
  "url": "https://your-server.com/webhook",
  "events": ["task_completed", "payment_confirmed"]
}

Response: { id, url, events, secret, note }

Save the secret — it's shown only once. Max 10 webhooks per user.

Payload Format

{
  "event": "task_completed",
  "payload": { "taskId": "...", "skill": "live_prices", "status": "completed" },
  "timestamp": 1709145600000,
  "webhookId": "wh_..."
}

Signature Verification

Every delivery includes an X-Hub-Signature-256 header. Verify with HMAC-SHA256:

// Node.js verification example
const crypto = require('crypto');
function verify(body, secret, signature) {
  const expected = 'sha256=' + crypto.createHmac('sha256', secret)
    .update(body).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature), Buffer.from(expected)
  );
}

Delivery Policy

• Up to 3 delivery attempts with exponential backoff
• 5-second timeout per attempt
• HTTPS required for webhook URLs
• View delivery log: GET /api/webhooks/:id/deliveries
• Send test event: POST /api/webhooks/:id/test

Sandbox / Testnet Mode

Test all skills with virtual credits — no real blockchain transactions.

SDKs & Tools

LangChain Integration

The fastest way to add crypto intelligence to any LangChain / LangGraph agent. Two approaches — pick whichever fits your stack.

Option A: Official Toolkit (Recommended)

Pre-built tools with human-readable names, typed schemas, and retry logic. No MCP dependency.

pip install langchain-assistanthub==0.1.2 langchain-mcp-adapters

from langchain_assistanthub import AssistantHubToolkit
from langgraph.prebuilt import create_react_agent

# Option 1: From env var (recommended)
toolkit = AssistantHubToolkit.from_env()  # reads ASSISTANT_HUB_API_KEY

# Option 2: Explicit API key
toolkit = AssistantHubToolkit.from_api_key("ahk_your_key")

# Option 3: Anonymous (10 free calls/day, no key needed)
toolkit = AssistantHubToolkit()

tools = toolkit.get_tools()
agent = create_react_agent(model, tools)
result = agent.invoke({"messages": [
    {"role": "user", "content": "What's the risk score for SOL and current Fear & Greed?"}
]})

npm install langchain-assistanthub @langchain/core

import { AssistantHubToolkit } from "langchain-assistanthub";

const toolkit = new AssistantHubToolkit({ apiKey: "your-hub-api-key" });
const tools = toolkit.getTools();
// Plug into any LangGraph / LangChain agent

Toolkit Options

Available Tools (13)

* Requires enable_price_feed=True and websockets package. Premium daily limit is unlimited. Premium tools also accept x402 pay-per-call (1.00 USDC).

from langchain_assistanthub import AssistantHubToolkit
from langgraph.prebuilt import create_react_agent

# Auto-discover all tools via MCP protocol
tools = await AssistantHubToolkit.from_mcp(api_key="ahk_your_key")
agent = create_react_agent(model, tools)

from langchain_assistanthub import AssistantHubMCPClient

client = AssistantHubMCPClient.from_api_key("ahk_your_key")
tools = await client.get_tools()
# tools is a list of LangChain BaseTool instances

import { getMcpTools } from "langchain-assistanthub";
const tools = await getMcpTools({ apiKey: "your-jwt" });
// Auto-discovers all tools from the MCP server

x402 Pay-Per-Call (No Subscription Needed)

Free tools work instantly with any auth. Premium tools return HTTP 402 with payment headers — your agent pays per call with USDC on Base:

# Toolkit approach — premium tools return payment info as structured error
toolkit = AssistantHubToolkit(api_key="your-key")
tools = toolkit.get_tools()
# Premium tools that require payment will return:
# {"error": "payment_required", "payment": {"x-402-amount": "1.00", ...}}

# JWT approach — Pro/Premium subscribers get unlimited premium calls
toolkit = AssistantHubToolkit(api_key="your-pro-jwt")  # all tools work

See Showcase Notebooks for 3 runnable examples: sentiment trader, backtest optimizer, and live monitor.

Showcase Notebooks

Copy-paste-run examples that demonstrate full agent workflows. Each script is self-contained — just set your API key and go.

MCP Connect — Claude Desktop & Cursor

Add Assistant Hub tools directly to Claude Desktop, Cursor, or any MCP-compatible client.

Claude Desktop

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "assistanthub": {
      "url": "https://rmassistanthub.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_JWT_TOKEN"
      }
    }
  }
}

Config file location: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)

Cursor

In Cursor Settings → MCP Servers → Add Server:

Available Tools

Once connected, these tools appear in your AI assistant:

Quick Verify

# Test MCP discovery:
curl https://rmassistanthub.io/.well-known/mcp.json | jq .

# Test Streamable HTTP transport:
curl -X POST https://rmassistanthub.io/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"initialize","id":"1","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

Interactive API Explorer

Try endpoints directly from your browser. Sandbox mode uses virtual credits.