# MCP Durable Tasks Backend (`neon_innovation_lab/mcp-durable-tasks-backend`) Actor

Plug-and-play SSE backend for the MCP Tasks extension (io.modelcontextprotocol/tasks). Defeats AI tool timeouts via Supabase durable queues.

- **URL**: https://apify.com/neon\_innovation\_lab/mcp-durable-tasks-backend.md
- **Developed by:** [Neon Innovation Lab](https://apify.com/neon_innovation_lab) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 task createds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🚀 MCP Durable Tasks Backend (io.modelcontextprotocol/tasks)

### 1. What does the MCP Durable Tasks Backend do?

AI Agents (like Claude, Cursor, and custom LangChain bots) natively time out if a tool takes longer than 60 seconds to execute. This Actor provides a plug-and-play Server-Sent Events (SSE) backend that fully implements the July 2026 `io.modelcontextprotocol/tasks` extension. It allows your MCP server to instantly offload heavy, long-running workloads (like deep web scraping, video rendering, or massive data analysis) into a durable Supabase-backed async queue, returning a task handle to the AI so it can poll for progress without crashing.

### 2. Why use this Actor? (The Problem it Solves)

- **Bypasses the 60-Second AI Timeout:** Stop watching your AI agents crash on `TimeoutError`. Hand them a task ID and let them check back later.
- **Zero-Infrastructure Job Queue:** You don't need to spin up Redis, Celery, or RabbitMQ. We handle the PostgreSQL/Supabase state management natively.
- **Official Protocol Compliance:** 100% compliant with the official `ext-tasks` specification (`tasks/get`, `tasks/update`, `tasks/cancel`).
- **Plug-and-Play Middleware:** Connects seamlessly to your existing FastMCP, Express, or standard Model Context Protocol servers.

### 3. Ideal Use Cases

- **Autonomous Researchers:** Agents that need to scrape 100+ pages of a domain over several minutes.
- **DevOps/Infra Bots:** Agents triggering long-running CI/CD pipelines, database migrations, or server provisions.
- **Media Generation:** Handing off video rendering, heavy TTS generation, or bulk image processing workloads.
- **Multi-Agent Orchestration:** Delegating complex sub-tasks to child agents and monitoring their percentage completion.

### 4. Input Configuration

The Actor accepts standard JSON configuration to bind to your Supabase instance and define task metadata:

```json
{
  "supabase_url": "https://your-project.supabase.co",
  "supabase_service_key": "eyJhb...",
  "tenant_id": "00000000-0000-0000-0000-000000000001",
  "port": 8002
}
```

### 5. Output Data Format

When queried via the `get_task_status` tool, the Actor returns fully compliant JSON-RPC payloads mapping directly to the MCP spec:

```json
{
  "taskId": "d59e55a9-7056-4805-9597-3bc34283701b",
  "status": "working",
  "progress": {
    "percent": 33,
    "completed_items": 1,
    "total_items": 3
  },
  "result": null,
  "error": null,
  "ttlMs": 3000
}
```

### 6. How to Integrate (Code Example)

Simply point your AI Client (Claude Desktop, Cursor, or custom script) to this Apify Standby Actor's SSE URL:

```json
{
  "mcpServers": {
    "durable-tasks": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/inspector", "https://your-apify-actor-url.apify.tech/sse"]
    }
  }
}
```

### 7. Cost & Pricing Strategy

- **Pay-per-Event:** Billed dynamically per asynchronous task created ($0.005/task). Highly cost-effective for intermittent agent operations.

### 8. Integrations & Compatibility

- Fully compatible with **FastMCP (Python)**, **@modelcontextprotocol/sdk (Node.js)**, **Claude Desktop**, and **Cursor**.
- Built natively for **Supabase / PostgREST** state storage.

### 9. Limitations & Support

- **Max Task Duration:** Bound by your Supabase database retention policies and Apify Standby limits.
- **Stateless Reconnection:** If an SSE connection drops, the AI agent must re-invoke `get_task_status(taskId)` to resume polling. The state is durably backed up, so no data is lost during disconnects.
- For custom deployments or enterprise SLA, contact via Apify Issues.

# Actor input Schema

## `SUPABASE_URL` (type: `string`):

The URL of your Supabase instance (e.g. http://34.69.23.51:54321)

## `SUPABASE_SERVICE_ROLE_KEY` (type: `string`):

The secure service\_role key to bypass RLS and create tasks.

## `TENANT_ID` (type: `string`):

Optional: Internal Tenant ID for task partitioning (Multi-tenant isolation).

## Actor input object example

```json
{
  "TENANT_ID": "00000000-0000-0000-0000-000000000001"
}
```

# Actor output Schema

## `mcp_endpoint` (type: `string`):

Connect your MCP client to this live Server-Sent Events (SSE) URL.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("neon_innovation_lab/mcp-durable-tasks-backend").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("neon_innovation_lab/mcp-durable-tasks-backend").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call neon_innovation_lab/mcp-durable-tasks-backend --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neon_innovation_lab/mcp-durable-tasks-backend"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/19EPUtn9Cm6f1e1Cj/builds/tgXkuirKPBgZTVUUI/openapi.json