DCAP | Dynamic Capability Acquisition Protocol

[boorich]

Pre-submission Checklist

• This post follows the MCP community guidelines

What would you like to share?

Hey folks,

I have been working on discoverability of MCP tools for a while now and would like to invite you taking a look at what I have by now:

• Demo Video

(first half of the video is intro for people who don't nerd about MCP all day long)

What:
A specification and a data stream (ws://159.89.110.236:10191) that broadcasts tool invocations and returns useful data to clients plus some tooling here and there so it is easy to try and implement.

How:
While building a couple of MCP servers in my day job and learned that it can be quite hard to find and use tools automagically. Especially since there is more and more x402 payment gating in the mix, which turns out to be very exciting (can monetize) on one hand, but, at the same time, more complex on the other hand (stuff breaks all the time).

So, I started solving some my own problems like this:
First I made the message spec, so tools can expose themselves when they run via UDP. Then I made a little relay that translates those and serves a websocket so everyone can consume them and broadcast there. After that I enabled some servers that I am working on to use this and extended the inspector so it can handle that as well (if anyone wants that inspector-pro I can push).

After I saw messages coming in I built a couple of clients to consume the stream and figured out that they can now autonomously get new tools beyond what they have in their MCP.json as you see in the video. The idea is that they keep using their tool selection algorithm as is but reach out into a more expansive set of tools across servers. My hypothesis is, that if a client can find and use the right tools on demand, they should be able to accomplish their goals more efficiently and with less wasteful LLM calls on the way.

However, when x402 hit some weeks ago, I had to extend the protocol to handle payments which worked fine and that's where I am right now.

Challenges:
Getting the concept right and setting it all up was a bit tricky, but now that it is working the biggest challenge is to get more real traffic onto the protocol. As I said, this is open and free and no strings attached whatsoever. You can use it and do whatever you want with it. MIT all the way.

Examples:
If you feel like adding this to your tool calls, here are some examples that should help getting started:

import socket
import json
import time


def send_dcap_perf_update(tool_name: str, exec_ms: int, success: bool):
    """
    Send DCAP v2.4 perf_update message to the relay via UDP.
    
    Args:
        tool_name: Name of the MCP tool that was executed
        exec_ms: Execution time in milliseconds
        success: Whether the tool execution succeeded
    """
    try:
        # DCAP configuration (from environment or hardcoded)
        DCAP_RELAY_HOST = "127.0.0.1"  # or your relay's IP
        DCAP_RELAY_PORT = 10191
        SERVER_ID = "my-mcp-server"
        
        # Build DCAP message (spec-compliant)
        message = {
            "v": 2,                          # Protocol version
            "ts": int(time.time()),          # Unix timestamp
            "t": "perf_update",              # Message type
            "sid": SERVER_ID,                # Server identifier
            "tool": tool_name,
            "exec_ms": exec_ms,
            "success": success,
            "ctx": {
                "caller": "unknown-agent",   # Agent identifier (if known)
                "payer": "0x0000...",        # Wallet address (if using x402)
                "args": {}                   # Anonymized args (optional)
            }
        }
        
        # Send via UDP
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        message_bytes = json.dumps(message).encode('utf-8')
        sock.sendto(message_bytes, (DCAP_RELAY_HOST, DCAP_RELAY_PORT))
        sock.close()
        
        print(f"🪱 DCAP broadcast sent: {tool_name}")
        
    except Exception as e:
        # Fail silently - never break tool execution
        print(f"⚠️ DCAP broadcast failed: {e}")


# Usage in your MCP tool handler:
def my_mcp_tool(args):
    start_ms = time.time() * 1000
    
    try:
        # Your tool logic here
        result = do_work(args)
        
        exec_time = int(time.time() * 1000 - start_ms)
        send_dcap_perf_update("my_tool_name", exec_time, True)
        
        return result
    except Exception as e:
        exec_time = int(time.time() * 1000 - start_ms)
        send_dcap_perf_update("my_tool_name", exec_time, False)
        raise

import dgram from 'dgram';

interface DCAPPerfUpdate {
  toolName: string;
  execMs: number;
  success: boolean;
  args?: Record<string, any>;
}

function sendDCAPPerfUpdate(options: DCAPPerfUpdate): void {
  try {
    // DCAP configuration (from environment or hardcoded)
    const DCAP_RELAY_HOST = process.env.DCAP_RELAY_HOST || '127.0.0.1';
    const DCAP_RELAY_PORT = parseInt(process.env.DCAP_RELAY_PORT || '10191');
    const SERVER_ID = process.env.DCAP_SERVER_ID || 'my-mcp-server';
    
    // Build DCAP message (spec-compliant)
    const message = {
      v: 2,                              // Protocol version
      ts: Math.floor(Date.now() / 1000), // Unix timestamp
      t: 'perf_update',                  // Message type
      sid: SERVER_ID,                    // Server identifier
      tool: options.toolName,
      exec_ms: options.execMs,
      success: options.success,
      ctx: {
        caller: 'unknown-agent',         // Agent identifier (if known)
        payer: '0x0000...',              // Wallet address (if using x402)
        args: options.args || {}         // Anonymized args (optional)
      }
    };
    
    // Send via UDP
    const client = dgram.createSocket('udp4');
    const messageBuffer = Buffer.from(JSON.stringify(message), 'utf-8');
    
    client.send(messageBuffer, 0, messageBuffer.length, DCAP_RELAY_PORT, DCAP_RELAY_HOST, (error) => {
      if (error) {
        console.error(`⚠️ DCAP broadcast failed: ${error.message}`);
      } else {
        console.log(`🪱 DCAP broadcast sent: ${options.toolName}`);
      }
      client.close();
    });
    
  } catch (error) {
    // Fail silently - never break tool execution
    console.error(`⚠️ DCAP error: ${error}`);
  }
}

// Usage in your MCP tool handler:
async function myMCPTool(args: any) {
  const startMs = Date.now();
  
  try {
    // Your tool logic here
    const result = await doWork(args);
    
    const execTime = Date.now() - startMs;
    sendDCAPPerfUpdate({ toolName: 'my_tool_name', execMs: execTime, success: true });
    
    return result;
  } catch (error) {
    const execTime = Date.now() - startMs;
    sendDCAPPerfUpdate({ toolName: 'my_tool_name', execMs: execTime, success: false });
    throw error;
  }
}

Learned:
Tool Discovery is required to scale the agent-first internet and everyone building MCP server could help getting this right. (I don't think I am getting it all right yet, but hopefully people better than me are around to chip in their expertise.)

Contribution:
The easiest way to contribute is to broadcast your invocations to the stream. However, if you feel like working on this more seriously, you can definitely do so by forking and adding your ideas. Or you can just open issues and I do.

I would love to hear all of your thoughts and maybe see some messages on the relay soon.

Thanks for reading!

Relevant Links

No response