MCP-Ambari-API
Manage and inspect Apache Ambari clusters through MCP, covering health, services, hosts, alerts, configurations, requests, users, metrics, and service/component operations.
Inspect cluster information and active requests.
List and check services, components, details, and status.
Start, stop, and restart individual services or all services.
Start, stop, and restart host-level components.
Monitor request status and task-level host/role progress.
List hosts and retrieve host details.
List users and get user details.
View current alerts and alert history with filters.
Dump and filter service configuration types and keys.
Discover Ambari Metrics apps, metadata, and catalog entries.
Query exact time-series Ambari Metrics data.
Generate HDFS dfsadmin-style capacity and DataNode reports.
Provides comprehensive management of Apache Hadoop clusters through Ambari API, enabling service control (start/stop/restart HDFS, YARN, Spark, etc.), configuration management, real-time monitoring, alert management, host administration, and user management via natural language commands.
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., "@MCP-Ambari-API show me the status of all HDFS services"
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.
MCP Ambari API
Manage and inspect Apache Ambari clusters from Claude Desktop, OpenWebUI, or any MCP client.
MCP Ambari API turns common Hadoop operations into MCP tools. It can inspect cluster health, services, hosts, alerts, configurations, requests, and Ambari Metrics data, and can perform service operations with safety guidance for high-impact actions.
Example requests:
“Show the current status of every service.”
“List critical Ambari alerts and their affected hosts.”
“Generate an HDFS capacity report.”
“Find NameNode heap metrics available in AMS.”
“Restart HDFS after showing me the affected components.”
More requests to try: see Example queries by area for cluster and services, service operations, requests and tasks, hosts, configurations, users, alerts, and metrics.
Quick start
Choose one installation method. MCPB is the shortest path for Claude Desktop; Docker Compose provides the full OpenWebUI, MCP server, and optional MCPO stack.
Claude Desktop with MCPB
Prerequisites:
Claude Desktop for macOS or Windows with MCPB extension support
Network access from the desktop to the Ambari server and, when used, the Ambari Metrics collector
Download
mcp-ambari-api-<version>.mcpbfrom the latest GitHub Release.In Claude Desktop, open Settings → Extensions → Advanced settings → Install Extension….
Select the downloaded bundle.
Enter the Ambari host, port, username, password, cluster name, and Metrics collector settings. The password is declared as a sensitive field.
Ask a read-only verification question such as “Show the Ambari cluster status.”
The bundle uses stdio transport, uv, and Python 3.12; it does not expose a
listening port.
MCPB settings are stored by the desktop host and are not written into this
repository.
OpenWebUI with Docker Compose
Prerequisites:
Docker Engine with Docker Compose
A reachable Ambari cluster
An OpenWebUI model provider and a model that supports tool calling
git clone https://github.com/call518/MCP-Ambari-API.git
cd MCP-Ambari-API
cp .env.example .env
cp mcp-config.json.http mcp-config.json.http.local
chmod 600 .env mcp-config.json.http.localEdit .env with the Ambari connection values. If remote MCP authentication is
enabled, replace <REMOTE_SECRET_KEY> in both .env and
mcp-config.json.http.local with the same strong secret.
docker compose up -d
docker compose psDefault host endpoints:
Service | URL | Purpose |
OpenWebUI |
| Chat interface |
MCP server |
| Direct Streamable HTTP MCP |
MCPO |
| Optional OpenAPI compatibility layer |
The published ports bind to 127.0.0.1 by default. Set
DOCKER_BIND_ADDRESS only when remote access is required, and enable
authentication plus TLS at the network boundary before exposing the services.
Configure OpenWebUI
Open http://localhost:3001, create the administrator account, and configure a
model provider under Settings → Admin → Connections. For OpenAI, add a
connection with these values:
Field | Value |
URL |
|
Auth |
|
API key | Your OpenAI API key |
API Type |
|
Chat Completions must be used with the Quick Start's default
DEFAULT_MODEL_PARAMS={"reasoning_effort":"none"} setting. To use an OpenAI
reasoning model with reasoning enabled instead, set DEFAULT_MODEL_PARAMS={}
before the first start, select Responses, and leave Reasoning Effort at
Default in the global, per-model, and chat settings. Mixing Responses
with reasoning_effort=none, or Chat Completions with another reasoning
effort, can cause tool calls to fail.
Confirm that the model appears in a new chat, then add one of the following external tool-server connections under Settings → Admin → Tools → Integrations.
Option A: Direct MCP (recommended)
Add a connection of type MCP (Streamable HTTP) using the URL visible from the
OpenWebUI container:
http://mcp-server:8000/mcpUse http://localhost:18001/mcp only from a client running on the Docker host.
Use authentication None unless REMOTE_AUTH_ENABLE=true; when authentication
is enabled, use Bearer with the configured REMOTE_SECRET_KEY.
Option B: MCPO (OpenAPI)
Add a connection of type OpenAPI with this URL:
http://mcpo-proxy:8000/mcp-ambari-apiMCPO is not required for OpenWebUI; it remains in the standard stack for
OpenAPI-compatible clients. Use the Compose service URLs above rather than
localhost because OpenWebUI resolves them from inside its container.
To start without MCPO:
docker compose up -d mcp-server open-webuiOther installation methods
PyPI with uvx
{
"mcpServers": {
"mcp-ambari-api": {
"command": "uvx",
"args": ["--python", "3.12", "mcp-ambari-api"],
"env": {
"AMBARI_HOST": "ambari.example.com",
"AMBARI_PORT": "8080",
"AMBARI_USER": "<AMBARI_USER>",
"AMBARI_PASS": "<AMBARI_PASSWORD>",
"AMBARI_CLUSTER_NAME": "<AMBARI_CLUSTER_NAME>",
"MCP_LOG_LEVEL": "INFO"
}
}
}
}Remote Streamable HTTP
{
"mcpServers": {
"mcp-ambari-api": {
"type": "streamable-http",
"url": "https://mcp.example.com/mcp",
"headers": {
"Authorization": "Bearer <REMOTE_SECRET_KEY>"
}
}
}
}Related MCP server: Ambari MCP Server
Capabilities
Cluster, service, component, host, request, user, and alert inspection
Service start, stop, restart, maintenance, and configuration workflows
HDFS
dfsadmin-style capacity and DataNode reportsLive Ambari Metrics metadata discovery and exact-name time-series queries
stdio and Streamable HTTP transports
Optional bearer authentication for Streamable HTTP
Cross-tool safety and reporting rules are sent to clients as MCP server
instructions from
server_instructions.md. Tool availability
can evolve, so MCP clients should use tools/list rather than relying on a
copied static tool list.
Configuration
CLI arguments take precedence over environment variables, which take precedence over defaults.
Server settings
Variable | Default | Description |
|
|
|
|
| HTTP bind address |
|
| HTTP listen port |
|
| Log level |
|
| Enable HTTP bearer authentication |
| empty | Required when authentication is enabled |
CLI equivalents are --type, --host, --port, --auth-enable, and
--secret-key.
Ambari settings
Variable | Default | Description |
|
| Ambari server host |
|
| Ambari server port |
|
| Ambari username |
|
| Ambari password |
|
| Default target cluster |
| Ambari host | Metrics collector host |
|
| Metrics collector port |
|
| Metrics collector protocol |
|
| Metrics request timeout in seconds |
Metrics workflow
Ambari metric names are exact identifiers rather than natural-language labels. Use this sequence:
Call
list_ambari_metric_appsto discover valid app IDs.Call
list_common_metrics_catalogorlist_ambari_metrics_metadatato find an exact metric name.Call
query_ambari_metricswith an explicitapp_idand exact metric name.
Example:
query_ambari_metrics(
metric_names="jvm.JvmMetrics.MemHeapUsedM",
app_id="namenode",
duration="1h",
group_by_host=true
)Safety and security
Keep
.envandmcp-config.json.http.localoutside Git. The tracked files contain placeholders only.Use a unique, strong
REMOTE_SECRET_KEY; never reuse an Ambari password as the MCP bearer token.Plain HTTP does not protect credentials in transit. Use a TLS reverse proxy for remote access.
Keep unauthenticated development services bound to localhost.
Review service-wide start, stop, restart, and configuration changes before approving them in the MCP client.
Compatibility
Python
3.12.xMCP stdio and Streamable HTTP transports
Claude Desktop MCPB through the UV runtime
Docker Compose stack with OpenWebUI
0.13.3Apache Ambari environments that expose the Ambari REST API; exact behavior can vary by Ambari and Hadoop component version
Troubleshooting
OpenAI reasoning model rejects tool calls
The connection's API Type and Reasoning Effort must match:
Setup | API Type | Reasoning Effort |
Quick Start default |
|
|
Reasoning with tools |
|
|
The Compose example seeds the Quick Start default into OpenWebUI with:
DEFAULT_MODEL_PARAMS={"reasoning_effort":"none"}OpenWebUI stores this value in its database on first startup. For an existing
open-webui-data volume, set Reasoning Effort to none in the Admin UI or
per-model settings instead. Per-chat settings can override both. Do not delete
the data volume as a troubleshooting shortcut. If using Responses, remove
the parameter from the global, per-model, and chat settings and leave Reasoning
Effort at Default. Remove the global parameter if the selected provider does
not support it.
MCPO returns 401 Unauthorized
Check, without printing the secret itself:
REMOTE_AUTH_ENABLEin.env.Whether
REMOTE_SECRET_KEYis set.Whether
mcp-config.json.http.localstill contains the placeholder.Whether its bearer token matches the server secret.
Whether the MCPO container was recreated after the change.
An error emitted while cleaning up the connection can follow the initial 401; diagnose the first HTTP error first.
Direct MCP works but MCPO fails
These are separate client paths. Verify the direct endpoint
http://mcp-server:8000/mcp and the MCPO-mounted local config independently.
Ambari connection fails
Verify host reachability from the process or container, Ambari credentials,
cluster name spelling, and the server port. localhost inside a container is
the container itself; use host.docker.internal for a service on the Docker
host.
Development
Install and run with the existing uv project:
uv sync --dev
uv run ruff check src tests scripts
uv run pytestRun MCP Inspector against local source:
./run-mcp-inspector-local.shBuild a local MCPB using a canonical semantic version:
scripts/build-mcpb.sh 0.0.0 /tmp/mcp-ambari-api-mcpb
unzip -l /tmp/mcp-ambari-api-mcpb/mcp-ambari-api-0.0.0.mcpbTagged releases build the wheel, source distribution, and MCPB. Publication to TestPyPI and PyPI completes before the GitHub Release is created with the MCPB attached.
Contributing
Keep changes focused, add tests for behavior changes, and verify documentation commands against the current configuration. Open an issue before making a breaking public API or configuration change.
License
Available Tools
29 toolsdump_configurationsDump ConfigurationsC
Unified configuration introspection tool (supersedes get_configurations & list_configurations & dump_all_configurations).
Inputs: limit, filter, max_chars, summarize, +3 more. Returns: result
get_active_requestsA
Retrieves currently active (in progress) requests/operations in an Ambari cluster. Shows running operations, in-progress tasks, pending requests.
[Tool Role]: Dedicated tool for monitoring currently running Ambari operations
[Core Functions]:
Retrieve active/running Ambari operations (IN_PROGRESS, PENDING status)
Show real-time progress of ongoing operations
Monitor current cluster activity
[Required Usage Scenarios]:
When users ask for "active requests", "running operations", "current requests"
When users ask for "request list", "operation list", "task list"
When users want to see "current tasks", "running tasks", "in progress operations"
When users mention "running", "in progress", "current activity"
When users ask about Ambari requests, operations, or tasks
When checking if any operations are currently running
Returns: Active requests information (success: active request list, failure: error message)
Inputs: no named parameters. Returns: result
get_alerts_historyA
Retrieve current alerts or alert history from Ambari cluster.
[Tool Role]: Unified tool for retrieving both current/active alert status and historical alert events from Ambari cluster
[Core Functions]:
Current mode: Retrieve current alerts for entire cluster, specific service, or specific host
History mode: Retrieve alert history for entire cluster, specific service, or specific host
Support filtering by alert state (CRITICAL, WARNING, OK, UNKNOWN)
Support filtering by definition name
Current mode: Support filtering by maintenance state (ON, OFF)
History mode: Support filtering by time range with from_timestamp/to_timestamp
Support different output formats (detailed, summary, compact, groupedSummary for current)
History mode: Provide pagination support for large datasets
Provide current time context for LLM natural language time calculations
[Required Usage Scenarios]:
Current mode: When users request current alerts, active alerts, or alert status
Current mode: When monitoring immediate cluster health
Current mode: When investigating current issues or troubleshooting active problems
History mode: When users request alert history, past alerts, or historical alert data
History mode: When monitoring alert trends or analyzing alert patterns
History mode: When investigating past alert incidents or troubleshooting
When users mention alert status, current problems, cluster health, alert events, alert timeline, or alert logs
Inputs: mode, limit, format, host_name, +10 more. Returns: result
get_cluster_infoA
Retrieves basic information for an Ambari cluster.
[Tool Role]: Dedicated tool for real-time retrieval of overall status and basic information for an Ambari cluster.
[Core Functions]:
Retrieve cluster name, version, provisioning state, and security type
Provide formatted output for LLM automation and cluster monitoring
[Required Usage Scenarios]:
When users request cluster info, status, or summary
When monitoring cluster health or auditing cluster properties
When users mention cluster overview, Ambari cluster, or cluster details
Returns: Cluster basic information (success: formatted info, failure: English error message)
Inputs: no named parameters. Returns: result
get_cluster_servicesA
Retrieves the list of services with status in an Ambari cluster.
[Tool Role]: Dedicated tool for real-time retrieval of all running services and basic status information in an Ambari cluster
[Core Functions]:
Retrieve cluster service list with status via Ambari REST API
Provide service names, current state, and cluster information
Include detailed link information for each service
Display visual indicators for service status
[Required Usage Scenarios]:
When users mention "service list", "cluster services", "Ambari services"
When cluster status check is needed
When service management requires current status overview
When real-time cluster information is absolutely necessary
[Absolutely Prohibited Scenarios]:
General Hadoop knowledge questions
Service installation or configuration changes
Log viewing or performance monitoring
Requests belonging to other cluster management tools
Returns: Cluster service list with status information (success: service list with status, failure: error message)
Inputs: no named parameters. Returns: result
get_current_alertsA
Retrieve current alerts from Ambari cluster.
DEPRECATED: This function is deprecated in favor of get_alerts_history with mode="current". This wrapper is maintained for backward compatibility.
Inputs: format, host_name, cluster_name, service_name, +3 more. Returns: result
get_host_detailsA
Retrieves detailed information for a specific host or all hosts in the Ambari cluster.
[Tool Role]: Dedicated tool for retrieving comprehensive host details including metrics, hardware info, and components.
[Core Functions]:
If host_name provided: Query specific host information
If host_name not provided: Query all hosts and their detailed information
Return host hardware specs, state, metrics, and assigned components
Provide formatted output for LLM automation and cluster management
[Required Usage Scenarios]:
When users request specific host details or host status
When users request all hosts details or cluster-wide host information
When auditing or monitoring individual or all cluster nodes
When troubleshooting host-specific issues
Inputs: host_name. Returns: result
get_request_statusA
Retrieves the status and progress of a specific Ambari request operation.
[Tool Role]: Dedicated tool for real-time tracking and reporting of Ambari request status.
[Core Functions]:
Query the status, progress, and context of a request by its ID
Provide detailed status (PENDING, IN_PROGRESS, COMPLETED, FAILED, etc.)
Show progress percentage and timing information
Return actionable status for automation and LLM integration
[Required Usage Scenarios]:
When users ask for the status or progress of a specific operation/request
When monitoring or troubleshooting Ambari operations
When tracking bulk or individual service actions
When users mention request ID, operation status, or progress
Inputs: request_id (required). Returns: result
get_request_tasksA
Retrieves task-level details for a specific Ambari request (host-by-host breakdown).
[Tool Role]: Provides granular, per-host task information for an Ambari request, going beyond the summary level offered by get_request_status.
[Core Functions]:
List all tasks (host/role/status/timing) belonging to a request
Filter tasks by status (e.g. FAILED, IN_PROGRESS) or exclude a status (not:COMPLETED)
Filter tasks by hostname to inspect a specific host
Identify which hosts/roles are failing, pending, or still running
[Required Usage Scenarios]:
When users want to know which hosts or roles failed/are pending in an operation
When debugging a partially-failed bulk operation (e.g. "Start all services")
When users ask for task details, host-level progress, or remaining tasks
When request progress is near 100% but not complete and user wants to know what's left
Inputs: request_id (required), host_filter, status_filter. Returns: result
get_service_componentsB
Retrieves detailed components information for a specific service in the Ambari cluster.
[Tool Role]: Dedicated tool for retrieving service component details and host assignments.
[Core Functions]:
List all components for a service, including state and category
Show host assignments and instance counts
Provide formatted output for LLM automation and troubleshooting
[Required Usage Scenarios]:
When users request service component details or host info
When troubleshooting service health or scaling
When users mention component list, host assignments, or service breakdown
Inputs: service_name (required). Returns: result
get_service_detailsA
Retrieves detailed status and configuration information for a specific service in the Ambari cluster.
[Tool Role]: Dedicated tool for retrieving comprehensive service details, including state, components, and configuration.
[Core Functions]:
Retrieve service state, component list, and configuration availability
Provide formatted output for LLM automation and troubleshooting
[Required Usage Scenarios]:
When users request detailed service info or breakdown
When troubleshooting service health or auditing service setup
When users mention service details, service summary, or configuration status
Inputs: service_name (required). Returns: result
get_service_statusA
Retrieves the status information for a specific service in an Ambari cluster.
[Tool Role]: Dedicated tool for real-time retrieval of specific service status and state information
[Core Functions]:
Retrieve specific service status via Ambari REST API
Provide detailed service state information (STARTED, STOPPED, INSTALLING, etc.)
Include service configuration and component information
[Required Usage Scenarios]:
When users ask about specific service status (e.g., "HDFS status", "YARN state")
When troubleshooting service issues
When monitoring specific service health
Inputs: service_name (required). Returns: result
get_userB
Get detailed information about a specific user.
Inputs: user_name (required). Returns: result
hdfs_dfadmin_reportHDFS DFSAdmin ReportC
Produce a DFSAdmin-style capacity and DataNode report using Ambari metrics.
Inputs: cluster_name, lookback_minutes. Returns: result
list_ambari_metric_appsList Ambari Metric AppsC
Return discovered AMS appIds, optionally with metric counts.
Inputs: limit, refresh, include_counts. Returns: result
list_ambari_metrics_metadataList Ambari Metrics MetadataC
Retrieve metric metadata from Ambari Metrics service with optional filters.
Inputs: limit, app_id, search, host_filter, +2 more. Returns: result
list_common_metrics_catalogList Common Metrics CatalogC
List supported metrics per appId (exact names only).
Inputs: limit, app_id, search, min_score, +1 more. Returns: result
list_hostsA
Retrieves the list of hosts in the Ambari cluster.
[Tool Role]: Dedicated tool for listing all hosts registered in the Ambari cluster.
[Core Functions]:
Query Ambari REST API for host list
Return host names and API links
Provide formatted output for LLM automation and cluster management
[Required Usage Scenarios]:
When users request cluster host list or host details
When auditing or monitoring cluster nodes
Returns: List of hosts (success: formatted list, failure: error message)
Inputs: no named parameters. Returns: result
list_usersA
List all users in the Ambari system.
Returns a formatted list of all users with their basic information.
Inputs: no named parameters. Returns: result
query_ambari_metricsQuery Ambari MetricsC
Fetch time-series metrics (exact metric names only) from Ambari Metrics.
Inputs: metric_names (required), app_id, duration, end_time, +8 more. Returns: result
restart_all_servicesA
Restarts all services in the Ambari cluster (stop all, then start all).
[Tool Role]: Dedicated tool for automated bulk restart of all Ambari services, ensuring safe stop and start sequence.
[Core Functions]:
Stop all running services and wait for completion
Start all services and wait for completion
Return clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to "restart all services", "bulk restart", "cluster-wide restart"
When troubleshooting or recovering cluster-wide issues
When maintenance or configuration changes require a full restart
Returns: Bulk restart operation result (success: English completion message, failure: English error message) - Success: "All services restart operation completed successfully." - Failure: "Error: ..." with details
Inputs: no named parameters. Returns: result
restart_host_componentA
Restarts a specific component on a specific host in the Ambari cluster (stop then start).
[Tool Role]: Dedicated tool for restarting individual host-level components, enabling fine-grained control without affecting other hosts or the overall service.
[Core Functions]:
Stop the specified component on the given host and wait for completion
Start the component and return request information
Return clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to restart a component on a specific host (e.g., "restart DataNode on host-A")
When recovering a stuck or malfunctioning single component instance
When applying config changes that require a component-level restart
Inputs: host_name (required), component_name (required). Returns: result
restart_serviceA
Restarts a specific service in an Ambari cluster (stop then start).
[Tool Role]: Dedicated tool for automated restart of Ambari services, ensuring safe stop and start sequence.
[Core Functions]:
Stop the specified service and wait for completion
Start the service and wait for completion
Return clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to "restart" a service (e.g., "restart HDFS", "restart YARN")
When troubleshooting or recovering service issues
When maintenance or configuration changes require a restart
When users mention service restart, safe restart, or automated restart
Inputs: service_name (required). Returns: result
start_all_servicesA
Starts all services in an Ambari cluster (equivalent to "Start All" in Ambari Web UI).
[Tool Role]: Dedicated tool for bulk starting all services in the cluster, automating mass startup.
[Core Functions]:
Start all installed services simultaneously
Return request information for progress tracking
Provide clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to "start all services", "start everything", "cluster startup"
When recovering cluster after maintenance or outage
When users mention mass startup, bulk start, or cluster bring-up
Returns: Start operation result (success: request info, failure: English error message)
Inputs: no named parameters. Returns: result
start_host_componentA
Starts a specific component on a specific host in the Ambari cluster.
[Tool Role]: Dedicated tool for starting individual host-level components, enabling fine-grained control without affecting other hosts or the overall service.
[Core Functions]:
Start the specified component on the given host
Skip if the component is already in STARTED state
Return request information for progress tracking
[Required Usage Scenarios]:
When a specific host's component is STOPPED but the overall service is STARTED
When users request to start a component on a specific host (e.g., "start DataNode on host-A")
When recovering a single component instance without restarting the entire service
Inputs: host_name (required), component_name (required). Returns: result
start_serviceA
Starts a specific service in the Ambari cluster.
[Tool Role]: Dedicated tool for automated start of Ambari services, ensuring safe and monitored startup.
[Core Functions]:
Start the specified service and initiate Ambari request
Return request information for progress tracking
Provide clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to "start" a service (e.g., "start HDFS", "start YARN")
When recovering stopped services
When maintenance or configuration changes require a service start
When users mention service start, bring up service, or automated start
Inputs: service_name (required). Returns: result
stop_all_servicesA
Stops all services in an Ambari cluster (equivalent to "Stop All" in Ambari Web UI).
[Tool Role]: Dedicated tool for bulk stopping all services in the cluster, automating mass shutdown.
[Core Functions]:
Stop all running services simultaneously
Return request information for progress tracking
Provide clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to "stop all services", "stop everything", "cluster shutdown"
When cluster maintenance or troubleshooting requires mass shutdown
When users mention mass shutdown, bulk stop, or cluster halt
Returns: Stop operation result (success: request info, failure: English error message)
Inputs: no named parameters. Returns: result
stop_host_componentA
Stops a specific component on a specific host in the Ambari cluster.
[Tool Role]: Dedicated tool for stopping individual host-level components, enabling fine-grained control without affecting other hosts or the overall service.
[Core Functions]:
Stop the specified component on the given host
Skip if the component is already in INSTALLED (stopped) state
Return request information for progress tracking
[Required Usage Scenarios]:
When users request to stop a component on a specific host (e.g., "stop DataNode on host-A")
When decommissioning or isolating a specific node's component
When troubleshooting a single component instance
Inputs: host_name (required), component_name (required). Returns: result
stop_serviceA
Stops a specific service in the Ambari cluster.
[Tool Role]: Dedicated tool for automated stop of Ambari services, ensuring safe and monitored shutdown.
[Core Functions]:
Stop the specified service and initiate Ambari request
Return request information for progress tracking
Provide clear success or error message for LLM automation
[Required Usage Scenarios]:
When users request to "stop" a service (e.g., "stop HDFS", "stop YARN")
When maintenance or troubleshooting requires a service shutdown
When users mention service stop, shutdown, or automated stop
Inputs: service_name (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 29 tools
Several tools have overlapping purposes: get_service_details already includes state and components, blurring the line with get_service_status and get_service_components; get_host_details can retrieve all hosts with details, overlapping list_hosts; and the deprecated get_current_alerts remains alongside get_alerts_history. Descriptions help, but an agent could misselect, especially for service/host introspection and alert retrieval.
Nearly all tools follow snake_case with a verb_noun pattern (get_, list_, start_, stop_, restart_, dump_). Exceptions like hdfs_dfadmin_report (noun phrase) and mixed get_/list_ for retrieval are minor deviations that don't hinder readability.
29 tools is above the 25-tool threshold for 'too many' given the guideline; some consolidation is possible (e.g., deprecating get_current_alerts, merging service status/components into details). While Ambari is complex, the surface feels heavy with redundant read operations.
Core lifecycle operations for services and components (start/stop/restart) and read access for hosts, requests, alerts, metrics, and users are present. However, notable gaps exist: no configuration update (dump_configurations only reads), no user CRUD beyond list/get, and no host add/remove or service installation—operations likely needed for full cluster management.
Maintenance
Related MCP Connectors
MCP-Native LLM Orchestration Agent
LLM Orchestration Agent (Mcp)
LLM Orchestration MCP Agent
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Related MCP Servers
- AlicenseCqualityBmaintenanceMonitor and manage Apache Airflow clusters through natural language queries via MCP tools: DAG inspection, task monitoring, health checks, and cluster analytics without API complexity. * Guide: https://call518.medium.com/mcp-airflow-api-a-model-context-protocol-mcp-server-for-apache-airflow-5dfdfb25354MIT
- AlicenseBqualityDmaintenanceEnables AI assistants to manage Apache Ambari clusters, including services, hosts, alerts, and configurations via the MCP protocol.401Apache 2.0
- AlicenseAqualityBmaintenanceMCP server exposing Apache Airflow REST API operations as tools — list DAGs, inspect runs and task instances, trigger DAG runs, and check failed DAGs and scheduler health72MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for interacting with QUADS infrastructure systems via API, enabling resource management and automation through LLM applications.MIT