Tingyun MCP. Query app metrics and system health via natural language.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Tingyun / 听云 connects your AI agent to an entire application performance monitoring (APM) stack. It lets you query real-time metrics, check alerts, and audit system dependencies—all through natural conversation.
Instead of clicking through complex dashboards for performance data or incident reports, your agent retrieves summarized health scores and specific metric points instantly.
What your AI agents can do
Get account info
Retrieves general metadata about the connected account.
Get app summary
Provides a high-level performance summary for a specific application.
Get metrics
Pulls quantitative metric data points (e.g., average latency, throughput) for analysis.
Get overall performance summaries or list all monitored applications to see the current state of your services.
List active alerts, check alert policies, and identify potential service issues based on predefined rules.
View all linked components—from databases to external services—to understand the full scope of impact if one piece fails.
Query specific metric data points (like latency or throughput) across time ranges for deep trend analysis.
List and inspect Real User Monitoring (RUM) applications to check how the frontend performs for actual users.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Tingyun / 听云 MCP Server: 10 Tools for Observability
Use these tools to perform deep diagnostics. Your agent can list apps, check summaries, pull metrics, and map dependencies across your entire application stack.
019d848eget account info
Retrieves general metadata about the connected account.
019d848eget app summary
Provides a high-level performance summary for a specific application.
019d848eget metrics
Pulls quantitative metric data points (e.g., average latency, throughput) for analysis.
019d848elist alert policies
Shows the criteria and rules used by the system to trigger alerts.
019d848elist alerts
Retrieves a list of all currently active performance warnings or incidents.
019d848elist app instances
Lists the running instances of an application to pinpoint where failures are occurring.
019d848elist applications
Retrieves a full list of all Application Performance Monitoring (APM) applications monitored in your account.
019d848elist browser apps
Lists Real User Monitoring (RUM) browser applications to audit frontend performance data.
019d848elist databases
Retrieves a list of all databases currently being monitored by the platform.
019d848elist external services
Lists external services that your applications connect to, helping map dependencies.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Tingyun / 听云, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Tingyun connects your AI agent straight into a complete application performance monitoring stack. You don't gotta click through dashboards or read massive incident reports; your agent handles all that noise and gives you plain text answers right away. It's like having an SRE sitting next to you, knowing exactly what data you need.
Checking Application Health:
You can check the overall status of everything monitored in your account using get_account_info which pulls general metadata about the connection. To get a quick read on performance, run list_applications to grab a full list of every APM application running. Then, for any specific app, use get_app_summary; that gives you an immediate, high-level health score for the service.
Managing and Reviewing Alerts:
If something's wrong, your agent tells you. You can pull a list of all active performance warnings or incidents with list_alerts. If you wanna know what triggers those alarms in the first place, run list_alert_policies to see the criteria and rules that keep everything running smoothly. By checking these tools, you figure out potential service issues before they get worse.
Deep Dive Performance Analysis:
Need more than a summary? You've got several ways to dig deep into metrics. Use get_metrics to pull specific data points—think average latency or throughput—so you can analyze trends over time ranges. If the app is failing, you don't know where yet; running list_app_instances lists all the running copies of an application, pinpointing exactly which one is having issues.
You can also audit your user experience by using list_browser_apps; this pulls Real User Monitoring (RUM) data so you see how the actual frontend performs for real people.
Mapping System Dependencies:
Figuring out what failed and why takes looking at everything connected. The agent lets you map out all linked components. You can get a list of all databases being monitored with list_databases. If your app talks to other services, running list_external_services shows every external dependency, which is key for understanding the scope if one piece goes down.
It's also smart to know what applications are even available to monitor; run list_applications and list_browser_apps to get a full picture of your monitored surface area.
How Tingyun MCP Works
- 1 Subscribe to the MCP Server and provide your Tingyun API Key and Secret Key.
- 2 Connect your preferred client (Claude, Cursor, etc.) to the server via the Vinkius Marketplace.
- 3 Ask a natural language question. For example: 'Show me the performance summary for the checkout service' or 'List all critical alerts.' Your agent runs the necessary tools and provides the plain text answer.
The bottom line is, you get live observability data delivered directly into your chat window, eliminating the need to navigate any monitoring dashboard.
Who Is Tingyun MCP For?
This is for ops engineers and SREs who are sick of jumping between dashboards just to find a root cause. If you're an engineering manager who needs to quickly audit system dependencies or a technical analyst tracking performance anomalies, this saves hours of clicking. You need deep visibility without the UI overhead.
Runs diagnostic checks during incidents. They use it to correlate alert details with specific metric data and check application instances quickly.
Monitors deployment health. They ask for app summaries after a release or list external services to validate the new pipeline connections.
Performs root cause analysis and capacity planning. They use it to query metric data over time or list monitored databases to assess risk.
What Changes When You Connect
- Instantly check application status. Instead of navigating to a dashboard, asking 'What is the summary for the payment service?' gives you an immediate read on its current performance score using
get_app_summary. - Reduce incident response time. Use
list_alertsandlist_alert_policiestogether to immediately see what's wrong (the alert) and why it triggered (the policy). - Map out your entire stack risk. Combining calls like
list_databases,list_applications, andlist_external_serviceslets you build a dependency map in minutes, without leaving the chat. - Analyze trends deep in the past. The
get_metricstool pulls specific data points over time, letting you prove if that latency spike happened yesterday or last month. - Verify user experience. By calling
list_browser_apps, you audit the frontend performance (RUM) directly against backend metrics, giving a complete picture of the user journey.
Real-World Use Cases
Investigating a sudden latency spike
An SRE sees tickets about slow checkout times. They ask their agent: 'What are the metrics for the Checkout Service?' The agent runs get_metrics, showing average response time jumped 200ms in the last hour, pointing directly to a metric anomaly.
Post-deployment health check
A DevOps engineer just pushed code. They ask: 'Show me the app summary for the User API.' The agent runs get_app_summary and cross-references it with list_alerts. If both are green, the deployment was stable.
Identifying a potential failure point
A technical analyst suspects database connection issues. They ask: 'List all monitored databases and tell me which applications connect to them.' The agent runs list_databases and then uses list_applications, mapping out the risk.
Auditing a service dependency change
A manager needs to know if connecting a new microservice (Service X) requires touching other systems. They ask: 'What external services does Service X rely on?' The agent runs list_external_services, giving them an instant impact assessment.
The Tradeoffs
Manual dashboard clicking
Going to the Tingyun console, finding the application list, opening 5 tabs (Alerts, Metrics, DBs, Services), and manually correlating timestamps across all of them.
→
Instead, ask your agent: 'Show me a full health audit for the payments platform.' The agent runs get_app_summary and pulls dependency data from multiple tools into one cohesive report.
Ambiguous metric requests
Just asking: 'Is performance bad?' This requires human interpretation of ambiguous data spread across several views.
→
Be specific. Ask for the get_metrics tool to check 'error rate percentage over the last 24 hours.' Specific questions yield specific, actionable answers.
Ignoring dependencies
Fixing a bug in Application A but forgetting that it relies on Database B. This causes failure later.
→
Always run list_databases and then cross-reference the results with list_applications. This ensures you account for all system boundaries before making changes.
When It Fits, When It Doesn't
Use this server if your job involves diagnosing complex, multi-layered performance issues. If you need to correlate metrics (latency) with alerts (status) and dependencies (DBs/Services), this is the tool. It's designed for SRE workflows.
Don't use it if all you need is a simple 'Is the website up?' check. For basic uptime monitoring, a simpler dashboard solution works fine. You only bring Tingyun in when you need to know why the site might be slow or failing—when you need metric depth and dependency mapping.
If your primary goal is just listing users or managing accounts, tools outside of APM will handle that better. But for anything related to application performance, this suite is necessary.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Tingyun / 听云. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Dealing with observability dashboards shouldn't mean clicking through five different tabs.
Today, if an incident happens, you open the monitoring platform. You check the main dashboard for alerts. If nothing pops up, you manually click over to the 'Metrics' section. Then you have to switch to the 'Dependencies' tab just to see what services are connected and which database they hit. It’s a frustrating, multi-tab dance that kills incident response time.
With this MCP server, you don't touch a dashboard. You just ask your agent: 'Tell me everything about the Checkout Service.' The system runs `get_app_summary`, pulls dependencies via `list_external_services`, and checks for open issues using `list_alerts`. You get the full story in one chat response.
Tingyun / 听云 MCP Server: Get data, not just dashboards.
You used to have to run separate queries for performance metrics and then manually compare that data against the list of monitored applications. It was a painful copy-paste job across multiple screens, making it hard to spot correlations between an old metric dip and a new dependency failure.
Now, you ask your agent: 'Find me any application where latency increased AND which databases are connected.' The tool combines `get_metrics` with `list_databases`, giving you a direct, correlated answer. It’s immediate, accurate, and saves time.
Common Questions About Tingyun MCP
How do I check overall performance using the Tingyun / 听云 MCP Server? +
You use get_app_summary. Just ask your agent to retrieve the summary for a specific app. It gives you an immediate health score and key metrics without needing to navigate the platform.
Can I find out what external services are connected using Tingyun / 听云 MCP Server? +
Yes, use list_external_services. This tool shows all third-party or internal services your core applications rely on. It's key for mapping risk.
I need to find historical metric data; is the Tingyun / 听云 MCP Server useful? +
The get_metrics tool handles this. You can query specific metrics and time ranges, allowing you to analyze trends that are crucial for capacity planning or post-incident deep dives.
What is the difference between `list_alerts` and `list_alert_policies` with Tingyun / 听云 MCP Server? +
list_alerts shows what's currently broken (active incidents). list_alert_policies shows the rules—the 'if/then' logic—that caused those alerts to fire in the first place.
What information does the `get_account_info` tool provide when using Tingyun / 听云 MCP Server? +
It retrieves your account metadata and basic subscription status. This is useful for quickly verifying connection settings or checking general platform usage limits without needing to dig into performance logs.
How do I use the `list_browser_apps` tool with Tingyun / 听云 MCP Server? +
You list Real User Monitoring (RUM) applications. This lets your agent check frontend performance—it reports on actual user experience metrics, not just backend service health.
What databases are monitored using the `list_databases` tool in Tingyun / 听云 MCP Server? +
The tool lists all connected and monitored database instances. This lets you audit which data sources your applications depend on, helping pinpoint where bottlenecks might start.
What does the `list_app_instances` command do when connected via Tingyun / 听云 MCP Server? +
It lists specific application instances. Instead of seeing an app's overall summary, this tool lets you narrow down monitoring to a single running environment or deployment unit.
How do I find my Tingyun API Key and Secret? +
Log in to your Tingyun console, go to [Account Management] → [API], and you will find your unique API Key and Secret Key there. Ensure you have the necessary permissions enabled.
Can I query specific metric data through this server? +
Yes. Use the get_metrics tool with the application ID and a comma-separated list of metric names. Your agent will retrieve the data points for the specified metrics.
Is it possible to monitor frontend performance? +
Yes! Use the list_browser_apps tool to access performance data from Tingyun RUM (Real User Monitoring) for your web and browser applications.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
OceanBase
Enterprise distributed relational database — manage clusters, tenants, and databases via AI.
Porter PaaS
Orchestrate Kubernetes clusters via Porter — manage apps, projects, container tags, and enforce rollouts directly with your AI.
Color Contrast Checker
Check WCAG color contrast compliance via AI — verify text readability against backgrounds for accessible, inclusive web design.
You might also like
Marqeta
Issue cards, manage users, and process payments via Marqeta's modern card issuing platform.
PagePixels
Capture website screenshots and generate visual previews programmatically with an API that handles rendering at any resolution.
Clientjoy
Manage your entire client lifecycle from proposals and contracts through invoicing and payments in one streamlined platform.