You already have a REST API. Here's how to add MCP so AI agents (and your CLI) consume it natively.

import express from 'express'
const app = express()

app.get('/api/subscriptions/:userId', async (req, res) => {
  const sub = await db.subscriptions.findOne({
    user_id: req.params.userId
  })
  if (!sub) return res.status(404).json({ error: 'No subscription found' })
  res.json({
    user_id: sub.user_id,
    plan: sub.plan,                  // 'free' | 'pro' | 'enterprise'
    status: sub.status,              // 'active' | 'past_due' | 'canceled'
    renews_at: sub.renews_at,        // ISO date
    monthly_price_usd: sub.monthly_price_usd
  })
})

app.post('/api/subscriptions/:userId/cancel', async (req, res) => {
  await db.subscriptions.update(
    { user_id: req.params.userId },
    { status: 'canceled', canceled_at: new Date() }
  )
  res.json({ ok: true })
})

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import {
  CallToolRequestSchema,
  ListToolsRequestSchema
} from '@modelcontextprotocol/sdk/types.js'

const ACME_API = 'https://api.acme.com'

const server = new Server(
  { name: 'acme-subscriptions', version: '1.0.0' },
  { capabilities: { tools: {} } }
)

// ─── Tool discovery — agents call this to see what's available ───
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'get_subscription_status',
      description:
        'Get the current subscription status for a user — plan, status, renewal date, monthly price. Use this when the user asks about their account, billing, or subscription tier.',
      inputSchema: {
        type: 'object',
        properties: {
          user_id: {
            type: 'string',
            description: 'The unique user identifier (e.g., "u-1234")'
          }
        },
        required: ['user_id']
      }
    },
    {
      name: 'cancel_subscription',
      description: 'Cancel a user subscription immediately. Use with caution — this is destructive.',
      inputSchema: {
        type: 'object',
        properties: {
          user_id: { type: 'string', description: 'The user identifier' }
        },
        required: ['user_id']
      }
    }
  ]
}))

// ─── Tool execution — agents call this to invoke a tool ───
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params

  if (name === 'get_subscription_status') {
    const { user_id } = args as { user_id: string }
    const sub = await fetch(`${ACME_API}/api/subscriptions/${user_id}`).then(r => r.json())
    return {
      content: [{ type: 'text', text: JSON.stringify(sub, null, 2) }]
    }
  }

  if (name === 'cancel_subscription') {
    const { user_id } = args as { user_id: string }
    await fetch(`${ACME_API}/api/subscriptions/${user_id}/cancel`, { method: 'POST' })
    return {
      content: [{ type: 'text', text: `Subscription canceled for ${user_id}` }]
    }
  }

  throw new Error(`Unknown tool: ${name}`)
})

// ─── Boot the server over stdio ───
const transport = new StdioServerTransport()
await server.connect(transport)

# 1. Client says hello, server responds with capabilities
→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05",...}}
← {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2024-11-05","capabilities":{"tools":{}}}}

# 2. Client asks what tools exist
→ {"jsonrpc":"2.0","id":2,"method":"tools/list"}
← {"jsonrpc":"2.0","id":2,"result":{"tools":[{"name":"get_subscription_status",...}]}}

# 3. Client invokes a tool
→ {"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_subscription_status","arguments":{"user_id":"u-1234"}}}
← {"jsonrpc":"2.0","id":3,"result":{"content":[{"type":"text","text":"{\"user_id\":\"u-1234\",\"plan\":\"pro\",...}"}]}}

import Anthropic from '@anthropic-ai/sdk'
import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'

const anthropic = new Anthropic()

// 1. Connect to the MCP server (spawns it as a subprocess)
const mcpTransport = new StdioClientTransport({
  command: 'node',
  args: ['./mcp-server/dist/index.js']
})
const mcp = new Client(
  { name: 'acme-agent', version: '1.0.0' },
  { capabilities: {} }
)
await mcp.connect(mcpTransport)

// 2. Get the tool schemas from MCP and convert to Anthropic's format
const { tools: mcpTools } = await mcp.listTools()
const anthropicTools = mcpTools.map(t => ({
  name: t.name,
  description: t.description,
  input_schema: t.inputSchema
}))

// 3. Run the Claude tool-use loop
let messages = [
  { role: 'user', content: "What's u-1234 paying us per month?" }
]

while (true) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-5',
    max_tokens: 1024,
    tools: anthropicTools,
    messages
  })

  if (response.stop_reason === 'end_turn') {
    console.log(response.content[0].text)
    break
  }

  if (response.stop_reason === 'tool_use') {
    const toolUse = response.content.find(b => b.type === 'tool_use')

    // Call the MCP server to actually execute the tool
    const result = await mcp.callTool({
      name: toolUse.name,
      arguments: toolUse.input
    })

    // Feed the result back to Claude
    messages.push({ role: 'assistant', content: response.content })
    messages.push({
      role: 'user',
      content: [{
        type: 'tool_result',
        tool_use_id: toolUse.id,
        content: result.content[0].text
      }]
    })
  }
}

#!/usr/bin/env node
import { Command } from 'commander'
import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'

async function withMCPClient<T>(fn: (mcp: Client) => Promise<T>): Promise<T> {
  const transport = new StdioClientTransport({
    command: 'node',
    args: [`${process.env.HOME}/.acme/mcp-server/index.js`]
  })
  const mcp = new Client(
    { name: 'acme-cli', version: '1.0.0' },
    { capabilities: {} }
  )
  await mcp.connect(transport)
  try {
    return await fn(mcp)
  } finally {
    await mcp.close()
  }
}

const program = new Command()

program
  .command('subscription')
  .description('Subscription commands')

program.command('subscription status <userId>')
  .description('Show subscription status for a user')
  .action(async (userId) => {
    await withMCPClient(async (mcp) => {
      const result = await mcp.callTool({
        name: 'get_subscription_status',
        arguments: { user_id: userId }
      })
      const sub = JSON.parse(result.content[0].text)
      // Pretty-print for terminal
      console.log(`plan:              ${sub.plan}`)
      console.log(`status:            ${sub.status}`)
      console.log(`renews_at:         ${sub.renews_at}`)
      console.log(`monthly_price_usd: $${sub.monthly_price_usd}.00`)
    })
  })

program.command('subscription cancel <userId>')
  .action(async (userId) => {
    await withMCPClient(async (mcp) => {
      await mcp.callTool({
        name: 'cancel_subscription',
        arguments: { user_id: userId }
      })
      console.log(`✓ Subscription canceled for ${userId}`)
    })
  })

program.parse()