Skip to main content
Glama
Apache Airflow MCP Server

Apache Airflow MCP Server

by madamak

Apache Airflow MCP Server

MCP PyPI Python Airflow CI Security License Ruff

Independent community project; not affiliated with or endorsed by the Apache Software Foundation.

Published through PyPI, GHCR, and the official MCP Registry. Reproducible scan reports, dependency audits, SBOMs, and provenance are attached to each immutable release.

Connect Claude, Cursor, VS Code, or another MCP client to your Apache Airflow deployments and help agents diagnose failed DAGs.

Paste an Airflow UI link from a PagerDuty/Datadog alert and ask "why did this fail?" — the agent resolves the URL, finds the failed tasks, pulls log errors filtered and bounded before the MCP response, and can re-trigger or clear runs. Write tools carry destructive-operation annotations that MCP clients can use to request confirmation.

Highlights

  • 🔍 Incident-response first — resolve Airflow UI URLs straight to the failing task, filter logs by error level with context lines, follow try_number semantics correctly (sensors included)

  • 🏢 Multi-instance — one server for same-API-family dev/staging/prod targets, with per-instance credentials and an SSRF guard that rejects unknown hosts

  • 🔒 Safety controls — opt-in read-only mode (AIRFLOW_MCP_READ_ONLY=true) that never registers write tools; write tools annotated as destructive; configured credentials are redacted from instance responses and operation logs

  • 📉 Token-efficient — log tailing, level filtering, byte caps, and truncation metadata designed for LLM context windows

  • 🧭 Airflow 2 and 3 — API v1/v2 adapters with live E2E against Airflow 2.11 and 3.3, including JWT auth

  • 📎 Traceable — every response carries a request_id that matches the structured server logs

Related MCP server: airflow-mcp-server

Quickstart

1. Install

uv tool install apache-airflow-mcp-server \
  --with 'apache-airflow-client==3.3.0'  # replace 3.3.0 with your Airflow version

Airflow 2.11? Use --with 'apache-airflow-client==2.10.0' instead; 2.10.0 is the final generated v1 client and targets Airflow 2's stable API. See Airflow compatibility before using a different release.

2. Connect your MCP client

The fastest path is a single instance configured entirely with environment variables — no config file needed.

claude mcp add airflow \
  --env AIRFLOW_MCP_HOST=https://airflow.example.com \
  --env AIRFLOW_MCP_USERNAME=admin \
  --env AIRFLOW_MCP_PASSWORD=your-password \
  --env AIRFLOW_MCP_READ_ONLY=true \
  -- uvx --from apache-airflow-mcp-server \
  --with apache-airflow-client==3.3.0 airflow-mcp --transport stdio

Add to claude_desktop_config.json (Settings → Developer → Edit Config):

{
  "mcpServers": {
    "airflow": {
      "command": "uvx",
      "args": ["--from", "apache-airflow-mcp-server", "--with", "apache-airflow-client==3.3.0", "airflow-mcp", "--transport", "stdio"],
      "env": {
        "AIRFLOW_MCP_HOST": "https://airflow.example.com",
        "AIRFLOW_MCP_USERNAME": "admin",
        "AIRFLOW_MCP_PASSWORD": "your-password",
        "AIRFLOW_MCP_READ_ONLY": "true"
      }
    }
  }
}

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "airflow": {
      "command": "uvx",
      "args": ["--from", "apache-airflow-mcp-server", "--with", "apache-airflow-client==3.3.0", "airflow-mcp", "--transport", "stdio"],
      "env": {
        "AIRFLOW_MCP_HOST": "https://airflow.example.com",
        "AIRFLOW_MCP_USERNAME": "admin",
        "AIRFLOW_MCP_PASSWORD": "your-password",
        "AIRFLOW_MCP_READ_ONLY": "true"
      }
    }
  }
}

Add to .vscode/mcp.json:

{
  "servers": {
    "airflow": {
      "type": "stdio",
      "command": "uvx",
      "args": ["--from", "apache-airflow-mcp-server", "--with", "apache-airflow-client==3.3.0", "airflow-mcp", "--transport", "stdio"],
      "env": {
        "AIRFLOW_MCP_HOST": "https://airflow.example.com",
        "AIRFLOW_MCP_USERNAME": "admin",
        "AIRFLOW_MCP_PASSWORD": "your-password",
        "AIRFLOW_MCP_READ_ONLY": "true"
      }
    }
  }
}

