Data query and analysis in Managed Service for Prometheus-Simple Log Service(SLS)-阿里云帮助中心

The Model Context Protocol (MCP) defines a standard interface for exchanging context between a large language model and a development environment, giving the model secure and controlled access to real-time domain knowledge. Observable MCP Server provides AI-powered observability for accessing and analyzing multimodal data through natural language. It seamlessly integrates with Cursor, Cline, Windsurf, and various agent frameworks, enabling enterprise teams to use observable data more efficiently and reliably.

Important

This project has been rewritten in Go for single binary deployment with zero runtime dependencies. For the original Python version, visit V1.

Advantages

Multi-source data integration: Connect once to query data from multiple observability products—including Log Service, Application Real-Time Monitoring Service (ARMS), CloudMonitor, and Prometheus monitoring—for a unified view of logs, metrics, and traces.
Natural language-driven: Use natural language to query logs, traces, and metrics without writing query statements. The server returns structured answers.
Enterprise-grade security: It uses Alibaba Cloud AccessKey authentication and collects no server-side data. It strictly validates the inputs and outputs of each tool, keeping your data secure and under your control.
Single binary deployment: The Go application compiles into a single executable file that requires no runtime environment and supports Linux, macOS, and Windows.
Guaranteed stability: Built-in mechanisms such as retry (exponential backoff), circuit breakers, and graceful shutdown make it production-ready.

Paid features

Some AI tools in Observable MCP Server call APIs from Alibaba Cloud STAROps, an intelligent O&M platform. Using these tools incurs charges.

Paid tools

Each call to the following AI tools creates a STAROps AI conversation and incurs a charge:

Tool name	Feature	Description
`sls_text_to_sql`	natural language to SQL query	Converts natural language questions into executable SLS SQL.
`sls_text_to_spl`	natural language to SPL query	Converts natural language questions into SPL statements and executes them.
`sls_sop`	Log Service intelligent O&M assistant	Provides O&M suggestions for Log Service through an AI conversation.
`cms_natural_language_query`	natural language data query	Lets you query observability data in natural language directly through DataAgent.

Billing

Alibaba Cloud STAROps bills you for paid tools. For more information, see billing details.

If you do not require AI capabilities, you can prevent unexpected charges by explicitly defining the enabled_tools list in the config.yaml file to include only free tools.

toolkit:
  scope: all
  enabled_tools:
    - sls_list_projects
    - sls_list_logstores
    - sls_execute_sql
    - sls_execute_spl
    - cms_execute_promql
    # ... Add other free tools as needed

Getting started

Step 1: Configure permissions

This service requires a valid Alibaba Cloud AccessKey ID and AccessKey Secret. You can get them from Create an AccessKey.
If you use a RAM user, note the following:
- You must grant the required permissions to the RAM user or role associated with the AccessKey to access the relevant cloud services.
- Follow the principle of least privilege: Grant only the minimum set of permissions required by the MCP tools you plan to use. This helps minimize security risks.
Permission configuration options
For more fine-grained permission control, you can grant permissions on a per-service basis according to the toolset (toolkit.scope) in use.
- SLS (Log Service) permissions — For the sls_* series of tools.
  You can directly use the system policy AliyunLogReadOnlyAccess, or create a custom policy:
