Apache Airflow MCP Server
The Apache Airflow MCP Server enables AI agents (Claude, Cursor, VS Code Copilot, etc.) to monitor, debug, and manage Apache Airflow deployments. Key capabilities include:
Instance Management
List and describe configured Airflow instances (dev/staging/prod, secrets never exposed)
Resolve Airflow UI URLs (e.g., from PagerDuty/Datadog alerts) into structured identifiers (instance, dag_id, dag_run_id, task_id, try_number)
DAG & Run Inspection (Read)
List DAGs with pause state, UI links, and pagination
Get detailed DAG metadata and list/retrieve DAG runs with state filtering and ordering
Task Instance Inspection (Read)
List and inspect task instances (state, retries, timings, rendered templates, per-attempt log URLs)
Fetch logs with advanced filtering: by log level (error/warning/info), tail last N lines, context lines around matches, byte caps, and truncation metadata — optimized for LLM context windows
Dataset/Asset Events (Read)
Query dataset (Airflow 2) or asset (Airflow 3) events for a given URI
DAG & Run Management (Write — require approval)
Trigger DAG runs with optional config, logical date, custom run ID, and notes
Clear task instances across runs (with filters for task IDs, date ranges, upstream/downstream, dry-run support)
Clear all tasks in a specific DAG run (with dry-run support)
Pause/unpause DAG scheduling
Safety & Usability
Read-only mode (
AIRFLOW_MCP_READ_ONLY=true): write tools are never registeredDestructive annotations: write tools prompt clients for confirmation before executing
Multi-instance support: one server manages multiple clusters with per-instance credentials
SSRF guard: unknown hosts in UI URLs are rejected
Airflow 2 & 3 compatibility: supports REST API v1 and v2, including JWT auth for Airflow 3
Request tracing: every response includes a
request_idfor log correlation
Provides tools to interact with Apache Airflow instances to inspect DAGs, monitor DAG runs, retrieve task logs, and perform write operations such as triggering DAGs and clearing task instances.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Apache Airflow MCP Server show me the logs for the failed task in the daily_etl DAG"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Apache Airflow MCP Server
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_numbersemantics 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_idthat 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 versionAirflow 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 stdioAdd 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_pipelinefail?""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 |
| ✅ 3.3.0 |
2.11 | v1 |
| ✅ 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, | 🧪 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/tokenand 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_dateordering maps tological_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 theinclude_*/reset_dag_runsoptions ofairflow_clear_dag_run) are rejected withINVALID_INPUTrather 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 base URL, e.g. |
| ✅* | Basic auth credentials |
| ✅* | Bearer/JWT token (used instead of basic auth) |
|
| |
| Verify TLS certificates (default |
* 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 |
| Default instance key (also names the env-var instance) | |
|
| Don't register write tools at all |
|
| HTTP transport bind |
|
| Airflow API timeout |
|
| Airflow 3: JWT refresh interval for basic-auth instances |
| Optional log file path | |
|
| Enable |
|
| Return 405 for |
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 |
| List configured instance keys and the default |
| Host, API version, auth type (secrets redacted) |
| Parse an Airflow UI URL into instance + dag/run/task identifiers |
Read
Tool | Description |
| DAGs with pause state and UI links |
| DAG details |
| Runs with state filters and ordering (latest first by default) |
| Single run details |
| Task attempts for a run; filter by |
| Task metadata, retries, timings, optional rendered template fields |
| Logs with level filtering, tailing, context lines, and byte caps |
| Dataset (Airflow 2) / asset (Airflow 3) events |
Write (annotated destructive so clients can require approval; hidden entirely in read-only mode)
Tool | Description |
| Trigger a run with optional conf/logical date/note |
| Clear task instances across runs ( |
| Clear a whole run ( |
| 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 fromairflow_get_task_instancerather than guessing—the derivedretries_consumed/retries_remainingfields 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:latestOr 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 toolsairflow_clear_dag_runADestructive
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, optionalcontext)
Inputs: dag_id, ui_url, dry_run, instance, +6 more. Returns: object
airflow_clear_task_instancesADestructive
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, optionalcontext)
Inputs: dag_id, ui_url, dry_run, end_date, +10 more. Returns: object
airflow_dataset_eventsBRead-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_instanceARead-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, optionalcontext)
Inputs: instance (required). Returns: object
airflow_get_dagARead-onlyIdempotent
Get DAG details and a UI link.
Parameters
instance | ui_url: Provide one;
ui_urlauto-resolves/validates the host.dag_id: Required when only
instanceis supplied.
Returns
Response dict: { "dag": object, "ui_url": str, "request_id": str }
Raises: ToolError with compact JSON payload (
code,message,request_id, optionalcontext)
Inputs: dag_id, ui_url, instance. Returns: object
airflow_get_dag_runARead-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_instanceARead-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_numberis the authoritative input forairflow_get_task_instance_logs.Rendered fields include
bytes_returnedandtruncatedmetadata.Sensors increment
try_numberon 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_logsARead-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:
Auto-tail: If log >100MB, take last 10,000 lines
tail_lines: Extract last N lines from log
filter_level: Find matching lines by level (content filter)
context_lines: Add surrounding lines around matches (symmetric: N before + N after)
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, optionalcontext)
Inputs: dag_id, ui_url, task_id, instance, +6 more. Returns: object
airflow_list_dag_runsARead-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 useexecution_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, optionalcontext)
Inputs: limit, state, dag_id, offset, +4 more. Returns: object
airflow_list_dagsARead-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, optionalcontext)
Inputs: limit, offset, ui_url, instance. Returns: object
airflow_list_instancesARead-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, optionalcontext)
Inputs: no named parameters. Returns: object
airflow_list_task_instancesARead-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, optionalcontext)
Inputs: limit, state, dag_id, offset, +4 more. Returns: object
airflow_pause_dagADestructive
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, optionalcontext)
Inputs: dag_id, ui_url, instance. Returns: object
airflow_resolve_urlARead-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, optionalcontext)
Inputs: url (required). Returns: object
airflow_trigger_dagADestructive
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, optionalcontext)
Inputs: conf, note, dag_id, ui_url, +3 more. Returns: object
airflow_unpause_dagADestructive
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, optionalcontext)
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
Scored across 16 tools
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.
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.
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.
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
Related MCP Connectors
Connect, monitor, and control AI agents — tasks, approvals, schedules, and governance.
Build, test and publish agentic workflows from your AI client: approve steps, read tables, see runs.
Inspect RudderStack workspaces, pipelines, and schemas, and manage transformations and audiences.
Discover Playwright workflows, start runs, and inspect results in Playrunner Cloud.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables 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.213Apache 2.0
- AlicenseAqualityCmaintenanceAirflow MCP server — read DAGs, runs, task instances, log tails; trigger and clear (write-gated).876 npm2MIT
- AlicenseNot gradedqualityCmaintenanceEnables natural language interaction with Apache Airflow for querying DAGs, monitoring execution, and troubleshooting failures.28 PyPI1MIT
- AlicenseNot gradedqualityDmaintenanceProvides read-only monitoring of Apache Airflow DAGs, including listing active DAGs, fetching recent runs, and analyzing execution history and performance metrics.1MIT