Run the server yourself and point the client at the endpoint:

AIRFLOW_MCP_HOST=https://airflow.example.com \
AIRFLOW_MCP_USERNAME=admin AIRFLOW_MCP_PASSWORD=your-password \
AIRFLOW_MCP_READ_ONLY=true \
airflow-mcp --transport http --host 127.0.0.1 --port 8765
{ "mcpServers": { "airflow": { "url": "http://127.0.0.1:8765/mcp" } } }

Health check: GET /health → 200 OK.

3. Ask your agent something

"Why did the latest run of etl_pipeline fail?"

"https://airflow.example.com/dags/etl_pipeline/grid — what happened here, and is it safe to clear?"

"Show the failed task's error context and tell me the smallest recovery action."

Airflow compatibility

The server talks to Airflow through the generated apache-airflow-client. For Airflow 3, match the client release to your Airflow release: generated models can change within a major version, and a newer client is not guaranteed to deserialize an older server's responses correctly. Airflow 2.11 uses the final v1 client release, 2.10.0, against Airflow 2's stable API.

Your Airflow

REST API

Install

Live E2E status

3.3

v2

uv tool install apache-airflow-mcp-server --with 'apache-airflow-client==3.3.0'

✅ 3.3.0

2.11

v1

uv tool install apache-airflow-mcp-server --with 'apache-airflow-client==2.10.0'

✅ Airflow 2.11 + final v1 client 2.10.0

3.0–3.2

v2

Pin the client to the deployed Airflow 3 version

🧪 Not in the current live matrix

2.5–2.10

v1

Use the final v1 client, apache-airflow-client==2.10.0

🧪 Not in the current live matrix

When api_version isn't set, the server assumes the API matching the installed client (v1 for a 2.x client, v2 for 3.x). Set AIRFLOW_MCP_API_VERSION (or api_version: in the registry) explicitly to catch a major-version mismatch early.

One server process can currently load only one generated client major. All instances in a registry must therefore use the same API family; run separate MCP server processes for Airflow 2 and Airflow 3. Mixed-version support requires a future client-adapter change and is not advertised as working today.

