MCP server intelligence profile

astro-airflow-mcp Server

An MCP server that enables AI assistants to interact with Apache Airflow's REST API for DAG management, task monitoring, and system diagnostics. It provides comprehensive tools for triggering workflows, retrieving logs, and inspecting system health across Airflow 2.x and 3.

Local OnlyOfficial distributionastronomer
Verified cleanPypi · 0.9.1

Our scanner tested version 0.9.1 without proving a finding in the methods exercised. This is not a guarantee that every deployment is secure.

1Distribution channel
34Independently observed tools
0Linked remote endpoints
AvailableVersion intelligence

Install and connect

Installation and connection instructions are shown only when supported by retained package, repository, or endpoint evidence.

Install astro-airflow-mcp from PyPI

Install exact version 0.9.1. The executable name has not been verified, so it is intentionally not guessed.

python -m pip install 'astro-airflow-mcp==0.9.1'

Build from source

Clone the canonical public repository, then follow its version-specific setup documentation.

git clone https://github.com/astronomer/astro-airflow-mcp

Identity

Canonical slugastro-airflow-mcp-767f10d9DeploymentLocal Only
Canonical packagepypi:astro-airflow-mcpRepositoryhttps://github.com/astronomer/astro-airflow-mcp
First publishedJul 8, 2026Latest releaseJul 8, 2026
Last security verification—Classification confidence90%
PublicationPublishedOfficial distributionYes

Distributions

ChannelIdentifierCurrent versionVersionsSource
pypiastro-airflow-mcp0.9.11Repository

Current release

PackageVersionPublished / observedInventorySecurity scan
pypiastro-airflow-mcp0.9.1CurrentJul 8, 202634 toolsSucceeded · 4 resources · 3 promptsFailed
Enterprise protection

Continuously monitor this MCP for security risk

Independently scan the exact version your agents use, receive alerts when its risk changes, and investigate every finding with retained version evidence.

  • Independent exact-version security scans
  • Continuous release and vulnerability monitoring
  • Risk-change alerts with capability context
  • Historical evidence and API exports
Custom pricingContact salesTailored to your organization, integrations, data needs, and support requirements.

Current version evidence

Provenanceartifact_hash_verifiedSignature—
MCP SDKpython_mcp_source_evidence Artifact SHA-25649f723d600dd06ef227798acee91d010aec267d51df57e73b60e729bf65f760f
Scannermcp-proof-engine 0.1.0Scan completedSep 4, 2026
Security rating33 / 100Methodologyversion-rating-1.0
Rating reasons
[
  "security_policy_not_observed"
]

Current protocol inventory

2025-06-18Negotiated protocol
Airflow MCP ServerServer-reported name
6Capability groups
Sep 4, 2026Observed

Tools 34

