Skip to main content
Glama
jamesbrink

MCP Server for Coroot

list_integrations

View configured integrations for a Coroot project to check status of Prometheus, ClickHouse, AWS, Slack, Teams, PagerDuty, Opsgenie, and webhooks.

Instructions

List all configured integrations for a project.

Returns the configuration status of all available integrations:

  • Prometheus

  • ClickHouse

  • AWS

  • Slack

  • Microsoft Teams

  • PagerDuty

  • Opsgenie

  • Webhooks

Args: project_id: Project ID

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
project_idYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • MCP tool handler and registration for 'list_integrations'. This is the entrypoint function decorated with @mcp.tool() that handles the tool execution by delegating to the implementation helper.
    @mcp.tool()
    async def list_integrations(project_id: str) -> dict[str, Any]:
        """List all configured integrations for a project.
    
        Returns the configuration status of all available integrations:
        - Prometheus
        - ClickHouse
        - AWS
        - Slack
        - Microsoft Teams
        - PagerDuty
        - Opsgenie
        - Webhooks
    
        Args:
            project_id: Project ID
        """
        return await list_integrations_impl(project_id)  # type: ignore[no-any-return]
  • Server-side helper function that calls CorootClient.list_integrations(project_id) and wraps the result in a success response.
    @handle_errors
    async def list_integrations_impl(project_id: str) -> dict[str, Any]:
        """List all integrations."""
        integrations = await get_client().list_integrations(project_id)
        return {
            "success": True,
            "integrations": integrations,
        }
  • CorootClient method implementing the core API call to fetch integrations via GET /api/project/{project_id}/integrations.
    async def list_integrations(self, project_id: str) -> dict[str, Any]:
        """List all configured integrations for a project.
    
        Args:
            project_id: Project ID.
    
        Returns:
            Dictionary of integration configurations.
        """
        response = await self._request("GET", f"/api/project/{project_id}/integrations")
        data: dict[str, Any] = response.json()
        return data
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the tool returns configuration status but doesn't disclose behavioral traits like whether it's read-only, requires specific permissions, pagination, rate limits, or error handling. The description adds minimal context beyond the basic operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded with the core purpose. The bulleted list of integrations adds clarity without unnecessary verbosity, and the Args section is concise. Minor improvement possible by integrating parameter info more seamlessly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (1 parameter, list operation) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose and parameter semantics adequately, though it lacks behavioral details that annotations would normally provide.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description explicitly documents the single parameter 'project_id' with a brief explanation. Since there's only one parameter and the description compensates for the lack of schema coverage, this earns a high score, though it could add more context about format or validation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific verb ('List') and resource ('all configured integrations for a project'), and distinguishes from siblings like 'get_integration' (singular) and 'configure_integration' (configure vs. list). It also enumerates the specific integration types returned, providing concrete scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like 'get_integration' (for a single integration) or 'configure_integration' (for setup). The description implies usage for listing integrations but lacks explicit context, prerequisites, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jamesbrink/mcp-coroot'

If you have feedback or need assistance with the MCP directory API, please join our Discord server