Airflow 3 notes:

  • Auth: bearer tokens are passed through as JWTs; basic credentials are automatically exchanged for a JWT via POST /auth/token and refreshed periodically (AIRFLOW_MCP_TOKEN_REFRESH_SECONDS, default 3600 — keep it below your deployment's JWT expiry, and note there is no automatic re-auth on 401 yet).

  • execution_date ordering maps to logical_date, datasets map to assets, and UI links use the Airflow 3 route scheme. Tool names and the core workflow stay stable; documented fields and options can differ by API family.

  • Clear options that no longer exist in Airflow 3 (include_subdags/include_parentdag, and the include_*/reset_dag_runs options of airflow_clear_dag_run) are rejected with INVALID_INPUT rather than silently narrowing a destructive operation.

Both client families are exercised on relevant pull requests and main pushes. Bug reports from real Airflow deployments are very welcome!

Configuration

Single instance (env vars only)

Variable

Required

Description

AIRFLOW_MCP_HOST

✅

Airflow base URL, e.g. https://airflow.example.com

AIRFLOW_MCP_USERNAME / AIRFLOW_MCP_PASSWORD

✅*

Basic auth credentials

AIRFLOW_MCP_TOKEN

✅*

Bearer/JWT token (used instead of basic auth)

AIRFLOW_MCP_API_VERSION

v1 (Airflow 2) or v2 (Airflow 3); defaults to whichever matches the installed apache-airflow-client

AIRFLOW_MCP_VERIFY_SSL

Verify TLS certificates (default true)

* provide either username+password or a token.

Multiple instances (registry YAML)

Point AIRFLOW_MCP_INSTANCES_FILE at a YAML registry (it takes precedence over the single-instance env vars). Values may reference environment variables with ${VAR}:

data-stg:
  host: https://airflow.data-stg.example.com/
  api_version: v1        # Airflow 2
  verify_ssl: true
  auth:
    type: basic
    username: ${AIRFLOW_DATA_STG_USERNAME}
    password: ${AIRFLOW_DATA_STG_PASSWORD}

data-prod:
  host: https://airflow.data-prod.example.com/
  api_version: v1        # Keep one client/API family per server process
  auth:
    type: bearer
    token: ${AIRFLOW_DATA_PROD_TOKEN}

Every tool accepts either an instance key (data-stg) or a ui_url — a full http(s) Airflow UI URL whose host is resolved against the registry, with unknown hosts rejected (SSRF guard). ui_url also auto-fills dag_id/dag_run_id/task_id when the link contains them. If both instance and ui_url are passed and disagree, the call fails with INSTANCE_MISMATCH rather than guessing.

Kubernetes tip: mount the registry from a Secret at /config/instances.yaml and set AIRFLOW_MCP_INSTANCES_FILE=/config/instances.yaml.

Server options

Variable

Default

Description

AIRFLOW_MCP_DEFAULT_INSTANCE

Default instance key (also names the env-var instance)

AIRFLOW_MCP_READ_ONLY

false

Don't register write tools at all

AIRFLOW_MCP_HTTP_HOST / AIRFLOW_MCP_HTTP_PORT

127.0.0.1 / 8765

HTTP transport bind

AIRFLOW_MCP_TIMEOUT_SECONDS

30

Airflow API timeout

AIRFLOW_MCP_TOKEN_REFRESH_SECONDS

3600

Airflow 3: JWT refresh interval for basic-auth instances

AIRFLOW_MCP_LOG_FILE

Optional log file path

AIRFLOW_MCP_ENABLE_EXTENDED_CLEAR_PARAMS

false

Enable include_* clear params (Airflow ≥2.6)

AIRFLOW_MCP_HTTP_BLOCK_GET_ON_MCP

true

Return 405 for GET /mcp (SSE reads) on HTTP deployments

Read-only mode

The quickstarts set AIRFLOW_MCP_READ_ONLY=true: write tools (trigger, clear, pause/unpause) are never registered. This prevents MCP mutations, but read tools can still disclose sensitive logs, configuration, rendered fields, and DAG-run data; use least-privilege Airflow credentials.

To enable recovery operations deliberately, set AIRFLOW_MCP_READ_ONLY=false. Write tools then carry MCP destructiveHint annotations that clients can use when deciding whether to request confirmation. Annotations are advisory, so do not enable writes unless the Airflow credentials and MCP client's approval behavior are appropriate for the target environment.

Tools

Discovery & URL utilities

Tool

Description

airflow_list_instances

List configured instance keys and the default

airflow_describe_instance

Host, API version, auth type (secrets redacted)

airflow_resolve_url

Parse an Airflow UI URL into instance + dag/run/task identifiers

Read

Tool

Description

airflow_list_dags

DAGs with pause state and UI links

airflow_get_dag

DAG details

airflow_list_dag_runs

Runs with state filters and ordering (latest first by default)

airflow_get_dag_run

Single run details

airflow_list_task_instances

Task attempts for a run; filter by state / task_ids server-side

airflow_get_task_instance

Task metadata, retries, timings, optional rendered template fields

airflow_get_task_instance_logs

Logs with level filtering, tailing, context lines, and byte caps

airflow_dataset_events

Dataset (Airflow 2) / asset (Airflow 3) events

Write (annotated destructive so clients can require approval; hidden entirely in read-only mode)

Tool

Description

airflow_trigger_dag

Trigger a run with optional conf/logical date/note

airflow_clear_task_instances

Clear task instances across runs (dry_run=true by default)

airflow_clear_dag_run

Clear a whole run (dry_run=true by default)

airflow_pause_dag / airflow_unpause_dag

Toggle DAG scheduling

Every success payload includes a request_id for log correlation; failures raise a structured ToolError with {code, message, request_id, context}.

The incident workflow

This is the flow the tools were designed around — going from an alert link to a diagnosis in four calls:

# 1. Alert contains an Airflow UI link → resolve it
airflow_resolve_url("https://airflow.example.com/dags/etl_pipeline/grid?dag_run_id=...")
#    → {instance, dag_id, dag_run_id, ...}

# 2. Which tasks failed in this run?
airflow_list_task_instances(dag_id="etl_pipeline", dag_run_id="scheduled__2026-01-01",
                            state=["failed"])

# 3. Get attempt metadata (authoritative try_number, retries, timings)
ti = airflow_get_task_instance(dag_id="etl_pipeline",
                               dag_run_id="scheduled__2026-01-01",
                               task_id="transform_data")

# 4. Pull only the error lines, with context, capped for the LLM
airflow_get_task_instance_logs(dag_id="etl_pipeline",
                               dag_run_id="scheduled__2026-01-01",
                               task_id="transform_data",
                               try_number=ti["attempts"]["try_number"],
                               tail_lines=500, filter_level="error", context_lines=5)

Log responses include truncated, auto_tailed (logs >100MB tail automatically), match_count, and byte/line stats so the agent knows exactly what it's looking at. Host-segmented logs are flattened with --- [worker-1] --- headers; Airflow 3 structured logs are rendered as plain lines.

Note on try_number: reschedule-mode sensors could increment it on every reschedule through Airflow 2.9; Airflow 2.10+ no longer does. Always read it from airflow_get_task_instance rather than guessing—the derived retries_consumed/retries_remaining fields are heuristics.

Deployment

Docker

docker run -p 127.0.0.1:8765:8765 \
  -e AIRFLOW_MCP_HOST=https://airflow.example.com \
  -e AIRFLOW_MCP_USERNAME=admin \
  -e AIRFLOW_MCP_PASSWORD=your-password \
  -e AIRFLOW_MCP_READ_ONLY=true \
  ghcr.io/madamak/apache-airflow-mcp-server:latest

Or build locally with docker build -t airflow-mcp .

The release image contains the lockfile's Airflow 3.3 client and serves streamable HTTP on :8765 (/mcp endpoint, /health for probes). The MCP HTTP endpoint has no built-in caller authentication: keep it loopback-bound or place it behind an authenticated private proxy. Mount a same-API-family registry YAML for multi-instance setups. Airflow 2 deployments should use the pinned local installation path above until a separate v1 image is published.

CI audits the exact image's installed Python dependencies and scans both the read-only and write-enabled MCP tool surfaces with a pinned Cisco MCP Scanner release's YARA analyzer. The security workflow fails on incomplete scans or any untriaged YARA finding. Starting with v1.0.1, release assets include the machine-readable scan reports, and release image manifests carry attached SBOM and provenance attestations covering their broader package inventory. These are automated checks, not a security certification or substitute for deployment-specific review.

FastMCP tooling

A fastmcp.json is included so FastMCP-aware tooling can auto-discover the entrypoint and deployment defaults.

Development

uv sync                 # install dependencies
uv run pytest           # unit tests (no real network; the Airflow client is mocked)
uv run ruff check .     # lint
uv run ruff format .    # format
uv run airflow-mcp --transport stdio   # run locally
./scripts/e2e.sh af2    # end-to-end against Airflow 2.11
./scripts/e2e.sh af3    # end-to-end against Airflow 3.3
                        # Both seed failures/noisy logs and drive every tool
                        # through MCP. Set E2E_KEEP=1 to keep the instance up.

CI runs the unit suite against both apache-airflow-client families on Python 3.10–3.13. Relevant pull requests, main pushes, nightly runs, and releases also exercise live dockerized Airflow 2.11 and 3.3. See CONTRIBUTING.md for guidelines and AGENTS.md if you're pointing a coding agent at this repo (it's written for that).