ToolCategoryAnnotationsRisk
clear_dag_runClear a DAG run to allow re-execution of all its tasks. Use this tool when the user asks to: - "Clear DAG run X" or "Retry DAG run Y" - "Re-run this DAG run" or "Reset this run" - "Clear a failed run" or "Restart this execution" This resets the DAG run and its task instances so they can be re-executed by the scheduler. Unlike deleting, this preserves the run but resets its state. Use dry_run=True (default) to preview what would be cleared before committing. IMPORTANT: This is a write operation that modifies Airflow state by resetting task instances. Set dry_run=False to actually clear.
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG (e.g., \"example_dag\")"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run to clear (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    },
    "dry_run": {
      "default": true,
      "type": "boolean",
      "description": "If True (default), return what would be cleared without clearing.\n     Set to False to actually clear and re-execute."
    }
  },
  "required": [
    "dag_id",
    "dag_run_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": true,
  "openWorldHint": true
}
—WritesDestructiveIdempotentOpen world—
clear_task_instancesClear task instances to retry their execution. Use this tool when the user asks about: - "Retry task X" or "Clear task Y and run again" - "Rerun the failed tasks" or "Reset task Z" - "Clear and retry from task A onwards" - "Re-execute task B" or "Run task C again" - "Fix the failed task and retry" This clears the state of task instances, allowing them to be re-executed. By default, it runs in dry_run mode to show what would be cleared. Set dry_run=False to actually clear the tasks. Returns information about cleared task instances including: - task_id: The ID of the cleared task - dag_id: The DAG containing the task - dag_run_id: The DAG run containing the task - state: The previous state of the task (before clearing)
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG (e.g., \"example_dag\")"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    },
    "task_ids": {
      "items": {
        "type": "string"
      },
      "type": "array",
      "description": "List of task IDs to clear (e.g., [\"extract_data\", \"transform_data\"])"
    },
    "dry_run": {
      "default": true,
      "type": "boolean",
      "description": "If True (default), only show what would be cleared without actually\n     clearing. Set to False to actually clear the tasks."
    },
    "only_failed": {
      "default": false,
      "type": "boolean",
      "description": "If True, only clear task instances that are in a failed state.\n         Useful for retrying just the failures."
    },
    "include_downstream": {
      "default": false,
      "type": "boolean",
      "description": "If True, also clear all downstream tasks that depend\n               on the specified tasks. Useful for \"retry from here onwards\"."
    }
  },
  "required": [
    "dag_id",
    "dag_run_id",
    "task_ids"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": true,
  "openWorldHint": true
}
—WritesDestructiveIdempotentOpen world—
delete_dag_runDelete a specific DAG run permanently. Use this tool when the user asks to: - "Delete DAG run X" or "Remove DAG run Y" - "Clean up old DAG runs" or "Delete stuck runs" - "Remove this run" or "Get rid of this DAG run" This permanently removes the DAG run and its metadata. This cannot be undone. IMPORTANT: This is a destructive, irreversible operation. Always confirm with the user before calling this tool. Show them the dag_id and dag_run_id you intend to delete and get explicit approval first. The response includes details of the deleted run for confirmation.
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG (e.g., \"example_dag\")"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run to delete (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    }
  },
  "required": [
    "dag_id",
    "dag_run_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": false,
  "openWorldHint": true
}
—WritesDestructiveNon-idempotentOpen world—
diagnose_dag_runDiagnose issues with a specific DAG run - get run details and failed tasks. USE THIS TOOL WHEN troubleshooting a failed or problematic DAG run. Returns all the information you need to understand what went wrong. This is the preferred tool when: - User asks "Why did this DAG run fail?" - User asks "What's wrong with run X?" - You need to investigate task failures in a specific run Returns combined data: - DAG run metadata (state, start/end times, trigger type) - All task instances for this run with their states - Highlighted failed/upstream_failed tasks with details - Summary of task states
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    }
  },
  "required": [
    "dag_id",
    "dag_run_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
explore_dagComprehensive investigation of a DAG - get all relevant info in one call. USE THIS TOOL WHEN you need to understand a DAG completely. Instead of making multiple calls, this returns everything about a DAG in a single response. This is the preferred first tool when: - User asks "Tell me about DAG X" or "What is this DAG?" - You need to understand a DAG's structure before diagnosing issues - You want to know the schedule, tasks, and source code together Returns combined data: - DAG metadata (schedule, owners, tags, paused status) - All tasks with their operators and dependencies - DAG source code - Any import errors or warnings for this DAG
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to explore"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_airflow_configGet Airflow instance configuration and settings. Use this tool when the user asks about: - "What's the Airflow configuration?" or "Show me Airflow settings" - "What's the executor type?" or "How is Airflow configured?" - "What's the parallelism setting?" - Database connection, logging, or scheduler settings - Finding specific configuration values Returns all Airflow configuration organized by sections: - [core]: Basic Airflow settings (executor, dags_folder, parallelism) - [database]: Database connection and settings - [webserver]: Web UI configuration (port, workers, auth) - [scheduler]: Scheduler behavior and intervals - [logging]: Log locations and formatting - [api]: REST API configuration - [operators]: Default operator settings - And many more sections... Each setting includes: - key: Configuration parameter name - value: Current value - source: Where the value came from (default, env var, config file) Returns: JSON with complete Airflow configuration organized by sections
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_airflow_versionGet version information for the Airflow instance. Use this tool when the user asks about: - "What version of Airflow is running?" or "Show me the Airflow version" - "What's the Airflow version?" or "Which Airflow release is this?" - "What version is installed?" or "Check Airflow version" - "Is this Airflow 2 or 3?" or "What's the version number?" Returns version information including: - version: The Airflow version string (e.g., "2.8.0", "3.0.0") - git_version: Git commit hash if available This is useful for: - Determining API compatibility - Checking if features are available in this version - Troubleshooting version-specific issues - Verifying upgrade success Returns: JSON with Airflow version information
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_dag_detailsGet detailed information about a specific Apache Airflow DAG. Use this tool when the user asks about: - "Show me details for DAG X" or "What are the details of DAG Y?" - "Tell me about DAG Z" or "Get information for this specific DAG" - "What's the schedule for DAG X?" or "When does this DAG run?" - "Is DAG Y paused?" or "Show me the configuration of DAG Z" - "Who owns this DAG?" or "What are the tags for this workflow?" Returns complete DAG information including: - dag_id: Unique identifier for the DAG - is_paused: Whether the DAG is currently paused - is_active: Whether the DAG is active - is_subdag: Whether this is a SubDAG - fileloc: File path where the DAG is defined - file_token: Unique token for the DAG file - owners: List of DAG owners - description: Human-readable description of what the DAG does - schedule_interval: Cron expression or timedelta for scheduling - tags: List of tags/labels for categorization - max_active_runs: Maximum number of concurrent runs - max_active_tasks: Maximum number of concurrent tasks - has_task_concurrency_limits: Whether task concurrency limits are set - has_import_errors: Whether the DAG has import errors - next_dagrun: When the next DAG run is scheduled - next_dagrun_create_after: Earliest time for next DAG run creation
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to get details for"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_dag_runGet detailed information about a specific DAG run execution. Use this tool when the user asks about: - "Show me details for DAG run X" or "What's the status of run Y?" - "When did this run start/finish?" or "How long did run Z take?" - "Why did this run fail?" or "Get execution details for run X" - "What was the configuration for this run?" or "Show me run metadata" - "What's the state of DAG run X?" or "Did run Y succeed?" Returns detailed information about a specific DAG run execution including: - dag_run_id: Unique identifier for this execution - dag_id: Which DAG this run belongs to - state: Current state (running, success, failed, queued, etc.) - execution_date: When this run was scheduled to execute - start_date: When execution actually started - end_date: When execution completed (if finished) - duration: How long the run took (in seconds) - run_type: Type of run (manual, scheduled, backfill, etc.) - conf: Configuration parameters passed to this run - external_trigger: Whether this was triggered externally - data_interval_start: Start of the data interval - data_interval_end: End of the data interval - last_scheduling_decision: Last scheduling decision timestamp - note: Optional note attached to the run
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG (e.g., \"example_dag\")"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    }
  },
  "required": [
    "dag_id",
    "dag_run_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_dag_sourceGet the source code for a specific Apache Airflow DAG. Use this tool when the user asks about: - "Show me the code for DAG X" or "What's the source of DAG Y?" - "How is DAG Z implemented?" or "What does the DAG file look like?" - "Can I see the Python code for this workflow?" - "What tasks are defined in the DAG code?" Returns the DAG source file contents including: - content: The actual Python source code of the DAG file - file_token: Unique identifier for the source file
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to get source code for"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_dag_statsGet statistics about DAG runs (success/failure counts by state). Use this tool when the user asks about: - "What's the overall health of my DAGs?" or "Show me DAG statistics" - "How many DAG runs succeeded/failed?" or "What's the success rate?" - "Give me a summary of DAG run states" - "How many runs are currently running/queued?" - "Show me stats for specific DAGs" Returns statistics showing counts of DAG runs grouped by state: - success: Number of successful runs - failed: Number of failed runs - running: Number of currently running runs - queued: Number of queued runs - And other possible states
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_ids": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional list of DAG IDs to filter by. Pass a list even for a\nsingle DAG, for example [\"example_dag\"]. If not provided, returns\nstats for all DAGs."
    }
  },
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_poolGet detailed information about a specific resource pool. Use this tool when the user asks about: - "Show me details for pool X" or "What's the status of pool Y?" - "How many slots are available in pool Z?" or "Is pool X full?" - "What's using pool Y?" or "How many tasks are running in pool X?" - "Get information about the default_pool" or "Show me pool details" Pools are used to limit parallelism for specific sets of tasks. This returns detailed real-time information about a specific pool's capacity and utilization. Returns detailed pool information including: - name: Name of the pool - slots: Total number of available slots in the pool - occupied_slots: Number of currently occupied slots (running + queued) - running_slots: Number of slots with currently running tasks - queued_slots: Number of slots with queued tasks waiting to run - open_slots: Number of available slots (slots - occupied_slots) - description: Human-readable description of the pool's purpose
Input schema
{
  "additionalProperties": false,
  "properties": {
    "pool_name": {
      "type": "string",
      "description": "The name of the pool to get details for (e.g., \"default_pool\")"
    }
  },
  "required": [
    "pool_name"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_system_healthGet overall Airflow system health - import errors, warnings, and DAG stats. USE THIS TOOL WHEN you need a quick health check of the Airflow system. Returns a consolidated view of potential issues across the entire system. This is the preferred tool when: - User asks "Are there any problems with Airflow?" - User asks "Show me the system health" or "Any errors?" - You want to do a morning health check - You're starting an investigation and want to see the big picture Returns combined data: - Import errors (DAG files that failed to parse) - DAG warnings (deprecations, configuration issues) - DAG statistics (run counts by state) if available - Version information Returns: JSON with system health overview
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_taskGet detailed information about a specific task definition in a DAG. Use this tool when the user asks about: - "Show me details for task X in DAG Y" or "What does task Z do?" - "What operator does task A use?" or "What's the configuration of task B?" - "Tell me about task C" or "Get task definition for D" - "What are the dependencies of task E?" or "Which tasks does F depend on?" Returns task definition information including: - task_id: Unique identifier for the task - task_display_name: Human-readable display name - owner: Who owns this task - start_date: When this task becomes active - end_date: When this task becomes inactive (if set) - trigger_rule: When this task should run (all_success, one_failed, etc.) - depends_on_past: Whether task depends on previous run's success - wait_for_downstream: Whether to wait for downstream tasks - retries: Number of retry attempts - retry_delay: Time between retries - execution_timeout: Maximum execution time - operator_name: Type of operator (PythonOperator, BashOperator, etc.) - pool: Resource pool assignment - queue: Queue for executor - downstream_task_ids: List of tasks that depend on this task - upstream_task_ids: List of tasks this task depends on
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG containing the task"
    },
    "task_id": {
      "type": "string",
      "description": "The ID of the task to get details for"
    }
  },
  "required": [
    "dag_id",
    "task_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_task_instanceGet detailed information about a specific task instance execution. Use this tool when the user asks about: - "Show me details for task X in DAG run Y" or "What's the status of task Z?" - "Why did task A fail?" or "When did task B start/finish?" - "What's the duration of task C?" or "Show me task execution details" - "Get logs for task D" or "What operator does task E use?" Returns detailed task instance information including: - task_id: Name of the task - state: Current state (success, failed, running, queued, etc.) - start_date: When the task started - end_date: When the task finished - duration: How long the task ran - try_number: Which attempt this is - max_tries: Maximum retry attempts - operator: What operator type (PythonOperator, BashOperator, etc.) - executor_config: Executor configuration - pool: Resource pool assignment
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    },
    "task_id": {
      "type": "string",
      "description": "The ID of the task within the DAG"
    }
  },
  "required": [
    "dag_id",
    "dag_run_id",
    "task_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_task_logsGet logs for a specific task instance execution. Use this tool when the user asks about: - "Show me the logs for task X" or "Get logs for task Y" - "What did task Z output?" or "Show me task execution logs" - "Why did task A fail?" (to see error messages in logs) - "What happened during task B execution?" - "Show me the stdout/stderr for task C" - "Debug task D" or "Troubleshoot task E" Returns the actual log output from the task execution, which includes: - Task execution output (stdout/stderr) - Error messages and stack traces (if task failed) - Timing information - Any logged messages from the task code This is essential for debugging failed tasks or understanding what happened during task execution.
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG (e.g., \"example_dag\")"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run (e.g., \"manual__2024-01-01T00:00:00+00:00\")"
    },
    "task_id": {
      "type": "string",
      "description": "The ID of the task within the DAG (e.g., \"extract_data\")"
    },
    "try_number": {
      "default": 1,
      "type": "integer",
      "description": "The task try/attempt number, 1-indexed (default: 1).\n        Use higher numbers to get logs from retry attempts."
    },
    "map_index": {
      "default": -1,
      "type": "integer",
      "description": "For mapped tasks, which map index to get logs for.\n       Use -1 for non-mapped tasks (default: -1)."
    }
  },
  "required": [
    "dag_id",
    "dag_run_id",
    "task_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_upstream_asset_eventsGet asset events that triggered a specific DAG run. Use this tool when the user asks about: - "What triggered this DAG run?" - "Which asset events caused this run to start?" - "Why did DAG X start running?" - "Show me the upstream triggers for this run" - "What data changes triggered this pipeline run?" This is useful for understanding causation in data-aware scheduling. When a DAG is scheduled based on asset updates, this tool shows which specific asset events triggered the run. Returns information including: - dag_id: The DAG that was triggered - dag_run_id: The specific run - triggered_by_events: List of asset events that caused this run - event_count: Number of triggering events Each event includes: - asset_uri or dataset_uri: The asset that was updated - source_dag_id: The DAG that produced the event - source_run_id: The run that produced the event - timestamp: When the event occurred
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG"
    },
    "dag_run_id": {
      "type": "string",
      "description": "The ID of the DAG run (e.g., \"scheduled__2024-01-01T00:00:00+00:00\")"
    }
  },
  "required": [
    "dag_id",
    "dag_run_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
get_variableGet a specific Airflow variable by key. Use this tool when the user asks about: - "What's the value of variable X?" or "Show me variable Y" - "Get variable Z" or "What does variable A contain?" - "What's stored in variable B?" or "Look up variable C" Variables are key-value pairs stored in Airflow's metadata database that can be accessed by DAGs at runtime. They're commonly used for configuration values, API keys, or other settings that need to be shared across DAGs. Returns variable information including: - key: The variable's key/name - value: The variable's value (may be masked if marked as sensitive) - description: Optional description of the variable's purpose
Input schema
{
  "additionalProperties": false,
  "properties": {
    "variable_key": {
      "type": "string",
      "description": "The key/name of the variable to retrieve"
    }
  },
  "required": [
    "variable_key"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_asset_eventsList asset/dataset events with optional filtering. Use this tool when the user asks about: - "What asset events were produced by DAG X?" - "Show me dataset events from run Y" - "Debug why downstream DAG wasn't triggered" - "What assets did this pipeline produce?" - "List recent asset update events" Asset events are produced when a task updates an asset/dataset. These events can trigger downstream DAGs that depend on those assets (data-aware scheduling). Returns event information including: - uri: The asset that was updated - source_dag_id: The DAG that produced this event - source_run_id: The DAG run that produced this event - source_task_id: The task that produced this event - timestamp: When the event was created
Input schema
{
  "additionalProperties": false,
  "properties": {
    "source_dag_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter events by the DAG that produced them"
    },
    "source_run_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter events by the DAG run that produced them"
    },
    "source_task_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter events by the task that produced them"
    },
    "limit": {
      "default": 100,
      "type": "integer",
      "description": "Maximum number of events to return (default: 100)"
    }
  },
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_assetsGet data assets and datasets tracked by Airflow (data lineage). Use this tool when the user asks about: - "What datasets exist?" or "List all assets" - "What data does this DAG produce/consume?" - "Show me data dependencies" or "What's the data lineage?" - "Which DAGs use dataset X?" - Data freshness or update events Assets represent datasets or files that DAGs produce or consume. This enables data-driven scheduling where DAGs wait for data availability. Returns asset information including: - uri: Unique identifier for the asset (e.g., s3://bucket/path) - id: Internal asset ID - created_at: When this asset was first registered - updated_at: When this asset was last updated - consuming_dags: Which DAGs depend on this asset - producing_tasks: Which tasks create/update this asset Returns: JSON with list of all assets and their producing/consuming relationships
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_connectionsGet connection configurations for external systems (databases, APIs, services). Use this tool when the user asks about: - "What connections are configured?" or "List all connections" - "How do I connect to database X?" - "What's the connection string for Y?" - "Which databases/services are available?" - Finding connection details by name or type Connections store credentials and connection info for external systems that DAGs interact with (databases, S3, APIs, etc.). Returns connection metadata including: - connection_id: Unique name for this connection - conn_type: Type (postgres, mysql, s3, http, etc.) - description: Human-readable description - host: Server hostname or IP - port: Port number - schema: Database schema or path - login: Username (passwords excluded for security) - extra: Additional connection parameters as JSON IMPORTANT: Passwords are NEVER returned for security reasons. Returns: JSON with list of all connections (credentials excluded)
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_dag_runsGet execution history and status of DAG runs (workflow executions). Use this tool when the user asks about: - "What DAG runs have executed?" or "Show me recent runs" - "Which runs failed/succeeded?" - "What's the status of my workflows?" - "When did DAG X last run?" - Execution times, durations, or states - Finding runs by date or status Returns execution metadata including: - dag_run_id: Unique identifier for this execution - dag_id: Which DAG this run belongs to - state: Current state (running, success, failed, queued) - execution_date: When this run was scheduled to execute - start_date: When execution actually started - end_date: When execution completed (if finished) - run_type: manual, scheduled, or backfill - conf: Configuration passed to this run
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional DAG ID to filter runs for a specific DAG.\n    If not provided, returns runs across all DAGs."
    },
    "limit": {
      "default": 100,
      "type": "integer",
      "description": "Maximum number of DAG runs to return (default: 100)."
    },
    "offset": {
      "default": 0,
      "type": "integer",
      "description": "Offset for pagination (default: 0). Use together with `limit`\n    to page through DAGs that have more than `limit` runs."
    },
    "order_by": {
      "default": "-start_date",
      "type": "string",
      "description": "Sort field; prefix with '-' for descending order.\n      Defaults to '-start_date' so the most recent runs are\n      returned first. The Airflow API default would be 'id'\n      ascending (oldest first), which is rarely what callers want."
    }
  },
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_dag_warningsGet warnings and issues detected in DAG definitions. Use this tool when the user asks about: - "Are there any DAG warnings?" or "Show me DAG issues" - "What problems exist with my DAGs?" or "Any DAG errors?" - "Check DAG health" or "Show me DAG validation warnings" - "What's wrong with my workflows?" Returns warnings about DAG configuration issues including: - dag_id: Which DAG has the warning - warning_type: Type of warning (e.g., deprecation, configuration issue) - message: Description of the warning - timestamp: When the warning was detected Returns: JSON with list of DAG warnings and their details
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_dagsGet information about all Apache Airflow DAGs (Directed Acyclic Graphs). Use this tool when the user asks about: - "What DAGs are available?" or "List all DAGs" - "Show me the workflows" or "What pipelines exist?" - "Which DAGs are paused/active?" - DAG schedules, descriptions, or tags - Finding a specific DAG by name Returns comprehensive DAG metadata including: - dag_id: Unique identifier for the DAG - is_paused: Whether the DAG is currently paused - is_active: Whether the DAG is active - schedule_interval: How often the DAG runs - description: Human-readable description - tags: Labels/categories for the DAG - owners: Who maintains the DAG - file_token: Location of the DAG file Returns: JSON with list of all DAGs and their complete metadata
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_import_errorsGet import errors from DAG files that failed to parse or load. Use this tool when the user asks about: - "Are there any import errors?" or "Show me import errors" - "Why isn't my DAG showing up?" or "DAG not appearing in Airflow" - "What DAG files have errors?" or "Show me broken DAGs" - "Check for syntax errors" or "Are there any parsing errors?" - "Why is my DAG file failing to load?" Import errors occur when DAG files have problems that prevent Airflow from parsing them, such as: - Python syntax errors - Missing imports or dependencies - Module not found errors - Invalid DAG definitions - Runtime errors during file parsing Returns import error details including: - import_error_id: Unique identifier for the error - timestamp: When the error was detected - filename: Path to the DAG file with the error - stack_trace: Complete error message and traceback Returns: JSON with list of import errors and their stack traces
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_pluginsGet information about installed Airflow plugins. Use this tool when the user asks about: - "What plugins are installed?" or "List all plugins" - "Show me the plugins" or "Which plugins are enabled?" - "Is plugin X installed?" or "Do we have any custom plugins?" - "What's in the plugins directory?" Plugins extend Airflow functionality by adding custom operators, hooks, views, menu items, or other components. This returns information about all plugins discovered by Airflow's plugin system. Returns information about installed plugins including: - name: Name of the plugin - hooks: Custom hooks provided by the plugin - executors: Custom executors provided by the plugin - macros: Custom macros provided by the plugin - flask_blueprints: Flask blueprints for custom UI pages - appbuilder_views: Flask-AppBuilder views for admin interface - appbuilder_menu_items: Custom menu items in the UI Returns: JSON with list of all installed plugins and their components
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_poolsGet resource pools for managing task concurrency and resource allocation. Use this tool when the user asks about: - "What pools are configured?" or "List all pools" - "Show me the resource pools" or "What pools exist?" - "How many slots does pool X have?" or "What's the pool capacity?" - "Which pools are available?" or "What's the pool configuration?" Pools are used to limit parallelism for specific sets of tasks. Each pool has a certain number of slots, and tasks assigned to a pool will only run if there are available slots. This is useful for limiting concurrent access to resources like databases or external APIs. Returns pool information including: - name: Name of the pool - slots: Total number of available slots in the pool - occupied_slots: Number of currently occupied slots - running_slots: Number of slots with running tasks - queued_slots: Number of slots with queued tasks - open_slots: Number of available slots (slots - occupied_slots) - description: Human-readable description of the pool's purpose Returns: JSON with list of all pools and their current utilization
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_providersGet information about installed Airflow provider packages. Use this tool when the user asks about: - "What providers are installed?" or "List all providers" - "What integrations are available?" or "Show me installed packages" - "Do we have the AWS provider?" or "Is the Snowflake provider installed?" - "What version of provider X is installed?" Returns information about installed provider packages including: - package_name: Name of the provider package (e.g., "apache-airflow-providers-amazon") - version: Version of the provider package - description: What the provider does - provider_info: Details about operators, hooks, and sensors included Returns: JSON with list of all installed provider packages and their details
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_tasksGet all tasks defined in a specific DAG. Use this tool when the user asks about: - "What tasks are in DAG X?" or "List all tasks for DAG Y" - "Show me the tasks in this workflow" or "What's in the DAG?" - "What are the steps in DAG Z?" or "Show me the task structure" - "What does this DAG do?" or "Explain the workflow steps" Returns information about all tasks in the DAG including: - task_id: Unique identifier for the task - task_display_name: Human-readable display name - owner: Who owns this task - operator_name: Type of operator (PythonOperator, BashOperator, etc.) - start_date: When this task becomes active - end_date: When this task becomes inactive (if set) - trigger_rule: When this task should run - retries: Number of retry attempts - pool: Resource pool assignment - downstream_task_ids: List of tasks that depend on this task - upstream_task_ids: List of tasks this task depends on
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to list tasks for"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
list_variablesGet all Airflow variables (key-value configuration pairs). Use this tool when the user asks about: - "What variables are configured?" or "List all variables" - "Show me the variables" or "What variables exist?" - "What configuration variables are available?" - "Show me all variable keys" Variables are key-value pairs stored in Airflow's metadata database that can be accessed by DAGs at runtime. They're commonly used for configuration values, environment-specific settings, or other data that needs to be shared across DAGs without hardcoding in the DAG files. Returns variable information including: - key: The variable's key/name - value: The variable's value (may be masked if marked as sensitive) - description: Optional description of the variable's purpose IMPORTANT: Sensitive variables (like passwords, API keys) may have their values masked in the response for security reasons. Returns: JSON with list of all variables and their values
Input schema
{
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read onlyNon-destructiveIdempotentOpen world—
pause_dagPause a DAG to prevent new scheduled runs from starting. Use this tool when the user asks to: - "Pause DAG X" or "Stop DAG Y from running" - "Disable DAG Z" or "Prevent new runs of DAG X" - "Turn off DAG scheduling" or "Suspend DAG execution" When a DAG is paused: - No new scheduled runs will be created - Currently running tasks will complete - Manual triggers are still possible - The DAG remains visible in the UI with a paused indicator IMPORTANT: This is a write operation that modifies Airflow state. The DAG will remain paused until explicitly unpaused.
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to pause (e.g., \"example_dag\")"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—WritesNon-destructiveIdempotentOpen world—
trigger_dagTrigger a new DAG run (start a workflow execution manually). Use this tool when the user asks to: - "Run DAG X" or "Start DAG Y" or "Execute DAG Z" - "Trigger a run of DAG X" or "Kick off DAG Y" - "Run this workflow" or "Start this pipeline" - "Execute DAG X with config Y" or "Trigger DAG with parameters" - "Start a manual run" or "Manually execute this DAG" This creates a new DAG run that will be picked up by the scheduler and executed. You can optionally pass configuration parameters that will be available to the DAG during execution via the `conf` context variable. NOTE: This tool automatically unpauses the DAG if it is paused before triggering. This ensures the DAG run will execute and not get stuck in a queued state. IMPORTANT: This is a write operation that modifies Airflow state by creating a new DAG run. Use with caution. Returns information about the newly triggered DAG run including: - dag_run_id: Unique identifier for the new execution - dag_id: Which DAG was triggered - state: Initial state (typically 'queued') - execution_date: When this run is scheduled to execute - start_date: When execution started (may be null if queued) - run_type: Type of run (will be 'manual') - conf: Configuration passed to the run - external_trigger: Set to true for manual triggers
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to trigger (e.g., \"example_dag\")"
    },
    "conf": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional configuration dictionary to pass to the DAG run.\n  This will be available in the DAG via context['dag_run'].conf"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": true
}
—WritesNon-destructiveNon-idempotentOpen world—
trigger_dag_and_waitTrigger a DAG run and wait for it to complete before returning. Use this tool when the user asks to: - "Run DAG X and wait for it to finish" or "Execute DAG Y and tell me when it's done" - "Trigger DAG Z and wait for completion" or "Run this pipeline synchronously" - "Start DAG X and let me know the result" or "Execute and monitor DAG Y" - "Run DAG X and show me if it succeeds or fails" This is a BLOCKING operation that will: 1. Automatically unpause the DAG if it is paused 2. Trigger the specified DAG 3. Poll for status automatically (interval scales with timeout) 4. Return once the DAG run reaches a terminal state (success, failed, upstream_failed) 5. Include details about any failed tasks if the run was not successful NOTE: This tool automatically unpauses the DAG if it is paused before triggering. This ensures the DAG run will execute and not get stuck in a queued state. IMPORTANT: This tool blocks until the DAG completes or times out. For long-running DAGs, consider using `trigger_dag` instead and checking status separately with `get_dag_run`. Default timeout is 60 minutes. Adjust the `timeout` parameter for longer DAGs. Returns information about the completed DAG run including: - dag_id: Which DAG was run - dag_run_id: Unique identifier for this execution - state: Final state (success, failed, upstream_failed) - start_date: When execution started - end_date: When execution completed - elapsed_seconds: How long we waited - timed_out: Whether we hit the timeout before completion - failed_tasks: List of failed task details (only if state != success)
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to trigger (e.g., \"example_dag\")"
    },
    "conf": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional configuration dictionary to pass to the DAG run.\n  This will be available in the DAG via context['dag_run'].conf"
    },
    "timeout": {
      "default": 3600,
      "type": "number",
      "description": "Maximum time to wait in seconds (default: 3600.0 / 60 minutes)"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": true
}
—WritesNon-destructiveNon-idempotentOpen world—
unpause_dagUnpause a DAG to allow scheduled runs to resume. Use this tool when the user asks to: - "Unpause DAG X" or "Resume DAG Y" - "Enable DAG Z" or "Start DAG scheduling again" - "Turn on DAG X" or "Activate DAG Y" When a DAG is unpaused: - The scheduler will create new runs based on the schedule - Any missed runs (depending on catchup setting) may be created - The DAG will appear active in the UI IMPORTANT: This is a write operation that modifies Airflow state. New DAG runs will be scheduled according to the DAG's schedule_interval.
Input schema
{
  "additionalProperties": false,
  "properties": {
    "dag_id": {
      "type": "string",
      "description": "The ID of the DAG to unpause (e.g., \"example_dag\")"
    }
  },
  "required": [
    "dag_id"
  ],
  "type": "object"
}
Output schema
{
  "properties": {
    "result": {
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "type": "object",
  "x-fastmcp-wrap-result": true
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—WritesNon-destructiveIdempotentOpen world—

Resources 4

  • resource_configairflow://config

    Get Airflow configuration as a resource.

  • resource_pluginsairflow://plugins

    Get installed Airflow plugins as a resource.

  • resource_providersairflow://providers

    Get installed Airflow providers as a resource.

  • resource_versionairflow://version

    Get Airflow version information as a resource.

Resource templates 0

  • None observed.

Prompts 3

  • daily_health_checkdaily_health_check

    Morning health check workflow for Airflow.

  • onboard_new_dagonboard_new_dag

    Guide to understanding a new DAG.

  • troubleshoot_failed_dagtroubleshoot_failed_dag

    Step-by-step guide to troubleshoot a failed DAG.

Remote endpoints

EndpointTransportAuthenticationHealthObserved
No verified remote endpoint is linked.

astro-airflow-mcp Server questions

How do I install astro-airflow-mcp Server?

Install the selected package version with: python -m pip install 'astro-airflow-mcp==0.9.1'

What tools does astro-airflow-mcp Server provide?

astro-airflow-mcp Server exposed 34 tools during independent protocol observation, including clear_dag_run, clear_task_instances, delete_dag_run, diagnose_dag_run, explore_dag, get_airflow_config, get_airflow_version, get_dag_details, and others.

Is astro-airflow-mcp Server secure?

Our scanner tested version 0.9.1 without proving a finding in the methods exercised. This is not a guarantee that every deployment is secure.

Explore related MCP server guides

Curated product and capability guides containing this catalog record.

Official vs Community MCP Servers

Let’s talk about MCP security.

Share your details and our security team will contact you.