MCP.so
Sign In

Air PipeVerifiedFeatured

@airpipe

About Air Pipe

Build, validate, deploy — HTTP APIs, cron jobs, webhooks and MCP tools — from your AI client.

Connection details

https://api.airpipe.io/mcp

Setup

claude mcp add airpipe --transport http https://api.airpipe.io/mcp --header "Authorization: Bearer YOUR_AIRPIPE_MCP_TOKEN"

Tools

19

Create a reusable module (a typed config fragment referenced by handle) and optionally deploy it to staging or production. spec_yaml is base64-encoded YAML of the module body; module_type is the config struct it represents (e.g. Database).

Get airpipe config-authoring instructions plus RAG-retrieved real action examples for a natural-language request, so YOU (the calling model) write the YAML yourself instead of the server generating it. Returns { instructions, context, request, protocol }. After writing the config, validate it with the validate_config tool (repair loop) then persist it with create_config. Prefer this over generate_config whenever you can author YAML yourself.

Enable or disable one or more configurations by config_uuid.

Edit an AirPipe configuration YAML with a natural-language instruction.

Deploy a specific past revision of a configuration to staging or production.

List the organizations you belong to and their organization_uuid. Call this first to get an organization_uuid for the config tools.

Undeploy a reusable module from an environment (STAGING or PRODUCTION).

Deploy a specific past revision of a module to staging or production.

Update an existing reusable module by module_uuid (adds a new revision; spec_yaml is base64-encoded YAML) and optionally redeploy.

Get a single configuration's data by config_uuid, optionally with its revisions.

List the organization's AirPipe configurations.

Create a new AirPipe configuration (config_yaml is base64-encoded YAML) and optionally deploy it to staging or production.

List the organization's reusable modules (pass revisions=true to include revision history).

Delete one or more reusable modules by module_uuid.

Get a single reusable module by uuid, including its revision history and spec.

Update an existing AirPipe configuration by config_uuid (config_yaml is base64-encoded YAML) and optionally redeploy.

Schema-validate an airpipe YAML config. Send { "yaml": <the full YAML string> }. Returns { valid: true } when it passes, or { valid: false, error: <message> } when it fails — feed the error back into your fix and call again until valid. Schema check only; does not save. Use create_config to persist a valid config.

Delete one or more AirPipe configurations by config_uuid.

Undeploy a configuration from an environment (STAGING or PRODUCTION).

Overview

Air Pipe turns one declarative config into a running backend — HTTP routes, cron jobs, webhooks, realtime channels and MCP tools, all from the same interface and behind the same auth.

This server hands that platform to your AI client. Claude Code, Claude Desktop or Cursor can plan a service, write the config, validate it, deploy it to staging or production, and roll it back — end to end, without leaving the chat.

The authoring loop

The interesting tool is plan_config, and it deliberately does not generate YAML server-side. It returns config-authoring instructions plus real action examples retrieved for your request, and your model writes the config. That keeps the output in your model's context where you can reason about it, rather than handing back a black box.

  1. plan_config — instructions + retrieved examples for what you asked for
  2. your model writes the YAML
  3. validate_config — schema check; feed the error back and retry until it passes
  4. create_config — persist it, optionally deploying in the same call
  5. deploy_config_revision — promote or roll back to any past revision

Step 3 is a repair loop, not a gate. validate_config returns the specific schema error so the model can fix and re-submit, which is why generated configs converge instead of failing opaquely.

Tools

Discovery

ToolDoes
list_organizationsYour orgs and their organization_uuid. Call this first — the config tools need it.
list_configsThe org's configurations.
get_configOne configuration, optionally with its revision history.

Authoring

ToolDoes
plan_configAuthoring instructions + retrieved examples so your model can write the config.
validate_configSchema-validate YAML. Returns the exact error to repair against.
create_configPersist a config, optionally deploying it.
update_configUpdate by uuid, adding a revision, optionally redeploying.
edit_configApply a natural-language edit to an existing config.

Lifecycle

ToolDoes
deploy_config_revisionDeploy any past revision to staging or production — this is your rollback.
undeploy_configRemove a config from an environment.
toggle_configEnable or disable configs.
delete_configDelete configs.

Reusable modules — typed config fragments referenced by handle, so shared pieces (a database block, a common action) live in one place: list_modules, get_module, create_module, update_module, deploy_module_revision, undeploy_module, delete_module.

19 tools in total.

Setup

  1. Create an account at https://app.airpipe.io/register — the free tier is 3,000 managed request units a month, no card.
  2. Mint an MCP token from your account. It is a long-lived JWT (90 days by default), shown once, and revocable at any time.
  3. Add the server:
{
  "mcpServers": {
    "airpipe": {
      "type": "http",
      "url": "https://api.airpipe.io/mcp",
      "headers": { "Authorization": "Bearer YOUR_AIRPIPE_MCP_TOKEN" }
    }
  }
}

Ask your client to list_organizations to confirm the connection.

Security

Every tool validates the token, then checks org membership, then role — three layers, and they fail closed. An agent reaches exactly what you could reach yourself with that token, and nothing more.

Tool discovery is open (registries need it), but every tool call is authenticated. Tokens are revocable by id without waiting for expiry.

What you get on the other end

A config deployed through these tools is a real service: OpenAPI docs, Prometheus metrics and OpenTelemetry traces generated from the same file, over Postgres, MySQL, SQL Server, SQLite or MongoDB. Run it on Air Pipe's managed cloud, or self-host the identical config as a single binary — the self-hosted binary serves this same MCP interface.

Frequently asked questions

What is the Air Pipe remote MCP server?

The Air Pipe remote MCP server is a hosted Model Context Protocol endpoint at https://api.airpipe.io/mcp, so AI assistants can connect to it without installing or running anything locally.

How do I connect to the Air Pipe MCP server?

Add the endpoint https://api.airpipe.io/mcp to any MCP-compatible client such as Claude Code, Cursor, or VS Code. The setup snippets on this page configure each client in one step.

Does the Air Pipe MCP server require authentication?

Yes. Air Pipe requires an API key — check the official documentation for how to obtain one, then include it in your client's configuration.

Which transport does the Air Pipe MCP server use?

Air Pipe exposes a Streamable HTTP endpoint, the transport used by remote MCP servers and supported by all major MCP clients.

Comments