Ductape / Get started

Build with Ductape

Build a real backend with your AI coding agent. Connect it to Ductape through MCP, pick a project, and let the agent build it — the MCP server handles wiring the SDK into your codebase.

Create your Ductape workspace

Access Key — server-side, used by the SDK to create and manage resources
Publishable Key — used by the MCP server and frontend clients
Workspace ID — identifies your workspace to the MCP server

The Access Key and Publishable Key have different scopes — the Access Key can create/update resources, the Publishable Key cannot.

Connect your AI coding agent

Install the MCP server and the CLI locally.

npm install -g @ductape/mcp @ductape/cli

Log the CLI in — this step is required, not optional. Your agent creates and manages resources through this logged-in session, separately from the keys above:

ductape login

Add the MCP server to your agent's MCP config using your Publishable Key and Workspace ID:

{
  "mcpServers": {
    "ductape": {
      "type": "stdio",
      "command": "ductape-mcp",
      "env": {
        "DUCTAPE_PUBLISHABLE_KEY": "your_publishable_key",
        "DUCTAPE_WORKSPACE": "your_workspace_id"
      }
    }
  }
}

Then tell your agent:

You are building this backend using Ductape.
Inspect the Ductape documentation and available MCP tools before you start.
Use the Ductape SDK in this codebase and use Ductape for backend resources, integrations, configuration, execution, and observability where appropriate.
Build the requested backend completely.
Do not just explain what I should do. Make the changes in the codebase, configure Ductape, run the application, test the important workflows, and fix any errors you encounter.

You don’t need to install @ductape/sdk or write any init code yourself — once connected, your agent installs the SDK and wires it into your codebase as part of building.

Pick something to build

Choose one of these projects and give its prompt to your agent.

Run it

Once your agent finishes, start your project the way you normally would — npm run dev, go run ., dotnet run, mvn spring-boot:run, whatever your stack uses.

Test the APIs it created. Then open your Ductape workspace to inspect what happened: products, apps, environments, actions, resources, logs, and runs.

Ductape is designed around these reusable backend building blocks, so the result isn’t just code sitting in your repository — you can inspect and manage what the agent created directly in Workbench.

Now build whatever you want

Once you’ve completed one project, you don’t need another tutorial. Tell your agent:

I want to build [describe your product].
Use this codebase and Ductape to build the backend.
First inspect the requirements and determine the necessary resources, APIs, integrations, Actions, and backend components.
Use the Ductape SDK and MCP tools where appropriate.
Build the backend end-to-end.
Add authentication, validation, error handling, retries, and tests where appropriate.
Configure the required environment variables and secrets.
Run the application and tests.
If anything fails, diagnose the issue and fix it.
Do not just explain the implementation. Build it.

You're ready. Connect your agent. Pick a project. Start building.

Create your workspace