```
{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "log:ListProject",
        "log:ListLogStores",
        "log:ListMetricStores",
        "log:GetLogStoreLogs",
        "log:GetContextLogs"
      ],
      "Resource": [
        "acs:log:*:*:project/*"
      ]
    }
  ]
}
```
  To specify a project, replace project/* with project/<YOUR-PROJECT-NAME>.
- CMS (CloudMonitor 2.0) permissions — Applies to the cms_* series of tools, list_workspace, list_domains, and the AI conversion tool.
  CMS 2.0 is the core service of the Observable MCP Server. The cms_* series tools, Shared tools (such as list_workspace and list_domains), and AI conversion tools (such as sls_text_to_sql, sls_text_to_promql, and sls_text_to_spl) all use the CMS 2.0 API. Create a custom policy:
```
{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "cms:ListWorkspaces",
        "cms:GetEntityStoreData"
      ],
      "Resource": ["*"]
    }
  ]
}
```
  If you use AI conversion tools such as sls_text_to_sql, sls_text_to_promql, and sls_text_to_spl, or the cms_natural_language_query natural language query tool, you must also grant additional permissions. Note: CreateThread and CreateChat are write operations used to create AI conversation sessions to convert natural language into query statements. If you do not need the AI conversion capability, you do not need to grant these two permissions.
- ARMS (Application Real-Time Monitoring Service) permissions — For umodel_* series PaaS tools.
  The umodel_* tools access ARMS data through the CMS 2.0 unified data model. When the CMS 2.0 backend executes a query, it may need to call the ARMS API on your behalf. You can use the system policy AliyunARMSReadOnlyAccess or create a custom policy:
```
{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "arms:GetTraceApp",
        "arms:ListTraceApps",
        "arms:SearchTraces",
        "arms:GetTrace",
        "arms:GetStack",
        "arms:QueryMetric",
        "arms:SearchAlertRules"
      ],
      "Resource": ["*"]
    }
  ]
}
```
  Note: MCP Server does not call the ARMS API directly. Instead, it accesses ARMS data through the GetEntityStoreData interface of CMS 2.0. These ARMS permissions are required for calls made by the CMS 2.0 backend proxy. However, you do not need to grant these permissions if the backend uses a server-side identity for access. We recommend that you grant the permissions during the initial configuration. You can remove them if you confirm that they are not required.
Important
The Observable MCP Server uses your provided AccessKey to call the Alibaba Cloud OpenAPI at runtime, but it does not store the AccessKey in any form or use it for any other purpose.

Step 2: Install the MCP service

We provide two installation methods below. Choose the one that suits your needs. We strongly recommend deploying the MCP Server in an internal network or trusted environment, such as a VPC, to avoid exposing it to the public internet. The recommended approach is to deploy using Function Compute (FC) and configure its network for VPC-only access to achieve network-level isolation and security.

Download binaries

Download the binary file for your platform from the Releases page:

# Linux amd64
wget https://github.com/aliyun/alibabacloud-observability-mcp-server/releases/latest/download/alibabacloud-observability-mcp-server-linux-amd64.tar.gz
tar -xzf alibabacloud-observability-mcp-server-linux-amd64.tar.gz

# macOS arm64 (M1/M2)
wget https://github.com/aliyun/alibabacloud-observability-mcp-server/releases/latest/download/alibabacloud-observability-mcp-server-darwin-arm64.tar.gz
tar -xzf alibabacloud-observability-mcp-server-darwin-arm64.tar.gz

The extracted package contains:

alibabacloud-observability-mcp-server — The executable file
config.yaml — The default configuration file

After configuring your credentials, you can start the service:

# Set your Alibaba Cloud AccessKey
export ALIBABA_CLOUD_ACCESS_KEY_ID=<YOUR_ACCESS_KEY_ID>
export ALIBABA_CLOUD_ACCESS_KEY_SECRET=<YOUR_ACCESS_KEY_SECRET>

# Start in stdio mode (for local integrations like Cursor, Kiro, and Cline)
./alibabacloud-observability-mcp-server start --stdio

# Start in SSE or streamable-http mode (determined by server.transport in config.yaml)
./alibabacloud-observability-mcp-server start --config config.yaml

Build from source

Go 1.22 or later is required.

# Clone the source code
git clone https://github.com/aliyun/alibabacloud-observability-mcp-server.git
# Enter the source code directory
cd alibabacloud-observability-mcp-server
# Build for the current platform
make build
# Start the service in stdio mode
./bin/alibabacloud-observability-mcp-server start --stdio
# Start the service in SSE/streamable-http mode (requires config.yaml)
./bin/alibabacloud-observability-mcp-server start --config config.yaml

To build the binaries for all platforms, run the following command:

# Build for all platforms (Linux, macOS, and Windows)
make build-all

The generated binaries are located in the bin/ directory.

Configuration

The configuration uses a two-layer structure:

config.yaml — Server configuration, including transport mode, logging, network settings, and toolkits.
.env file or environment variables — Credentials and runtime parameters, such as your AccessKey.

config.yaml structure

Search path for config.yaml: current directory → ./config/ directory. In stdio mode, if config.yaml does not exist, the built-in default is used.

# Server configuration
server:
  transport: streamable-http  # stdio, sse, streamable-http
  host: "0.0.0.0"
  port: 8180

# Logging configuration
logging:
  level: info                 # debug, info, warn, error
  debug_mode: false

# Toolkit configuration
toolkit:
  scope: all                  # all, paas, iaas
# Fine-grained tool selection (optional)
# When enabled_tools is not empty, only the tools in the list are registered (scope still determines which toolkits are loaded).
# Uncomment the tools you want to enable and keep the others commented out.
# enabled_tools:
#   ## ── Shared tools (general) ──
#   - introduction              # Get service introduction information
#   - list_workspace            # List available workspaces
#   - list_domains              # List entity domains in a workspace



# Network configuration
network:
  max_retry: 1
  retry_wait_seconds: 1
  read_timeout_ms: 610000
  connect_timeout_ms: 30000

# Localization configuration
locale:
  timezone: Asia/Shanghai
  language: zh-CN

# Endpoint override configuration (optional, for internal network access or custom endpoints)
# endpoints:
#   sls:
#     cn-hangzhou: "cn-hangzhou-intranet.log.aliyuncs.com"
#   cms:
#     cn-hangzhou: "cms.cn-hangzhou.aliyuncs.com"

Configuration parameters

Parameter	Description	Options
`server.transport`	Specifies the transport mode.	Valid values are `stdio`, `sse`, and `streamable-http`. The default value is `stdio`. - streamable-http: Use cases include production environments and web applications (Recommended). - Advantages: A modern HTTP streaming protocol that provides excellent performance and production-grade stability. The endpoint path is `/streamhttp`. - Limitations: Requires network configuration and config.yaml. - stdio: Use cases include local development and command-line tools. - Advantages: The simplest integration method. It requires no network configuration and uses direct inter-process communication. - Limitations: For local use only. It does not support concurrent access from multiple clients. - sse (Server-Sent Events): Use cases include web applications, remote access, and special scenarios. - Advantages: Supports remote connections, is based on the standard HTTP protocol, and supports multiple clients. The endpoint path is `/sse`. - Limitations: Requires maintaining long-lived connections. The performance is slightly lower than that of streamable-http. You are responsible for implementing access control and security measures for this service endpoint.
`server.host`	The listen address (for sse/streamable-http mode only).	Default: `0.0.0.0`.
`server.port`	The listen port (for sse/streamable-http mode only).	Default: `8180`.
`logging.level`	Log level.	Valid values: `debug`, `info`, `warn`, `error`. Default: `info`.
`logging.debug_mode`	Debug mode, which outputs full requests and responses.	Default: `false`.
`toolkit.scope`	Specifies the tools to enable.	Valid values: `all`, `paas`, `iaas`. Default: `all`.
`toolkit.enabled_tools`	Fine-grained tool selection (Optional). When the list is not empty, only the tools specified in it are registered, and the `scope` still determines which toolkit modules to load.	Defaults to empty, which registers all tools within the `scope`. The value is a list of tool names, such as `["sls_list_projects", "umodel_get_metrics"]`.
`network.max_retry`	Maximum number of retries.	Default: `1`.
`network.read_timeout_ms`	Read timeout in milliseconds.	Default: `610000`.
`network.connect_timeout_ms`	Connection timeout in milliseconds.	Default: `30000`.
`locale.timezone`	Time zone, used for time parsing.	Default: `Asia/Shanghai`.
`locale.language`	Language, used for error messages and other output.	Default: `zh-CN`.

`.env` environment variables (credentials and runtime parameters)

Credentials are read from the .env file first, and if not found, from shell environment variables.

Parameter	Description	Required
`ALIBABA_CLOUD_ACCESS_KEY_ID`	The Alibaba Cloud AccessKey ID.	Yes
`ALIBABA_CLOUD_ACCESS_KEY_SECRET`	The Alibaba Cloud AccessKey Secret.	Yes
`ALIBABA_CLOUD_SECURITY_TOKEN`	STS Token (temporary credential, optional).	No
`ALIBABA_CLOUD_REGION`	Default region.	No
`ALIBABA_CLOUD_WORKSPACE`	Default workspace (required for PaaS tools).	No

Important

Never expose an MCP Server SSE/HTTP endpoint to the public internet without a proper authentication and access control mechanism, especially when it uses your AccessKey. Doing so creates an extremely high security risk.

If you do not provide an AccessKey ID and AccessKey Secret at initialization, the server uses the following default access credentials:

If the ALIBABA_CLOUD_SECURITY_TOKEN environment variable is set, the server uses the STS Token as the default credential.
If ALIBABA_CLOUD_SECURITY_TOKEN is not set, the server checks if ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are both present and not empty. If so, they are used as the default credentials.

CLI commands

Command	Description	Parameters
`start`	Starts the MCP service.	`--config`: Specifies the configuration file path (searches automatically by default). `--stdio`: Forces the use of stdio transport mode (overrides the settings in config.yaml).
`version`	Displays version information.	None.
`tools`	Lists all registered MCP tools.	None.

MCP examples

List projects

After you start the MCP service, ask the large model in natural language to list your projects.
The MCP server then calls the sls_list_projects tool to query data, enabling multi-source data collaboration.

Available CloudMonitor metrics

You can ask the large model a question in natural language, such as 'List the available metrics in the Cloud Monitor namespace'. The model then queries data by calling tools provided by the MCP Server, such as cms_list_metrics and cms_list_namespaces, and returns a list of available monitoring metrics for the specified namespace.

Querying entity instance data

You can ask the large model to query for specific entity instance data using natural language. The MCP Server then calls tools such as umodel_get_entities, umodel_get_metrics, and umodel_list_data_set to retrieve detailed instance data for the entity.

AI tool integration

Cursor / Kiro / Cline (streamable-http mode)

In config.yaml, set server.transport: streamable-http.
Start the service: ./alibabacloud-observability-mcp-server start --config config.yaml.
Configure mcp.json in your AI tool:

{
  "mcpServers": {
    "alibaba_cloud_observability": {
      "url": "http://localhost:8180/streamhttp"
    }
  }
}

Cursor / Kiro / Cline (stdio mode)

Configure mcp.json in your AI tool:

{
  "mcpServers": {
    "alibaba_cloud_observability": {
      "command": "./bin/alibabacloud-observability-mcp-server",
      "args": ["start", "--stdio"],
      "env": {
        "ALIBABA_CLOUD_ACCESS_KEY_ID": "<YOUR_ACCESS_KEY_ID>",
        "ALIBABA_CLOUD_ACCESS_KEY_SECRET": "<YOUR_ACCESS_KEY_SECRET>"
      }
    }
  }
}

In stdio mode, if config.yaml does not exist, the server uses the built-in default.

References

Supported tools

Note

The list of MCP tools updates frequently. To see the most current list, run the ./alibabacloud-observability-mcp-server tools command.

PaaS tools (CloudMonitor 2.0, recommended)

Based on the unified data model, these tools are prefixed with umodel_.

Natural Language Data Query (DataAgent)

Core Purpose: Query observability data in natural language using the platform's agentic retrieval capability. This tool supports data queries for cloud products, APM applications, and custom entities.

Tool name	Purpose	Parameters	Best practices
`cms_natural_language_query`	Natural Language Data Query	`query`: natural language query (required) `workspace`: workspace name (required) `regionId`: Alibaba Cloud region ID (required)	Query data directly using natural language. Supports the `time_range` parameter.

Note: Data retrieval with this tool typically takes 15 to 60 seconds, depending on the task.

UModel metadata query tools

Core Purpose: Search for and retrieve UModel metadata.

Tool name	Purpose	Parameters	Best practices
`umodel_list_data_set`	List datasets of a specified type.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `data_set_types`: dataset types (optional) `regionId`: Alibaba Cloud region ID (required)	Discover available datasets. Understand data structures and fields.
`umodel_search_entity_set`	Search for entity sets.	`workspace`: workspace name (required) `search_text`: search keyword (required) `regionId`: Alibaba Cloud region ID (required)	Discover entity sets by keyword. Supports fuzzy searches.
`umodel_get_entity_set`	Get the schema definition of an entity set.	`domain`: entity domain (required) `entity_set_name`: entity set name (required) `workspace`: workspace name (required) `regionId`: Alibaba Cloud region ID (required) `detail`: whether to return the full schema (optional)	Understand entity structures and available fields. Identifies fields for filtering queries.
`umodel_list_related_entity_set`	List related entity sets.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `regionId`: Alibaba Cloud region ID (required)	Understand the relationships between entity sets. Explore data dependencies.

Entity query tools (entity)

Core Purpose: Retrieve data for an entity and its upstream and downstream entities.

Tool name	Purpose	Parameters	Best practices
`umodel_get_entities`	Get a list of entities for a specified entity set.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `regionId`: Alibaba Cloud region ID (required)	Explore available entity resources. Supports exact queries for specific entities.
`umodel_get_neighbor_entities`	Get the neighbors of an entity.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `entity_ids`: list of entity IDs (required) `regionId`: Alibaba Cloud region ID (required)	Explore service dependencies. Build topology maps.
`umodel_search_entities`	Search for entities that match specified criteria.	`workspace`: workspace name (required) `search_text`: search keyword (required) `regionId`: Alibaba Cloud region ID (required)	Supports complex query conditions. Flexible entity discovery.

Data query tools (data)

Core Purpose: Query various types of observability data associated with an entity and its neighbors.

Tool name	Purpose	Parameters	Best practices
`umodel_get_metrics`	Get time-series metric data for an entity.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `metric_domain_name`: metric domain name (required) `metric`: metric name (required) `regionId`: Alibaba Cloud region ID (required)	Supports range/instant queries. You can specify a time range and aggregation method. Supports `analysis_mode` (`basic`, `cluster`, `forecast`, or `anomaly_detection`). Supports time-series comparison using `offset`.
`umodel_get_golden_metrics`	Get golden metrics data.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `regionId`: Alibaba Cloud region ID (required)	Quickly retrieve key performance indicators. Includes latency, throughput, and error rate. Supports time-series comparison using `offset`.
`umodel_get_relation_metrics`	Get relationship-level metrics between entities.	`workspace`: workspace name (required) `src_domain`: source entity domain (required) `src_entity_set_name`: source entity set name (required) `src_entity_ids`: list of source entity IDs (required) `relation_type`: relationship type (required) `direction`: relationship direction (required) `regionId`: Alibaba Cloud region ID (required)	Analyze microservice call relationships. Supports service dependency analysis.
`umodel_get_logs`	Get log data related to an entity.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `log_set_name`: log set name (required) `log_set_domain`: log set domain (required) `regionId`: Alibaba Cloud region ID (required)	Use for fault diagnosis. Supports performance analysis.
`umodel_get_events`	Get event data for an entity.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `event_set_domain`: event set domain (required) `event_set_name`: event set name (required) `regionId`: Alibaba Cloud region ID (required)	Use for anomaly event analysis. Supports alert event tracking.
`umodel_get_traces`	Get detailed data for specified trace IDs.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `trace_set_domain`: trace set domain (required) `trace_set_name`: trace set name (required) `trace_ids`: list of trace IDs (required) `regionId`: Alibaba Cloud region ID (required)	Perform in-depth analysis of a trace. Includes complete span information.
`umodel_search_traces`	Search for traces based on specified criteria.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `trace_set_domain`: trace set domain (required) `trace_set_name`: trace set name (required) `regionId`: Alibaba Cloud region ID (required)	Filter by duration and error status. Returns trace summary information.
`umodel_get_profiles`	Get performance profiling data.	`workspace`: workspace name (required) `domain`: entity domain (required) `entity_set_name`: entity set name (required) `profile_set_domain`: profile set domain (required) `profile_set_name`: profile set name (required) `entity_ids`: list of entity IDs (required) `regionId`: Alibaba Cloud region ID (required)	Use for performance bottleneck analysis. Includes CPU and memory usage information.

IaaS tools (Log Service and CloudMonitor)

For direct access to the underlying API, tool names are prefixed with sls_ or cms_.

Log Service tools

Tool name	Purpose	Parameters	Best practices
`sls_list_projects`	List Projects.	`regionId` (required)	Discover available Log Service Projects.
`sls_list_logstores`	List Logstores.	`project`, `regionId` (required)	Discover Logstores within a Project.
`sls_text_to_sql`	Convert natural language to SQL.	`text`, `project`, `logStore`, `regionId` (required)	Requires the `sls:CallAiTools` permission.
`sls_text_to_promql`	Convert natural language to PromQL.	`text`, `project`, `metricStore`, `regionId` (required)	Requires the `sls:CallAiTools` permission.
`sls_text_to_spl`	Convert natural language to SPL.	`text`, `project`, `logStore`, `data_sample`, `regionId` (required)	Requires the `sls:CallAiTools` permission.
`sls_execute_sql`	Execute an SQL query.	`project`, `logStore`, `query`, `regionId` (required); `from_time`, `to_time`, `limit`, `offset`, `reverse` (optional)	Directly execute an SQL query.
`sls_execute_spl`	Execute a native SPL query.	`query`, `workspace`, `regionId` (required); `from_time`, `to_time` (optional)	Directly execute an SPL query.
`sls_get_context_logs`	Get log context.	`project`, `logStore`, `pack_id`, `pack_meta`, `regionId` (required); `back_lines`, `forward_lines` (optional)	View the context around a log entry.
`sls_log_explore`	Log exploration and analysis.	`project`, `logStore`, `regionId` (required); `query`, `from_time`, `to_time`, `max_patterns`, `sample_size` (optional)	Automatically discover log patterns.
`sls_log_compare`	Log comparison and analysis.	`project`, `logStore`, `regionId` (required); `current_from_time`, `current_to_time`, `baseline_from_time`, `baseline_to_time` (optional)	Compare logs from different time periods.
`sls_sop`	Log Service O&M assistant.	`text`, `regionId` (required)	Get O&M recommendations.

CloudMonitor tools

Tool name	Purpose	Parameters	Best practices
`cms_execute_promql`	Execute a PromQL query.	`project`, `metricStore`, `query`, `regionId` (required); `from_time`, `to_time` (optional)	Query CloudMonitor metrics with PromQL.

Shared tools

Workspace and domain management

Tool name	Purpose	Parameters	Best practices
`list_workspace`	Get a list of available workspaces.	`regionId`: Alibaba Cloud region ID (required)	Get the list of available workspaces before using other tools. Supports cross-region workspace queries.
`list_domains`	Get all entity domains in a workspace.	`workspace`: workspace name (required) `regionId`: Alibaba Cloud region ID (required)	Check the available domains before querying entities. Understand how data is categorized.
`introduction`	Get an introduction to the service.	No parameters.	Understand the high-level capabilities of the MCP Server.

Time expressions

All data query tools support flexible time range formats:

Format	Example
Relative presets	`last_5m`, `last_1h`, `last_3d`, `last_1w`, `last_1M`, `last_1y`
Relative time	`now()-1h`, `now-30m`, `now()-7d`
Grafana-style	`now-15m~now-5m`, `now/d`, `now-1d/d`
Keywords	`today`, `yesterday`
Absolute timestamps	`1718451045` (seconds), `1718451045000` (milliseconds)
Date-time strings	`2024-01-01 00:00:00`, `2024-01-01T00:00:00Z`

Advanced features

Time-series comparison analysis

The umodel_get_metrics and umodel_get_golden_metrics tools support time-series comparison by using the offset parameter:

# Compare data from the last hour with data from the same window one day ago
umodel_get_metrics(
    domain="apm", entity_set_name="apm.service",
    metric_domain_name="apm.metric.apm.service", metric="request_count",
    time_range="last_1h", offset="1d"
)

The response includes:

current: Statistics for the current period (max, min, avg, count).
compare: Statistics for the comparison period.
diff: Change analysis (trend, avg_change, avg_change_percent).
diff_score: A difference score from 0 to 1. A higher score indicates a more significant difference.

Advanced analysis modes

The umodel_get_metrics tool supports four analysis modes:

Mode	Description	Output fields
`basic`	Raw time-series data (default).	`__ts__`, `__value__`, `__labels__`
`cluster`	K-Means time-series clustering.	`__cluster_index__`, `__entities__`, `__sample_value__`
`forecast`	Time-series forecasting (requires 1–5 days of historical data).	`__forecast_ts__`, `__forecast_value__`, `__forecast_lower/upper_value__`
`anomaly_detection`	Anomaly detection (requires 1–3 days of data).	`__anomaly_list_`, `__anomaly_msg__`, `__value_min/max/avg__`