What is MCP

Model Context Protocol (MCP) is an open standard for connecting AI assistants to external tools and data sources. Instead of building custom integrations for each AI tool, you run a single MCP server that any compatible client can connect to. The server advertises its resources (data it can read) and tools (actions it can perform), and the client presents them to the LLM at inference time.

Package

The MCP server lives in packages/mcp and runs as a standalone Node.js process. It acts as a thin adapter between MCP clients and the wrk!ng REST API -- the server itself holds no state.

Configuration

Setup

{
  "mcpServers": {
    "wrking": {
      "command": "npx",
      "args": ["tsx", "packages/mcp/src/index.ts"],
      "env": {
        "WRKING_API_URL": "https://api.wrk.ing",
        "WRKING_API_KEY": "wrk_your_key_here"
      }
    }
  }
}

{
  "mcpServers": {
    "wrking": {
      "command": "npx",
      "args": ["tsx", "packages/mcp/src/index.ts"],
      "env": {
        "WRKING_API_URL": "https://api.wrk.ing",
        "WRKING_API_KEY": "wrk_your_key_here"
      }
    }
  }
}

Transports

stdio (default)

The default mode for local integrations. The MCP client spawns the server as a child process and communicates over stdin/stdout. Use this with Cursor, Claude Desktop, and CLI-based agent frameworks.

WRKING_API_KEY=wrk_abc123... npx tsx packages/mcp/src/index.ts

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

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "packages/mcp/src/index.ts"],
  env: { WRKING_API_KEY: "wrk_abc123..." },
});
const client = new Client({ name: "my-agent" });
await client.connect(transport);

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

params = StdioServerParameters(
    command="npx",
    args=["tsx", "packages/mcp/src/index.ts"],
    env={"WRKING_API_KEY": "wrk_abc123..."},
)
async with stdio_client(params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()

Streamable HTTP

For remote or hosted deployments where multiple clients connect over the network. The server exposes a single /mcp endpoint that handles POST (JSON-RPC requests), GET (SSE streams), and DELETE (session termination).

MCP_TRANSPORT=http MCP_PORT=3002 WRKING_API_KEY=wrk_abc123... \
  npx tsx packages/mcp/src/index.ts

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("http://localhost:3002/mcp")
);
const client = new Client({ name: "my-agent" });
await client.connect(transport);

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client("http://localhost:3002/mcp") as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()

Clients connect to http://localhost:3002/mcp (or your deployed URL). Each client gets an independent session managed via the mcp-session-id header.

Resources

Resources are read-only data that AI agents can access. The server exposes both static collections and parameterized resources for individual records.

Static resources

Parameterized resources

Clients can call list on parameterized resources to discover all available instances (e.g. all workflow IDs and names), then fetch a specific one by URI.

Tools

Tools expose actions the AI agent can perform. Each tool has a typed input schema, a description, and behavioral annotations (readOnlyHint, destructiveHint) so clients present them appropriately.

Read-only tools

Write tools

Authentication

The MCP server authenticates to the wrk!ng API using an organization-scoped API key. Create and manage keys through the API:

API keys use the format wrk_ followed by 64 hex characters. The first 12 characters serve as a visible prefix for identification. See Getting started for details on creating keys.

Event-driven AI loop

The complete automation loop

The MCP server, webhooks, and event system form a closed loop that enables fully automated, LLM-driven workflows.

1. A user action fires a lifecycle event
2. The webhook dispatcher delivers the event to your AI consumer
3. Your AI agent processes the event and decides on an action
4. The agent calls a wrk!ng MCP tool to execute the action
5. The action fires a new event, continuing the loop

This enables fully automated, LLM-driven workflows where AI reviews submissions, analyzes data, makes recommendations, and takes action at every interaction point in the platform.