pnpm add @modelcontextprotocol/sdk

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

{
  "name": "workflows/invoke",
  "description": "Declarative orchestration of 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": {
    "workflows": {
      "command": "npx",
      "args": ["-y", "@dotdo/mcp-server", "--tool=workflows"],
      "env": {
        "DO_API_KEY": "undefined"
      }
    }
  }
}

# Custom GPT configuration
tools:
  - type: mcp
    server: workflows
    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=workflows'],
})

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

await client.connect(transport)

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

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

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

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

// AI model calls tool via MCP
mcp call workflows/execute

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

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

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

User: "I need to process this data"

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

Let me start..."

[Calls: mcp call workflows/execute]

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

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

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

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