pnpm add @modelcontextprotocol/sdk

{
  "mcpServers": {
    "integrations": {
      "command": "npx",
      "args": ["-y", "@dotdo/mcp-server"],
      "env": {
        "DO_API_KEY": "your-api-key"
      }
    }
  }
}

{
  "name": "integrations/invoke",
  "description": "Connect external Application Programming Interface (API)s and systems to business processes",
  "inputSchema": {
    "type": "object",
    "properties": {
      "operation": {
        "type": "string",
        "description": "Operation to perform"
      },
      "parameters": {
        "type": "object",
        "description": "Operation parameters"
      }
    },
    "required": ["operation"]
  }
}

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "integrations": {
      "command": "npx",
      "args": ["-y", "@dotdo/mcp-server", "--tool=integrations"],
      "env": {
        "DO_API_KEY": "undefined"
      }
    }
  }
}

# Custom GPT configuration
tools:
  - type: mcp
    server: integrations
    operations:
      - invoke
      - query
      - execute

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

const transport = new StdioClientTransport({
  command: 'npx',
  args: ['-y', '@dotdo/mcp-server', '--tool=integrations'],
})

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

await client.connect(transport)

// Call tool
const result = await client.callTool({
  name: 'integrations/invoke',
  arguments: {
    operation: 'integrations',
    parameters: {},
  },
})

{
  "tools": [
    {
      "name": "integrations/invoke",
      "description": "Invoke integrations.do",
      "inputSchema": {
        /* ... */
      }
    },
    {
      "name": "integrations/query",
      "description": "Query integrations.do resources",
      "inputSchema": {
        /* ... */
      }
    },
    {
      "name": "integrations/status",
      "description": "Check integrations.do status",
      "inputSchema": {
        /* ... */
      }
    }
  ]
}

{
  "resources": [
    {
      "uri": "integrations://config",
      "name": "Integrations Configuration",
      "mimeType": "application/json"
    },
    {
      "uri": "integrations://docs",
      "name": "Integrations Documentation",
      "mimeType": "text/markdown"
    }
  ]
}

{
  "prompts": [
    {
      "name": "integrations-quick-start",
      "description": "Quick start guide for integrations.do",
      "arguments": []
    },
    {
      "name": "integrations-best-practices",
      "description": "Best practices for integrations.do",
      "arguments": []
    }
  ]
}

// AI model calls tool via MCP
mcp call integrations/call

// Call with parameters
await mcp.callTool('integrations/invoke', {
  operation: 'process',
  parameters: {
    // Operation-specific parameters
  },
  options: {
    timeout: 30000,
  },
})

try {
  const result = await mcp.callTool('integrations/invoke', {
    operation: 'process',
  })
  return result
} catch (error) {
  if (error.code === 'TOOL_NOT_FOUND') {
    console.error('Integrations tool not available')
  } else {
    throw error
  }
}

// AI agent uses integrations.do in workflow
const workflow = {
  steps: [
    {
      tool: 'integrations/invoke',
      operation: 'analyze',
      input: 'user-data',
    },
    {
      tool: 'integrations/process',
      operation: 'transform',
      input: 'analysis-result',
    },
  ],
}

User: "I need to process this data"

AI: "I'll use the integrations tool to:
1. Validate the data format
2. Process it through integrations.do
3. Return the results

Let me start..."

[Calls: mcp call integrations/call]

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

const server = new Server(
  {
    name: 'integrations-server',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
      resources: {},
      prompts: {},
    },
  }
)

// Register tool
server.setRequestHandler('tools/call', async (request) => {
  if (request.params.name === 'integrations/invoke') {
    // Handle integrations.do operation
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result),
        },
      ],
    }
  }
})

const transport = new StdioServerTransport()
await server.connect(transport)