prefect-mcp-server
OfficialThis server is a read-only MCP server for inspecting Prefect Cloud and self-hosted Prefect instances, with tools for monitoring resources, diagnosing failures, and searching Prefect documentation.
Get oriented:
orientationexplains the server;get_identityshows which Prefect instance/workspace you are connected to.Monitor dashboards:
get_dashboardreturns flow run statistics, work pool status, and active concurrency limits to spot bottlenecks.Inspect deployments:
get_deploymentslists/filters deployments with details on schedules, work pools, concurrency limits, and recent runs.List flows and runs:
get_flows,get_flow_runs, andget_task_runssupport advanced filtering by state, tags, names, time, and IDs.Read logs and events:
get_flow_run_logsretrieves execution logs;read_eventsprovides structured workflow events with time/type filters.Review work pools:
get_work_poolssurfaces pool health, queue info, active workers, and diagnostic hints.Inspect automations:
get_automationslists automation rules and triggers;get_object_schemareturns schemas for object types.Check rate limits:
review_rate_limitsidentifies Cloud API throttling periods and affected operation groups.Search documentation:
docs_search_prefectfinds Prefect docs, CLI/SDK guidance, and deployment patterns.
Provides tools for interacting with Prefect workflow orchestration, enabling monitoring and inspection of deployments, flow runs, task runs, work pools, logs, events, and debugging of workflows.
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., "@prefect-mcp-server show me the status of all active flows"
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.
prefect-mcp-server
This project is under active development and may change drastically at any time.
This is an experimental MCP server for Prefect. APIs, features, and behaviors are subject to change without notice. We encourage you to try it out, provide feedback, and contribute. Please create issues or open PRs with your ideas and suggestions.
An MCP server for interacting with prefect resources.
The server gives MCP clients read-only tools for inspecting Prefect Cloud and self-hosted Prefect instances, plus a docs proxy so assistants can look up current Prefect CLI, SDK, and deployment guidance.
Choose Your Setup
See the agent setup guides for client-specific instructions and setup prompts, or give your agent the plain-text setup index.
Use case | Recommended setup | Authentication |
ChatGPT | Prefect Cloud OAuth | |
Claude | Prefect Cloud OAuth | |
Claude Code or Codex | Prefect plugin for your client | Prefect Cloud OAuth |
Claude Tag or Cowork | The same Prefect plugin | Organization-managed Prefect Cloud OAuth |
Local MCP client |
| Active local Prefect profile or env vars |
Self-hosted Prefect or custom Cloud workspace | Self-hosted HTTP or stdio server | API key, basic auth, env vars, or headers |
Team-operated shared server | HTTP deployment with per-request headers | User or service-account credentials in headers |
Related MCP server: n8n-manager-mcp
ChatGPT Plugin and Claude Connector
Install the Prefect plugin in ChatGPT or connect the Prefect connector in Claude. Sign in to Prefect Cloud and select the workspaces the assistant may read. Both use Prefect's hosted MCP server; no local installation or API key is required.
In ChatGPT, installing the plugin and connecting your Prefect account are separate steps. Start a chat with Prefect selected and complete the Connect prompt. If an existing chat does not discover the newly connected tools, start a fresh chat. In Claude, connect from the directory listing and approve tool calls when prompted.
Try asking: "Which Prefect workspaces can you access?" Then choose a workspace and ask: "Why did my most recent failed flow run fail?" The hosted tools inspect runs, logs, and workspace health and search documentation; they do not change Prefect state.
See the Prefect MCP setup guide for more connection options.
Claude Code Plugin
The easiest setup for Claude Code is the Prefect plugin:
# add from marketplace
/plugin marketplace add prefecthq/prefect-mcp-server
# install the plugin
/plugin install prefectThis connects Claude to Prefect's hosted, read-only MCP server for diagnostics, documentation, and current release notes. Claude opens Prefect Cloud OAuth during installation so you can select the workspaces it may access.
The plugin does not read~/.prefect/profiles.toml or require a local Prefect
installation. For self-hosted Prefect or explicit credentials, use the local
uvx setup below.
Codex Plugin
The same hosted MCP server and workflow guidance are available as a Codex plugin:
# add from marketplace
codex plugin marketplace add prefecthq/prefect-mcp-server
# install the plugin
codex plugin add prefect@prefectLike the Claude Code plugin, Codex authenticates directly with Prefect Cloud OAuth. The plugin contains no API keys or placeholder credentials.
If you also configure a local MCP server, give it a distinct name such as
prefect-local. The plugin endpoint uses Prefect Cloud OAuth; a local server uses
the Prefect profile or environment variables available to its process. Call
get_identity before acting on workspace state to confirm which target is active.
The same plugin bundle is suitable for Cowork and Claude Tag because it references the hosted MCP URL instead of launching a process on the user's machine. Claude Tag administrators attach it and its Prefect credential to the appropriate Access bundle.
Prefect's privacy policy and terms and conditions apply to the hosted service.
Run Locally
When running the MCP server locally with stdio transport, it automatically uses your local Prefect configuration from ~/.prefect/profiles.toml if available.
# minimal setup - inherits from local Prefect profile
claude mcp add prefect \
-- uvx --from prefect-mcp prefect-mcp-server
# or explicitly set credentials
claude mcp add prefect \
-e PREFECT_API_URL=https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID] \
-e PREFECT_API_KEY=your-cloud-api-key \
-- uvx --from prefect-mcp prefect-mcp-serverFor self-hosted Prefect servers with basic auth,use PREFECT_API_AUTH_STRING instead of PREFECT_API_KEY.
Prefect Cloud users on Team, Pro, and Enterprise plans can use service accounts for API authentication. Pro and Enterprise users can restrict service accounts to read-only access since this MCP server requires no write permissions.
Deploy Your Own Server
Deploy your own server when you need a custom Prefect API target, self-hosted Prefect, a private network, or an API-key-based team deployment.
Fork this repository on GitHub:
gh repo fork prefecthq/prefect-mcp-serverDeploy it on Prefect Horizon or FastMCP Cloud.
Configure the server:
server path:
src/prefect_mcp_server/server.pyrequirements:
pyproject.tomlenvironment variables:
PREFECT_API_URL:https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]PREFECT_API_KEY: your Prefect Cloud API keyPREFECT_API_AUTH_STRING: basic auth credentials for self-hosted Prefect, if neededOPENAI_APPS_CHALLENGE_TOKEN: domain-verification token for an OpenAI public plugin submission, if needed
Add the deployed HTTP URL to your MCP client:
claude mcp add prefect --transport http https://your-server-name.fastmcp.app/mcp
For self-hosted deployments, environment variables are configured on the deployed MCP server, not in your MCP client configuration. The MCP host authenticates access to the MCP server, while this server uses the configured Prefect credentials to access Prefect.
Prefect operates a hosted MCP deployment that uses HTTP MCP OAuth instead of asking users to create or paste API keys. This is the endpoint used by the Prefect plugin.
A user can also add the hosted MCP URL directly to a compatible client:
claude mcp add prefect \
--transport http https://prefect.fastmcp.app/mcpThe MCP client discovers OAuth metadata from the server, opens a browser for Prefect Cloud authentication, and asks the user to choose the workspaces this MCP client may read. After authentication, the assistant can list the consented workspaces and call the same read-only Prefect tools against those workspaces.
Cloud OAuth mode:
uses HTTP MCP OAuth, not stdio credentials
does not require
PREFECT_API_KEYin the MCP clientlimits workspace-scoped tools to the workspaces selected during consent
requires workspace-scoped tool calls to include a
workspace_idkeeps the shared read-only tool definitions from this repository
Useful first prompts:
"Tell me what Prefect workspaces you can access."
"Look across all authorized workspaces and summarize recent failed flow runs."
"Compare deployment health between my staging and production workspaces."
Unattended Service-Account Clients
Browser OAuth is the right flow for human-operated MCP clients. Workflow agents and other noninteractive runtimes should use service-account MCP OAuth credentials issued by Prefect Cloud, exchange those credentials for an MCP bearer token, and connect to the hosted MCP URL with an Authorization header.
export PREFECT_MCP_CLOUD_CLIENT_ID=...
export PREFECT_MCP_CLOUD_CLIENT_SECRET=...
uvx --from prefect-mcp prefect-mcp-cloud-tokenAgents can also exchange credentials in process before constructing their MCP client:
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport
from prefect_mcp_server.cloud_oauth import exchange_client_credentials_token
token = await exchange_client_credentials_token()
transport = StreamableHttpTransport(
url="https://prefect.fastmcp.app/mcp",
headers={"Authorization": f"Bearer {token.access_token}"},
)
async with Client(transport) as client:
print(await client.list_tools())The token response includes expires_in. Treat an agent as long-running if it may keep using the MCP connection longer than that returned lifetime. In that case, request a new token with the same client credentials before reusing the MCP connection. This follows the OAuth client-credentials pattern: the client credentials are the renewable secret, and the access token is the time-limited bearer credential sent to the MCP server.
Cloud OAuth Deployment Entrypoint
Prefect-operated Cloud OAuth deployments use a dedicated entrypoint:
server path:
src/prefect_mcp_server/cloud.pyrequired runtime flag:
PREFECT_MCP_CLOUD_ENABLED=true
This entrypoint reuses the same read-only tool definitions as the local/API-key server, adds Prefect Cloud OAuth, and adds Cloud OAuth-only workspace discovery. If OAuth is not configured, the Cloud OAuth entrypoint fails at import time instead of starting an unprotected server.
Cloud OAuth mode is selected by deploying src/prefect_mcp_server/cloud.py. The hosted server validates Prefect Cloud-issued MCP OAuth access tokens against Prefect Cloud's JWKS endpoint, so the MCP runtime does not need access to Cloud token-signing secrets.
Cloud OAuth settings use the PREFECT_MCP_CLOUD_ prefix:
Environment variable | Purpose |
| Set to |
| Optional override for the Prefect API base URL |
| Optional override for auth helper endpoints |
| Optional override for the Prefect Cloud MCP OAuth JWKS endpoint |
| Optional override for advertised OAuth authorization server |
| Optional override for the expected token audience; defaults to the hosted MCP resource URL ( |
| Optional service-account MCP OAuth client id for unattended token exchange |
| Optional service-account MCP OAuth client secret for unattended token exchange |
| Public base URL for the hosted MCP server |
| Legacy alias for the public base URL |
For centrally-hosted deployments where multiple users connect to the same MCP server instance, credentials can be passed via HTTP headers instead of environment variables. This enables each request to authenticate with its own Prefect workspace.
Supported headers:
X-Prefect-Api-Url: Prefect API URL, required for both Cloud and self-hosted PrefectX-Prefect-Api-Key: Prefect Cloud API keyX-Prefect-Api-Auth-String: basic auth credentials for self-hosted Prefect, formatted asusername:password
Claude Code CLI:
claude mcp add-json prefect '{
"type": "http",
"url": "https://your-server.fastmcp.app/mcp",
"headers": {
"X-Prefect-Api-Url": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"X-Prefect-Api-Key": "your-api-key"
}
}'Claude Desktop app:
{
"mcpServers": {
"prefect": {
"type": "http",
"url": "https://your-server.fastmcp.app/mcp",
"headers": {
"X-Prefect-Api-Url": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"X-Prefect-Api-Key": "your-api-key"
}
}
}
}Python with FastMCP client:
from fastmcp.client import Client
from fastmcp.client.transports import StreamableHttpTransport
headers = {
"X-Prefect-Api-Url": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"X-Prefect-Api-Key": "your-api-key",
}
transport = StreamableHttpTransport(
url="https://your-server.fastmcp.app/mcp",
headers=headers,
)
client = Client(transport=transport)
async with client:
result = await client.call_tool("get_identity", {})
print(result)When HTTP headers are provided, they take precedence over environment variables. If no headers are present, the server falls back to the configured environment variables or local Prefect profile.
Other MCP Clients
This MCP server works with any MCP-compatible client. Most local clients use the same stdio command and optional environment variables.
Cursor (.cursor/mcp.json):
{
"mcpServers": {
"prefect": {
"command": "uvx",
"args": ["--from", "prefect-mcp", "prefect-mcp-server"],
"env": {
"PREFECT_API_URL": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"PREFECT_API_KEY": "your-api-key"
}
}
}
}Codex CLI:
codex mcp add prefect -- uvx --from prefect-mcp prefect-mcp-server
codex mcp add prefect \
--env PREFECT_API_URL=https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID] \
--env PREFECT_API_KEY=your-api-key \
-- uvx --from prefect-mcp prefect-mcp-serverOr edit ~/.codex/config.toml directly:
[mcp.prefect]
command = "uvx"
args = ["--from", "prefect-mcp", "prefect-mcp-server"]
[mcp.prefect.env]
PREFECT_API_URL = "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]"
PREFECT_API_KEY = "your-api-key"Gemini CLI:
gemini mcp add prefect uvx --from prefect-mcp prefect-mcp-server
gemini mcp add prefect \
-e PREFECT_API_URL=https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID] \
-e PREFECT_API_KEY=your-api-key \
uvx --from prefect-mcp prefect-mcp-serverOr edit ~/.gemini/settings.json directly:
{
"mcpServers": {
"prefect": {
"command": "uvx",
"args": ["--from", "prefect-mcp", "prefect-mcp-server"],
"env": {
"PREFECT_API_URL": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"PREFECT_API_KEY": "your-api-key"
}
}
}
}Kiro (~/.kiro/settings/mcp.json):
{
"mcpServers": {
"prefect": {
"command": "uvx",
"args": ["--from", "prefect-mcp", "prefect-mcp-server"],
"env": {
"PREFECT_API_URL": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"PREFECT_API_KEY": "your-api-key"
}
}
}
}VS Code with GitHub Copilot (.vscode/mcp.json):
{
"servers": {
"prefect": {
"command": "uvx",
"args": ["--from", "prefect-mcp", "prefect-mcp-server"],
"env": {
"PREFECT_API_URL": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"PREFECT_API_KEY": "your-api-key"
}
}
}
}Windsurf (~/.codeium/windsurf/mcp_config.json):
{
"mcpServers": {
"prefect": {
"command": "uvx",
"args": ["--from", "prefect-mcp", "prefect-mcp-server"],
"env": {
"PREFECT_API_URL": "https://api.prefect.cloud/api/accounts/[ACCOUNT_ID]/workspaces/[WORKSPACE_ID]",
"PREFECT_API_KEY": "your-api-key"
}
}
}
}Most MCP clients follow a similar configuration pattern. If your client is not listed here, check its documentation for MCP server configuration. Thecommand, args, and env values above usually work with minor adjustments to the config format.
Capabilities
This server enables MCP clients to interact with Prefect read-only APIs:
Monitoring and inspection
View dashboard overviews with flow run statistics and work pool status
Query deployments, flows, flow runs, task runs, work pools, and automations with advanced filtering
Retrieve detailed execution logs from flow runs
Track events across your workflow ecosystem
Review rate limit usage for Prefect Cloud
Documentation access
Search current Prefect documentation through the mounted docs MCP server
Find current CLI and SDK syntax for write operations
Look up deployment, work pool, and automation patterns
Intelligent debugging
Get contextual guidance for troubleshooting failed flow runs
Diagnose deployment issues, including concurrency problems and unhealthy work pools
Identify root causes of workflow failures
Development
# clone the repo
gh repo clone prefecthq/prefect-mcp-server && cd prefect-mcp-server
# install dev deps and pre-commit hooks
just setup
# run tests
just testEvals
This project includes scenario tests that connect Pydantic AI agents to the MCP server and validate that they can solve realistic Prefect support tasks. See evals/README.md.
Evals should be written like support case reproductions: set up a workspace state that represents a real customer problem, ask the agent the kind of question a user or support engineer would ask, and verify the final answer identifies the concrete cause or next action. Protocol behavior such as OAuth token validation belongs in unit tests; evals should prove that the MCP server helps an agent solve user-facing Prefect problems.
uv run pytest evalsLinks
FastMCP - the framework used to build this MCP server
Prefect Horizon - managed MCP deployment
Prefect - workflow orchestration
Model Context Protocol - the MCP specification
Claude Code - an MCP client
mcp-name: io.github.PrefectHQ/prefect-mcp-server
Available Tools
14 toolsdocs_search_prefectB
Search the Prefect knowledgebase for documentation on concepts, usage examples, and best practices.
Inputs: query (required), top_k. Returns: object
get_automationsA
Get automations with optional filters.
Returns compact summaries by default (trigger_type, action_count). Filter by specific ID(s) for full detail including trigger config, actions, actions_on_trigger, and actions_on_resolve.
Filter operators:
id.any_: Match specific automation IDs
name.any_: Match automation names
enabled.eq_: Filter by enabled state
Examples: - List all automations: get_automations() - Full detail: get_automations(filter={"id": {"any_": [""]}}) - Get by name: get_automations(filter={"name": {"any_": ["my-automation"]}}) - Only enabled: get_automations(filter={"enabled": {"eq_": True}})
Inputs: limit, filter, workspace_id. Returns: Result of listing automations.
get_dashboardB
Get a high-level dashboard overview of the Prefect instance.
Returns current flow run statistics, work pool status, and all active concurrency limits (global/tag-based, deployment, work pool, and work queue). Essential for diagnosing flow run delays and bottlenecks.
Inputs: workspace_id. Returns: Dashboard overview of Prefect instance.
get_deploymentsA
Get deployments with optional filters.
Returns compact summaries by default. Filter by specific ID(s) for full detail including parameters, parameter_openapi_schema, job_variables, work_pool details, and recent_runs.
Filter operators:
any_: Match any value in list
all_: Match all values
like_: SQL LIKE pattern matching
not_any_: Exclude values
is_null_: Check for null/not null
eq_/ne_: Equality comparisons
Examples: - List all deployments: get_deployments() - Full detail: get_deployments(filter={"id": {"any_": [""]}}) - Active deployments: get_deployments(filter={"paused": {"eq_": False}}) - Production deployments: get_deployments(filter={"tags": {"all_": ["production"]}})
Inputs: limit, filter, workspace_id. Returns: Result of listing deployments.
get_flow_run_logsA
Get execution logs for a flow run.
Retrieves log entries from the flow run execution, including timestamps, log levels, and messages.
Examples: - Get logs: get_flow_run_logs(flow_run_id="...") - Get more logs: get_flow_run_logs(flow_run_id="...", limit=500)
Inputs: flow_run_id (required), limit, workspace_id. Returns: Result of fetching logs for a flow run.
get_flow_runsA
Get flow runs with optional filters.
Returns compact summaries by default. Filter by specific ID(s) for full detail including parameters, inlined deployment info, and work pool info.
Filter operators:
any_: Match any value in list
all_: Match all values
like_: SQL LIKE pattern matching
not_any_: Exclude values
is_null_: Check for null/not null
after_/before_: Time comparisons
gt_/gte_/lt_/lte_: Numeric comparisons
Examples: - List recent runs: get_flow_runs() - Get specific run: get_flow_runs(filter={"id": {"any_": [""]}}) - Failed runs: get_flow_runs(filter={"state": {"type": {"any_": ["FAILED"]}}}) - Production runs: get_flow_runs(filter={"tags": {"all_": ["production"]}})
Inputs: limit, filter, workspace_id. Returns: Result of listing flow runs.
get_flowsA
Get flows with optional filters.
Returns a list of flows registered in the workspace.
Filter operators:
any_: Match any value in list
like_: SQL LIKE pattern matching
all_: Match all values
Examples: - List all flows: get_flows() - Get specific flow: get_flows(filter={"id": {"any_": [""]}}) - Flows by name pattern: get_flows(filter={"name": {"like_": "etl-%"}}) - Flows by tags: get_flows(filter={"tags": {"all_": ["production"]}})
Inputs: limit, filter, workspace_id. Returns: Result of listing flows.
get_identityA
Get identity and connection information for the current Prefect instance.
Returns API URL, type (cloud/oss), and user information if available. Essential for understanding which Prefect instance you're connected to.
Inputs: workspace_id. Returns: Result of getting identity information.
get_object_schemaC
Get a schema for an object type.
Inputs: object_type (required). Returns: object
get_task_runsA
Get task runs with optional filters.
Returns a list of task runs and their details matching the filters. Note that 'task_inputs' contains dependency tracking information (upstream task relationships), not the actual parameter values passed to the task.
Filter operators:
any_: Match any value in list
like_: SQL LIKE pattern matching
not_any_: Exclude values
is_null_: Check for null/not null
Examples: - List recent tasks: get_task_runs() - Get specific task: get_task_runs(filter={"id": {"any_": [""]}}) - Failed tasks: get_task_runs(filter={"state": {"type": {"any_": ["FAILED"]}}}) - Tasks by pattern: get_task_runs(filter={"name": {"like_": "%process%"}})
Inputs: limit, filter, workspace_id. Returns: Result of listing task runs.
get_work_poolsA
Get work pools with optional filters.
Returns compact summaries by default (name, type, status, concurrency_limit). Filter by specific ID(s) for full detail including work queues, active worker counts, and descriptions. Essential for debugging deployment issues related to flow runs being stuck or not starting.
Filter operators:
any_: Match any value in list
like_: SQL LIKE pattern matching
Examples: - List all pools: get_work_pools() - Full detail: get_work_pools(filter={"id": {"any_": [""]}}) - Kubernetes pools: get_work_pools(filter={"type": {"any_": ["kubernetes"]}})
Inputs: limit, filter, workspace_id. Returns: Result of listing work pools.
orientationC
Use this tool to get oriented with the Prefect MCP server.
Inputs: no named parameters. Returns: result
read_eventsA
Read and filter events from the Prefect instance.
Provides a structured view of events with filtering capabilities.
Note: When no time range is specified, events from the last 1 hour are returned by default. Use occurred_after/occurred_before parameters to query a different time range.
Common event type prefixes:
prefect.flow-run: Flow run lifecycle events
prefect.deployment: Deployment-related events
prefect.work-queue: Work queue events
prefect.agent: Agent events
Examples: - Recent flow run events: read_events(event_type_prefix="prefect.flow-run") - Last 24 hours: read_events(occurred_after="") - Specific time range: read_events(occurred_after="2024-01-01T00:00:00Z", occurred_before="2024-01-02T00:00:00Z")
Inputs: limit, workspace_id, occurred_after, occurred_before, +1 more. Returns: Result of reading events.
review_rate_limitsA
Review rate limit usage for this Prefect Cloud account (Cloud only).
Prefect Cloud API access is governed by rate limits in different categories (runs, deployments, flows, work_pools, writing-logs, etc.). When you see HTTP 429 errors or "Too Many Requests" responses from the Prefect API, use this tool to identify which operation groups were throttled and when.
Queries all common rate limit operation groups and groups consecutive throttled minutes into periods, showing which operation groups were affected during each stretch.
Note: These are not API authentication keys - they're categories of API operations that are rate limited together (e.g., "runs" includes all flow run API calls, "writing-logs" includes log write operations).
Useful for diagnosing why API calls are being rate limited. The response shows:
Distinct time periods where throttling occurred
Which operation groups were throttled during each period
Total denied requests and peak denials per minute for each group
Examples: - Check recent throttling: review_rate_limits() - Custom time range: review_rate_limits(since="2025-09-30T00:00:00Z", until="2025-10-01T00:00:00Z")
Inputs: since, until. Returns: Result of getting rate limit usage (Cloud only). Groups consecutive throttled m…
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
All tools have clearly distinct purposes: each targets a specific Prefect entity (automations, dashboard, deployments, flow runs, flows, etc.) with no overlapping functionality. The descriptions make it easy for an agent to select the appropriate tool.
Tool names follow a consistent verb_noun pattern with underscores, predominantly using 'get_' for retrieval operations. Minor deviations like 'docs_search_prefect', 'read_events', and 'orientation' are still clear and fit the overall schema.
With 14 tools, the server is well-scoped for Prefect monitoring and inspection. Each tool serves a distinct function without unnecessary redundancy, covering all key entities and operations relevant to the domain.
The tool set covers all major entities for observation (flows, deployments, runs, work pools, automations, events, rate limits), but lacks any mutation or management capabilities (create, update, delete). This is a notable gap for a comprehensive Prefect interface, though internally consistent for a read-only server.
Maintenance
Related MCP Connectors
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
Related MCP Servers
- AlicenseBqualityFmaintenanceA Model Context Protocol server that allows AI assistants to interact with Prefect's workflow automation platform through natural language, enabling users to manage flows, deployments, tasks, and other Prefect resources via conversational commands.4615Apache 2.0
- AlicenseBqualityBmaintenanceMCP server for managing n8n workflows through AI assistants. Supports workflow CRUD operations, synchronization, inspection, and execution support for automation-focused workflows.19155 npm2MIT
- FlicenseAqualityDmaintenanceMCP server for creating, monitoring, and managing Devin AI sessions.41-
- AlicenseAqualityBmaintenanceA Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to Langflow workflow automation platform.3430 npm10MIT