MCP

npm install @x402/mcp @x402/evm @modelcontextprotocol/sdk

import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { createx402MCPClient } from "@x402/mcp";
import { WalletAccountEvm } from "@tetherto/wdk-wallet-evm";

// WDK wallet as the payment signer
const account = new WalletAccountEvm(process.env.SEED_PHRASE, {
  provider: "https://rpc.plasma.to",
});

// Create x402-enabled MCP client
const mcpClient = createx402MCPClient({
  name: "my-agent",
  version: "1.0.0",
  schemes: [
    { network: "eip155:9745", client: new ExactEvmScheme(account) },
  ],
  autoPayment: true,
  onPaymentRequested: async (context) => {
    const price = context.paymentRequired.accepts[0];
    console.log(`Payment: ${price.amount} on ${price.network} for ${context.toolName}`);
    return true; // approve
  },
});

// Connect to MCP server
const transport = new SSEClientTransport(new URL("http://localhost:4022/sse"));
await mcpClient.connect(transport);

// Discover available tools
const { tools } = await mcpClient.listTools();

for (const tool of tools) {
  console.log(`${tool.name}: ${tool.description}`);
}

// Call a tool — payment happens automatically if required
const result = await mcpClient.callTool("get-weather", { city: "Dubai" });

console.log(result.content[0]?.text);

// Check if payment was made
if (result.paymentMade) {
  console.log("Settled:", result.paymentResponse.transaction);
}

const mcpClient = createx402MCPClient({
  // ...
  autoPayment: false, // require explicit approval
  onPaymentRequested: async (context) => {
    const price = context.paymentRequired.accepts[0];
    const amount = Number(price.amount) / 1e6; // USDT0 has 6 decimals

    // Reject anything over $1
    if (amount > 1.0) {
      console.log(`Rejected: $${amount} is too expensive`);
      return false;
    }

    return true;
  },
});

import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Convert MCP tools to OpenAI function calling format
const { tools } = await mcpClient.listTools();

const openaiTools: OpenAI.ChatCompletionTool[] = tools.map((tool) => ({
  type: "function",
  function: {
    name: tool.name,
    description: tool.description || "",
    parameters: tool.inputSchema as Record<string, unknown>,
  },
}));

// Let the LLM decide which tools to call
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "What's the weather in Dubai?" }],
  tools: openaiTools,
  tool_choice: "auto",
});

// Execute tool calls via MCP (payment handled automatically)
for (const toolCall of response.choices[0].message.tool_calls || []) {
  const args = JSON.parse(toolCall.function.arguments);
  const result = await mcpClient.callTool(toolCall.function.name, args);
  console.log(result.content[0]?.text);
}

import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

// Convert MCP tools to Anthropic format
const { tools } = await mcpClient.listTools();

const anthropicTools = tools.map((tool) => ({
  name: tool.name,
  description: tool.description || "",
  input_schema: tool.inputSchema,
}));

const response = await anthropic.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "What's the weather in Dubai?" }],
  tools: anthropicTools,
});

// Execute tool calls via MCP
for (const block of response.content) {
  if (block.type === "tool_use") {
    const result = await mcpClient.callTool(block.name, block.input);
    console.log(result.content[0]?.text);
  }
}

const mcpClient = createx402MCPClient({
  name: "my-agent",
  version: "1.0.0",
  schemes: [
    { network: "eip155:9745", client: new ExactEvmScheme(plasmaAccount) },
    { network: "eip155:988", client: new ExactEvmScheme(stableAccount) },
  ],
  autoPayment: true,
});

await mcpClient.close();