MCP Integration

Proxagora exposes a Model Context Protocol (MCP) server that wraps the entire API catalog as callable tools. Any MCP-compatible client — Claude Desktop, cursor, LangChain, custom agents — can connect and call any Proxagora API without manual tool definitions.

Status: MCP integration is in active development. The endpoint is live and functional, but the tool list may change as the catalog grows.

MCP Server URL

https://proxagora.com/mcp

This is a standard MCP HTTP server. It responds to the MCP protocol's standard endpoints for tool listing and tool calling.

What You Get

When you connect an MCP client to Proxagora's /mcp endpoint, it receives:

• A tool for each API in the catalog (e.g. proxagora_ip_geo, proxagora_domain_reputation)
• Tool descriptions pulled from the API's description field — used by LLMs to decide when to call which tool
• Input schemas derived from the API's params_schema
• Automatic payment handling (the MCP server manages x402 with a configured wallet)

Claude Desktop Setup

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "proxagora": {
      "command": "npx",
      "args": ["-y", "@proxagora/mcp-client"],
      "env": {
        "PROXAGORA_WALLET_KEY": "0x_your_base_wallet_private_key",
        "PROXAGORA_NETWORK": "base-sepolia"
      }
    }
  }
}

npm install -g @proxagora/mcp-client

After restarting Claude Desktop, you'll see Proxagora tools available in the tool selector.

Direct MCP Connection (HTTP)

For agents or frameworks that support MCP over HTTP:

from mcp import ClientSession
from mcp.client.http import http_client

async with http_client("https://proxagora.com/mcp") as client:
    async with ClientSession(*client) as session:
        await session.initialize()
        
        # List available tools
        tools = await session.list_tools()
        print([t.name for t in tools.tools])
        # ['proxagora_ip_geo', 'proxagora_domain_reputation', ...]
        
        # Call a tool
        result = await session.call_tool(
            "proxagora_ip_geo",
            arguments={"ip": "8.8.8.8"},
            # Payment header required for paid tools
        )

LangChain Integration

from langchain_mcp import MCPToolkit
from langchain.agents import create_openai_functions_agent

# Connect to Proxagora MCP server
toolkit = MCPToolkit(server_url="https://proxagora.com/mcp")
tools = toolkit.get_tools()

# Use in a LangChain agent
agent = create_openai_functions_agent(
    llm=llm,
    tools=tools,
    prompt=prompt
)

Manual Tool Definition (without MCP)

If you prefer explicit tool definitions without MCP:

from langchain.tools import StructuredTool
from pydantic import BaseModel
import requests

class IpGeoInput(BaseModel):
    ip: str

def ip_geo_lookup(ip: str, payment_header: str) -> dict:
    resp = requests.post(
        "https://proxagora.com/api/ip-geo",
        json={"ip": ip},
        headers={"X-Payment": payment_header}
    )
    return resp.json()

ip_geo_tool = StructuredTool.from_function(
    func=ip_geo_lookup,
    name="ip_geo",
    description="Look up geographic location, ASN, and carrier data for any IPv4/IPv6 address",
    args_schema=IpGeoInput,
    return_direct=False
)

Define one wrapper tool that reads the catalog and dispatches dynamically:

class ProxagoraInput(BaseModel):
    api_id: str
    params: dict

def call_any_proxagora_api(api_id: str, params: dict) -> dict:
    """Call any Proxagora API. Use /api/discover to find available APIs and their IDs."""
    # ... x402 payment handling here
    pass

proxagora_tool = StructuredTool.from_function(
    func=call_any_proxagora_api,
    name="proxagora",
    description="""Call any API in the Proxagora marketplace.
    First call GET https://proxagora.com/api/discover to see available APIs.
    Then call this tool with the api_id and required params.""",
    args_schema=ProxagoraInput
)

Tool Naming Convention

MCP tools from Proxagora follow this pattern: proxagora_{api_id_with_underscores}

Examples:

• ip-geo → proxagora_ip_geo
• domain-reputation → proxagora_domain_reputation
• email-validation → proxagora_email_validation
• serp-results → proxagora_serp_results

Payment in MCP Context

The MCP server handles x402 payment transparently if you configure a wallet key in the client. Each tool call triggers the payment flow automatically.

Configure via environment variables:

PROXAGORA_WALLET_KEY=0x_private_key   # Base wallet for x402 payments
PROXAGORA_NETWORK=base-sepolia        # or base-mainnet for production
PROXAGORA_MPP_TOKEN=mpp_...           # Alternative: Stripe MPP token

If neither is configured, the MCP server returns the tool result as a 402 payment instruction — useful for testing.

Roadmap

• [ ] MCP over stdio (for local process connections)
• [ ] Per-tool payment authorization (approve individual calls)
• [ ] Streaming tool responses for long-running APIs
• [ ] MCP resource endpoints for the API catalog
• [ ] OAuth-based identity for MCP sessions

Status updates: Proxagora status page