Model Context Protocol

Operate Askery from any AI agent.

A thin MCP bridge over the public API. Drop it into Claude Desktop, Cursor, or any MCP-capable client and your agent can build forms, fetch responses, and codegen Decision Engines — by name.

An AI assistant orb connected by thin lines to a constellation of typed tool icons

What it is

The Askery MCP server is a tiny stdio program that exposes the public REST API as a catalog of typed tools. The agent calls askery_generate_form with a brief; the server forwards it to POST /api/v1/forms/ai/generate with your API key; the JSON response goes back to the agent. Same API, same permissions, same audit trail as everything else you do on Askery.

Every tool maps 1:1 to a documented endpoint, so the behaviour is identical whether you use the tool, curl, or the dashboard. There's no second contract to learn.

Install

Clone the repo (or vendor the script) and drop the config into your client. Claude Desktop / Cursor / any other MCP-capable host all use the same config shape:

{
  "mcpServers": {
    "askery": {
      "command": "bunx",
      "args": ["--bun", "/path/to/askery/mcp/server.ts"],
      "env": {
        "ASKERY_API_KEY": "ak_live_..."
      }
    }
  }
}

Or with Node + tsx:

{
  "mcpServers": {
    "askery": {
      "command": "npx",
      "args": ["tsx", "/path/to/askery/mcp/server.ts"],
      "env": {
        "ASKERY_API_KEY": "ak_live_..."
      }
    }
  }
}

Mint a key at /dashboard/api-keys. Pick the scopes that match the tools you intend to expose; the server returns clean errors when a tool is called without the required scope, so you don't need to over-grant up front.

Test it

The Model Context Protocol team ships an interactive inspector. Run it pointed at the Askery server and you can list, call, and explore every tool:

bunx @modelcontextprotocol/inspector \
  bun /path/to/askery/mcp/server.ts

Tool catalog

25 tools, organised by what they touch. Required scope is shown so you know what to enable on the key.

Tool	Scope	What it does
askery_list_forms	forms:read	List forms in the workspace.
askery_get_form	forms:read	Fetch one form's full canonical definition.
askery_create_form	forms:write	Create a form from a FormDefinition.
askery_generate_form	ai:run	Generate a form from a natural-language brief.
askery_edit_form	ai:run	AI-edit a stored form. Supports preview mode.
askery_publish_form	forms:write	Publish a form (auto-generates a slug if needed).
askery_archive_form	forms:write	Archive a form (status → closed).
askery_duplicate_form	forms:write	Make a fresh draft copy of a form.
askery_list_responses	responses:read	List responses (with status, since, until, email filters and cursor pagination).
askery_get_response	responses:read	Fetch one response with answers folded in.
askery_export_responses_csv	responses:read	Pull all responses as CSV text.
askery_get_intelligence	forms:read	Read Form Intelligence config (mode, rules, decision code, sections).
askery_save_decision_code	forms:write	Save Decision Engine code (with validation).
askery_generate_decision_code	ai:run	Codegen Decision Engine code from a brief (IR → render → critique).
askery_test_decision_code	intelligence:run	Run DE code in the WASM sandbox against synthetic answers. 0 credits.
askery_regenerate_result	intelligence:run	Clear the cached AI outcome on a response and recompute.
askery_list_webhooks	forms:read	List webhook subscriptions.
askery_create_webhook	webhooks:write	Create a webhook subscription; secret returned once.
askery_delete_webhook	webhooks:write	Delete a webhook subscription.
askery_import_form	imports:run	Pull a canonical form definition from any third-party form URL.
askery_prefill_link	forms:read	Build a respondent URL with answer values pre-loaded into matching questions.
askery_workspace	workspace:read	Workspace identity, plan, credit balance.
askery_usage	workspace:read	Credit balance + recent ledger entries.
askery_audit_log	workspace:read	Workspace activity log (with filters).
askery_form_analytics	forms:read	Per-form analytics: views, starts, completions, funnel, per-question summaries.

Worked example

A typical agent conversation, after MCP is wired up:

You: Build me a 5-question NPS survey for our enterprise customers.

Agent → askery_generate_form({ brief: "...", save: true, status: "draft" })
       ← { id, slug, definition, ... }

You: Publish it.

Agent → askery_publish_form({ id: "..." })
       ← { id, status: "published", slug: "..." }

You: How are responses coming in?

Agent → askery_form_analytics({ id: "..." })
       ← { summary: { views, completions, completionRate, ... } }

You: Anyone score below 6? Show their answers.

Agent → askery_list_responses({ id, ... })
       ← filters in-app, returns the rows with answers folded in.

Errors

When a tool call fails, the server returns the API's structured error envelope verbatim. The agent sees the code, the human message, the request_id for support, and (when relevant) a docs_url. That's enough for the agent to decide whether to retry, ask you, or escalate.

Beyond MCP — the underlying API

The MCP server is a convenience. The same operations are available via the public REST API for traditional integrations (cron jobs, internal tools, BI pipelines, Lambdas). Full spec at /api/v1/openapi.json and /developers.