Contributing

Issues and PRs are welcome — especially:

  • Reports from real Airflow incident-response workflows and version combinations

  • Bounded-log, diagnosis-safety, and URL-first workflow improvements

  • Client setup recipes for more MCP hosts and deployment types

If this server saves you a debugging session, a ⭐ helps other Airflow teams find it.

License

Apache 2.0 — see LICENSE.

Apache Airflow and Airflow are registered trademarks of The Apache Software Foundation. This independent project is not affiliated with or endorsed by the ASF.

Available Tools

16 tools
airflow_clear_dag_runA
Destructive

Destructively clear all task instances within one specific DAG run.

Parameters

  • instance: Instance key (optional; mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve instance (optional; takes precedence)

  • dag_id: DAG identifier (required if ui_url not provided)

  • dag_run_id: DAG run identifier (required if ui_url not provided)

  • include_subdags: Include subDAGs (optional)

  • include_parentdag: Include parent DAG (optional)

  • include_upstream: Include upstream tasks (optional)

  • include_downstream: Include downstream tasks (optional)

  • dry_run: Preview without mutating (default true); set false explicitly to clear

  • reset_dag_runs: Reset DagRun state (optional)

Returns

  • Response dict: { "dag_id": str, "dag_run_id": str, "cleared": object, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: dag_id, ui_url, dry_run, instance, +6 more. Returns: object

airflow_clear_task_instancesA
Destructive

Clear task instances for a DAG across one or more runs using Airflow's native filter set (destructive).

Parameters

  • instance: Instance key (optional; mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve instance (optional; takes precedence)

  • dag_id: DAG identifier (required if ui_url not provided)

  • task_ids: List of task IDs to clear (optional)

  • start_date: ISO8601 start date filter (optional)

  • end_date: ISO8601 end date filter (optional)

  • include_subdags: Include subDAGs (optional)

  • include_parentdag: Include parent DAG (optional)

  • include_upstream: Include upstream tasks (optional)

  • include_downstream: Include downstream tasks (optional)

  • include_future: Include future runs (optional)

  • include_past: Include past runs (optional)

  • dry_run: Preview without mutating (default true); set false explicitly to clear

  • reset_dag_runs: Reset DagRun state (optional)

Returns

  • Response dict: { "dag_id": str, "cleared": object, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: dag_id, ui_url, dry_run, end_date, +10 more. Returns: object

airflow_dataset_eventsB
Read-onlyIdempotent

List dataset events.

Parameters

  • instance: Instance key (optional)

  • ui_url: Airflow UI URL to resolve instance (optional)

  • dataset_uri: Dataset URI (required)

  • limit: Max results (default 50; accepts int/float/str, coerced to non-negative int, fractional values truncated)

Returns

  • Response dict: { "events": [object], "count": int, "request_id": str }

Inputs: limit, ui_url, instance, dataset_uri. Returns: object

airflow_describe_instanceA
Read-onlyIdempotent

Describe a configured Airflow instance (host + metadata, never secrets).

Parameters

  • instance: Instance key (e.g., "data-stg")

Returns

  • Response dict: { "instance", "host", "api_version", "verify_ssl", "auth_type", "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: instance (required). Returns: object

airflow_get_dagA
Read-onlyIdempotent

Get DAG details and a UI link.

Parameters

  • instance | ui_url: Provide one; ui_url auto-resolves/validates the host.

  • dag_id: Required when only instance is supplied.

Returns

  • Response dict: { "dag": object, "ui_url": str, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: dag_id, ui_url, instance. Returns: object

airflow_get_dag_runA
Read-onlyIdempotent

Get a single DAG run and a UI link.

Parameters

  • instance: Instance key (optional)

  • ui_url: Airflow UI URL to resolve instance/dag/dag_run (optional)

  • dag_id: DAG identifier

  • dag_run_id: DAG run identifier

Returns

  • Response dict: { "dag_run": object, "ui_url": str, "request_id": str }

Inputs: dag_id, ui_url, instance, dag_run_id. Returns: object

airflow_get_task_instanceA
Read-onlyIdempotent

Return task metadata, config, attempt summary, optional rendered fields, and UI URLs.

Parameters

  • instance | ui_url: Target selection (URL precedence)

  • dag_id, dag_run_id, task_id: Required identifiers (unless resolved from ui_url)

  • include_rendered: When true, include rendered template fields (truncated using max_rendered_bytes)

  • max_rendered_bytes: Byte cap for rendered fields payload (default 100KB; accepts int/float/str, coerced to positive int, fractional values truncated)

Returns

  • Response dict: { "task_instance": {...}, "task_config": {...}, "attempts": {...}, "ui_url": {...}, "request_id": str, "rendered_fields"?: {...} }

Notes

  • attempts.try_number is the authoritative input for airflow_get_task_instance_logs.

  • Rendered fields include bytes_returned and truncated metadata.

  • Sensors increment try_number on every reschedule, so treat it as an attempt index; the derived retries counters are heuristic.

Inputs: dag_id, ui_url, task_id, instance, +3 more. Returns: object

airflow_get_task_instance_logsA
Read-onlyIdempotent

Fetch task instance logs with optional filtering and truncation.

Large log handling: Logs >100MB automatically tail to last 10,000 lines (sets auto_tailed=true). Host-segmented responses are flattened into a single string using headers of the form --- [worker] ---, ensuring agents can reason about multi-host output. The tool requires an explicit try_number; callers should first retrieve it via airflow_get_task_instance.

Filter order of operations:

  1. Auto-tail: If log >100MB, take last 10,000 lines

  2. tail_lines: Extract last N lines from log

  3. filter_level: Find matching lines by level (content filter)

  4. context_lines: Add surrounding lines around matches (symmetric: N before + N after)

  5. max_bytes: Hard cap on total output (UTF-8 safe truncation)

Parameters

  • instance: Instance key (optional, mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve identifiers (optional)

  • dag_id, dag_run_id, task_id, try_number: Task instance identifiers (required)

  • filter_level: "error" | "warning" | "info" (optional) - Show only lines matching level

    • "error": ERROR, CRITICAL, FATAL, Exception, Traceback

    • "warning": WARN, WARNING + error patterns

    • "info": INFO + warning + error patterns

  • context_lines: N lines before/after each match (optional, clamped to [0, 1000]; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • tail_lines: Extract last N lines before filtering (optional, clamped to [0, 100000]; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • max_bytes: Maximum response size in bytes (default: 100KB ≈ 25K tokens, clamped to 1MB)

Returns

  • Response dict with fields:

    • log: Normalized/filtered log text (host headers inserted when needed)

    • truncated: true if output exceeded max_bytes

    • auto_tailed: true if original log >100MB triggered auto-tail

    • bytes_returned: Actual byte size of returned log

    • original_lines: Line count before any filtering

    • returned_lines: Line count after all filtering/truncation

    • match_count: Number of lines matching filter_level (before context expansion)

    • meta.try_number: Attempt number for this task instance

    • meta.filters: Echo of effective filters applied (shows clamped values)

    • ui_url: Direct link to log view in Airflow UI

    • request_id: Correlates with server logs

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: dag_id, ui_url, task_id, instance, +6 more. Returns: object

airflow_list_dag_runsA
Read-onlyIdempotent

List DAG runs (defaults to execution_date DESC) with per-run UI URLs.

Parameters

  • instance: Instance key (optional)

  • ui_url: Airflow UI URL to resolve instance/dag_id (optional)

  • dag_id: DAG identifier (required if ui_url not provided)

  • limit: Max results (default 100; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • offset: Offset for pagination (default 0; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • state: List of states to filter by (optional)

  • order_by: Optional "start_date", "end_date", "execution_date", or "logical_date" (omit to use execution_date; execution_date and logical_date are mapped to whichever name the target Airflow version uses)

  • descending: Sort direction (default True). Ignored when order_by is omitted; defaults always use execution_date descending

Returns

  • Response dict: { "dag_runs": [{ "dag_run_id", "state", "start_date", "end_date", "ui_url" }], "count": int, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: limit, state, dag_id, offset, +4 more. Returns: object

airflow_list_dagsA
Read-onlyIdempotent

List DAGs (pause state + UI link) for the target instance.

Parameters

  • instance: Instance key (optional; mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve instance (optional; takes precedence - must match a configured host)

  • limit: Max results (default 100; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • offset: Offset for pagination (default 0; accepts int/float/str, coerced to non-negative int, fractional values truncated)

Returns

  • Response dict: { "dags": [{ "dag_id", "is_paused", "ui_url" }], "count": int, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: limit, offset, ui_url, instance. Returns: object

airflow_list_instancesA
Read-onlyIdempotent

List configured Airflow instance keys.

Returns

  • Response dict: { "instances": [str], "default_instance": str | null, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: no named parameters. Returns: object

airflow_list_task_instancesA
Read-onlyIdempotent

List task instances within one DAG run, including state and attempt log URLs.

Parameters

  • instance: Instance key (optional)

  • ui_url: Airflow UI URL to resolve instance/dag/dag_run (optional)

  • dag_id: DAG identifier

  • dag_run_id: DAG run identifier

  • limit: Max results (default 100; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • offset: Offset for pagination (default 0; accepts int/float/str, coerced to non-negative int, fractional values truncated)

  • state: Optional list of task states (case-insensitive). When provided, only matching states are returned.

  • task_ids: Optional list of task identifiers to include.

Returns

  • Response dict: { "task_instances": [{ "task_id", "state", "try_number", "ui_url" }], "count": int, "total_entries"?: int, "filters"?: { "state": [...], "task_ids": [...] }, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: limit, state, dag_id, offset, +4 more. Returns: object

airflow_pause_dagA
Destructive

Pause DAG scheduling (sets is_paused=True and returns UI link).

Parameters

  • instance: Instance key (optional; mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve instance (optional; takes precedence)

  • dag_id: DAG identifier (required if ui_url not provided)

Returns

  • Response dict: { "dag_id": str, "is_paused": true, "ui_url": str, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: dag_id, ui_url, instance. Returns: object

airflow_resolve_urlA
Read-onlyIdempotent

Parse an Airflow UI URL, resolve instance and identifiers.

Parameters

  • url: Airflow UI URL (http/https)

Returns

  • Response dict: { "instance", "dag_id"?, "dag_run_id"?, "task_id"?, "try_number"?, "route", "request_id" }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: url (required). Returns: object

airflow_trigger_dagA
Destructive

Trigger a DAG run with optional configuration.

Parameters

  • instance: Instance key (optional; mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve instance (optional; takes precedence)

  • dag_id: DAG identifier (required if ui_url not provided)

  • dag_run_id: Custom run id (optional)

  • logical_date: Optional ISO8601 logical date/time assigned to the new run

  • conf: Configuration object as dict or JSON string (optional)

  • note: Run note/comment (optional)

Returns

  • Response dict: { "dag_run_id": str, "ui_url": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: conf, note, dag_id, ui_url, +3 more. Returns: object

airflow_unpause_dagA
Destructive

Resume DAG scheduling (sets is_paused=False and returns UI link).

Parameters

  • instance: Instance key (optional; mutually exclusive with ui_url)

  • ui_url: Airflow UI URL to resolve instance (optional; takes precedence)

  • dag_id: DAG identifier (required if ui_url not provided)

Returns

  • Response dict: { "dag_id": str, "is_paused": false, "ui_url": str, "request_id": str }

  • Raises: ToolError with compact JSON payload (code, message, request_id, optional context)

Inputs: dag_id, ui_url, instance. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 16 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, targeting specific Airflow entities (DAGs, runs, tasks, instances, datasets) and actions (list, get, clear, trigger, pause/unpause, describe, resolve). No two tools perform the same operation on the same entity, and descriptions make boundaries clear.

    Naming Consistency5/5

    All tools follow a consistent 'airflow_verb_noun' pattern (e.g., airflow_list_dags, airflow_trigger_dag). No mixing of conventions or unusual naming styles, making it easy for agents to predict tool names.

    Tool Count4/5

    With 16 tools, the count is slightly above the high end of 'well-scoped' (3-15), but it is reasonable given the complexity of Apache Airflow. The tools cover a comprehensive set of operations without feeling bloated or redundant.

    Completeness4/5

    The tool surface covers all core Airflow interactions: listing, getting, clearing, triggering, pausing/unpausing DAGs, runs, and task instances, plus logs, dataset events, and instance management. Minor gaps exist (e.g., no DAG update or deletion), but those are less common operations and the set still enables effective agent workflows.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables management of Amazon Managed Workflows for Apache Airflow (MWAA) environments and operations including DAG management, workflow execution monitoring, and access to Airflow connections and variables through a unified interface.
      21
      3
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables natural language interaction with Apache Airflow for querying DAGs, monitoring execution, and troubleshooting failures.
      28 PyPI
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides read-only monitoring of Apache Airflow DAGs, including listing active DAGs, fetching recent runs, and analyzing execution history and performance metrics.
      1
      MIT