# UnifyApps MCP > UnifyApps lets your AI agent take over complex system monitoring. You can query all integrations, list every defined automation flow, check active connections, and audit execution logs—all in a single chat interface. It’s built for debugging massive SaaS orchestration systems. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** integration-platform, workflow-automation, pipeline-monitoring, api-management, automation-logic, system-connectivity ## Description **UnifyApps lets you take over complex system monitoring. You can query every integration, list every defined workflow blueprint, check active connection credentials, and audit execution logs—all from a single chat interface. This thing is built for debugging massive SaaS orchestration systems.** **Inventorying What's Coupled** You need to know what services are hooked up before you can fix anything. You'll get a full inventory of every application coupled into UnifyApps using `list_integrations`. That gives you the complete picture of your connected components. If you gotta check on credentials, you've got two ways: first, run `list_active_connections` to see all accounts that are currently logged in and running; or, if you know exactly which connection is giving you trouble, use `get_integration_details(ID)` to pull up specific status information for just that one integration. **Mapping the System Logic** Figuring out how everything talks to each other can be a nightmare. You'll get a structured view of every single possible automation flow blueprint by calling `list_automation_flows`. This lets you map out all your workflows without clicking through nested visual menus and getting lost. For managing the brains behind this operation, use `list_ai_agents` to pull up a list of every AI agent system that's configured within the UnifyApps environment. **Tracking Failures and Successes** When something breaks, you need history—you don't need guesswork. You can run `list_flow_executions` to query recent run logs for any specific automation flow. This tool shows you a clear record of the execution status, letting you see which runs succeeded and which ones failed. That historical data is your primary debugging resource. **How It Works in Practice** Think of this server like a deep-dive console for an operations team. You don't have to jump between five different dashboards to check the health of your whole setup. Instead, you tell your agent what you need—like 'show me all connections that failed last week,' or 'list every integration I've used.' The system talks back with specific data points pulled directly from the tools we laid out. If you find an issue, say a flow isn't running right, you can start by calling `list_automation_flows` to verify the blueprint is correct. Then, check that same flow's execution history using `list_flow_executions`. If the logs look good but it still fails, maybe you gotta dig into the credentials. You'll use `get_integration_details(ID)` on that specific app to make sure the token hasn't expired or gotten revoked. It’s a methodical process: map it, check its connections, and then audit the history. You never have to guess what kind of system you're running. You pull a list of all agents with `list_ai_agents`, verifying that every component—from your most basic connected service (`list_integrations`) to your complex multi-step workflow—is accounted for and working as it should. ## Tools ### get_integration_details Retrieves specific information and status for one integration by its ID. ### list_ai_agents Retrieves a list of every AI agent configured in the UnifyApps system environment. ### list_active_connections Lists all active accounts that are currently connected to UnifyApps. ### list_flow_executions Retrieves a history of recent runs, showing success and failure status for specific automation flows. ### list_automation_flows Lists all defined automation workflow blueprints within the platform. ### list_integrations Lists every configured application that is integrated into UnifyApps. ## Prompt Examples **Prompt:** ``` List all active integration configurations built within our system environment. ``` **Response:** ``` Found 4 distinct integrations spanning: 1. Salesforce CRM (ID: sf_11xx), 2. Outlook (ID: out_20A), 3. Stripe Payments (ID: str_09), and 4. Twilio SMS. Would you like me to deeply inspect the payload mapping of Salesforce? ``` **Prompt:** ``` Isolate execution logs for our overarching flows specifically looking out for the most recent actions resolving internally. ``` **Response:** ``` Executions polled successfully. Among the last 30 actions, 28 were successful HTTP outputs. However, the last 2 triggers connected to 'Stripe' failed via timeout errors. I strongly recommend analyzing the configuration mapping. ``` **Prompt:** ``` Can you check the details of integration connection ID int_99xx1 to see if its credentials are fully configured? ``` **Response:** ``` Integration parsed successfully: ID int_99xx1 correlates mapping the 'Hubspot Source'. Current status reads active and authenticated accurately. No configuration or connectivity mismatch encountered. ``` ## Capabilities ### Audit all connected services Retrieves a full inventory of applications coupled in UnifyApps using the `list_integrations` tool. ### Track workflow execution history Queries recent run logs, showing success/failure metrics for specific automation flows via `list_flow_executions`. ### Map and list defined workflows Retrieves a structured view of every possible automation flow blueprint using `list_automation_flows`. ### Check connection credentials Verifies the status and details of any specific integration connection using `get_integration_details` or `list_active_connections`. ### Inventory system agents Lists all AI agent systems that are currently configured within the UnifyApps environment via `list_ai_agents`. ## Use Cases ### Investigating a payment failure A customer reports an order failed. You ask your agent to check the logs. The agent uses `list_flow_executions` and identifies that the last three Stripe payments timed out. You then use `get_integration_details` on the Stripe connection ID, confirming it's a credential mapping issue, not a payment failure. ### Pre-audit for compliance Before a major audit, you need to prove every connected service is accounted for. You run `list_integrations` and cross-reference the output with your compliance checklist, confirming that all 42 required endpoints are present. ### Debugging orphaned workflows The team thinks a flow isn't running because someone deleted it. You run `list_automation_flows` to verify the blueprint exists, and then use `list_ai_agents` to confirm that no agents are mistakenly pointing at an outdated or non-existent workflow ID. ### Initial system onboarding A new service needs connecting. Instead of asking a teammate for documentation, you run `list_active_connections` first. This shows you which connection types are already active (e.g., 'Outlook', 'Salesforce'), helping you understand the required credential format immediately. ## Benefits - Saves time debugging. Instead of checking ten separate dashboards to see why a flow failed, you run `list_flow_executions` and get a centralized report showing exactly when the failure occurred and where. - Maintains security posture. Use `list_active_connections` to pull massive status lists verifying which credentials are currently linked to prevent unauthorized access endpoints from being missed. - Maps complex systems quickly. Need an overview of how everything runs? Run `list_automation_flows` to see the structural skeleton, avoiding manual navigation through nested menus. - Streamlines agent management. Use `list_ai_agents` to get a full inventory of all AI agents plugged into your system, ensuring no orphaned or forgotten services exist. - Reduces discovery overhead. With `list_integrations`, you immediately see every app connected (Salesforce, Stripe, etc.) without having to check the platform UI manually. ## How It Works The bottom line is that you talk to your agent, and the agent runs the necessary API calls against UnifyApps to give you a single-source view of everything connected. 1. Manually subscribe to this server logic through your connected portal. 2. Provide your overall UnifyApps Base Platform URL and API key to the agent. 3. Direct queries (e.g., 'What failed in the last hour?') to your AI client, letting it use the available tools to pull live data. ## Frequently Asked Questions **How do I use list_flow_executions to find a specific failure?** You ask your agent to run `list_flow_executions` and filter the results by time range or flow name. The output provides success/failure status for recent runs, allowing you to pinpoint exactly when and where the process broke. **Can list_integrations tell me which apps are connected?** Yes. `list_integrations` retrieves a full inventory of every application coupled in UnifyApps. This gives you a complete, single source list of all available integration types. **What is the difference between list_automation_flows and list_integrations?** They track different things. `list_integrations` lists the *applications* (e.g., Salesforce, Stripe). `list_automation_flows` lists the actual *blueprints* or workflows built using those applications. **Does get_integration_details check if a credential is good?** Yes, it checks the specific connection ID you provide. It reads the current status and confirms whether the credentials are authenticated and active, preventing guesswork. **Does list_active_connections show only currently running accounts, or does it report on all linked services?** It lists every account connection configured in your hub. For each entry, you get a status flag—Active, Suspended, or Deprecated—telling you the current operational state of that link. **What metadata does list_ai_agents provide regarding compatibility and dependencies?** The tool lists the agent's unique ID, its name, and which core SDK version it runs on. This helps you quickly verify if an integration requires a specific dependency to function. **If I suspect a connection is corrupted, how can I use list_integrations to detect the failure?** The output of list_integrations includes a 'health status' field for each entry. If credentials are bad or connectivity fails, it reports an error code and a descriptive message right in the listing. **When I run list_automation_flows, is there a limit to how many flows it can retrieve?** The tool supports pagination. It returns results in batches, so if your platform has more workflows than the page size you request, you'll need to call the function again using the provided next page token. **Can the agent simultaneously retrieve all recent failed/successful automation execution logs natively?** Yes. Instigate the 'list_flow_executions' tool payload command. It bypasses internal visualization panels generating the chronological queue, so your model can deduce if major error clusters occurred instantly. **How do I easily audit what 3rd party connections are actively mounted?** Issue a direct command targeting 'list_active_connections'. It pulls back pure lists documenting connected providers (e.g. Stripe, Salesforce) preventing hidden ghost authorizations from silently draining resources. **Does it also list internal AI Agents configured inside the platform natively?** Yes. Utilize 'list_ai_agents' via prompt and your model retrieves every bot profile attached along with baseline configurations proving visibility isn't simply restricted to flows.