Getting Started

{
  "mcpServers": {
    "do": {
      "url": "https://mcp.do",
      "apiKey": "sk_live_xxxxx"
    }
  }
}

You: "Create a new business called Acme Corp"

Claude: [uses do tool]
  script: $.Business.create({
    name: "Acme Corp",
    industry: "Technology"
  })

✓ Created business: Acme Corp (ID: acme-corp)

You: "Show me all businesses in the technology sector"

Claude: [uses do tool]
  script: db.Businesses.filter({ industry: "Technology" })

Results:
- Acme Corp (acme-corp)
- Tech Solutions (tech-solutions)
- Digital Innovations (digital-innovations)

You: "For each occupation, generate a lean canvas for all tasks"

Claude: [uses do tool]
  script: db.Occupations.forEach(occupation => {
    occupation.tasks.forEach(task => task.generateLeanCanvas())
  })

✓ Generated 2,847 lean canvases from 923 occupations

npm install @modelcontextprotocol/sdk

import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'

// Connect to MCP server
const transport = new SSEClientTransport(
  new URL('https://mcp.do'),
  {
    headers: {
      Authorization: 'Bearer sk_live_xxxxx'
    }
  }
)

const client = new Client(
  { name: 'my-app', version: '1.0.0' },
  {}
)

await client.connect(transport)

// List available tools (just 1!)
const tools = await client.listTools()
console.log(tools)
// [{ name: "do", description: "Execute code...", ... }]

// Execute code
const result = await client.callTool('do', {
  script: 'await db.list($.Business)'
})

console.log(result)
// [{ id: 'acme-corp', name: 'Acme Corp', ... }, ...]

await client.callTool('do', {
  module: `
    import { db, api } from 'sdk.do'

    export async function processOrder(customerId, items) {
      // Create order
      const order = await $.Order.create({
        customerId,
        items,
        total: items.reduce((sum, item) =>
          sum + item.price * item.quantity, 0
        )
      })

      // Charge via Stripe
      await api.stripe.charges.create({
        amount: order.total * 100,
        customer: customerId,
        description: 'Order #' + order.id
      })

      // Send confirmation
      await api.sendgrid.sendEmail({
        to: order.customer.email,
        template: 'order-confirmation',
        data: { order }
      })

      // Notify team
      await api.slack.postMessage({
        channel: '#sales',
        text: \`New order: $\${order.total}\`
      })

      return order
    }
  `,
  script: `
    await processOrder('cus_123', [
      { productId: 'prod_456', quantity: 2, price: 99.99 }
    ])
  `
})

await client.callTool('do', {
  script: `
    await db.Leads
      .filter({ createdAt: '>now-24h' })
      .forEach(async lead => {
        // Enrich with Clearbit
        const enriched = await api.clearbit.enrich({
          email: lead.email
        })

        // Update lead
        await lead.update({
          company: enriched.company,
          title: enriched.title,
          linkedin: enriched.linkedin
        })

        // Generate insights with AI
        const insights = await ai.generate({
          prompt: 'Analyze this lead: ' + JSON.stringify(enriched),
          model: 'gpt-5'
        })

        // Notify sales
        await api.slack.postMessage({
          channel: '#sales',
          text: \`New qualified lead: \${lead.name} - \${insights}\`
        })
      })
  `
})

await client.callTool('do', {
  script: `
    // For each O*NET occupation, generate lean canvas for all tasks
    await db.Occupations.forEach(async occupation => {
      await occupation.tasks.forEach(async task => {
        // Generate lean canvas with AI
        const canvas = await ai.generate({
          prompt: 'Create a lean canvas for: ' + task.description,
          model: 'claude-sonnet-4.5',
          schema: $.LeanCanvas
        })

        // Create business opportunity
        await $.Business.create({
          name: task.name,
          description: task.description,
          leanCanvas: canvas,
          sourceOccupation: occupation.id,
          sourceTask: task.id
        })
      })
    })
  `
})

await client.callTool('do', {
  script: `
    // Sync customers across platforms
    await db.Customers
      .filter({ synced: false })
      .forEach(async customer => {
        // Create in Stripe
        const stripeCustomer = await api.stripe.customers.create({
          email: customer.email,
          name: customer.name
        })

        // Add to SendGrid
        await api.sendgrid.contacts.add({
          email: customer.email,
          lists: ['newsletter']
        })

        // Create in HubSpot
        await api.hubspot.contacts.create({
          email: customer.email,
          firstname: customer.firstName,
          lastname: customer.lastName
        })

        // Update record
        await customer.update({
          synced: true,
          stripeId: stripeCustomer.id
        })
      })
  `
})

curl https://mcp.do \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "do",
      "arguments": {
        "script": "await db.list($.Business)"
      }
    },
    "id": 1
  }'

curl https://mcp.do \
  -H "Authorization: Bearer oauth_abc123" \
  -H "Content-Type: application/json" \
  -d '{ ... }'

curl https://mcp.do \
  -H "Authorization: Bearer sk_live_xxxxx" \
  -H "Content-Type: application/json" \
  -d '{ ... }'

Error: Unauthorized

Error: Write operation not allowed for anonymous users

Error: Execution timeout

Error: Rate limit exceeded