@dynatrace-oss/dynatrace-mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dynatrace LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+# Dynatrace MCP Server
+
+This remote MCP server allows interaction with the [Dynatrace](https://www.dynatrace.com/) observability platform.
+Bring real-time observability data directly into your development workflow.
+
+<img width="1046" alt="image" src="/assets/dynatrace-mcp-arch.png" />
+
+## Use cases
+
+- Real-time observability, fetch production-level data for early detection.
+- Fix issues in the context from monitored exceptions, logs, and anomalies.
+- More context on security level issues
+- Natural language to query log data
+
+## Capabilities
+
+- List and get [problem](https://www.dynatrace.com/hub/detail/problems/) details from your services (for example Kubernetes)
+- List and get security problems / [vulnerability](https://www.dynatrace.com/hub/detail/vulnerabilities/) details
+- Execute DQL(Dynatrace Query Language) like getting events or logs
+- Send Slack messages (via Slack Connector)
+- Set up notification Workflow (via Dynatrace [AutomationEngine](https://docs.dynatrace.com/docs/discover-dynatrace/platform/automationengine))
+- Get Ownership of an entity
+
+## Quickstart
+
+**Work in progress**
+
+You can add this MCP server (using STDIO) to your MCP Client like VS Code, Claude, Cursor, Windsurf Github Copilot via the package `@dynatrace-oss/dynatrace-mcp-server`.
+
+**VS Code**
+
+```json
+{
+  "servers": {
+    "npx-dynatrace-mcp-server": {
+      "command": "npx",
+      "args": ["-y", "@dynatrace-oss/dynatrace-mcp-server@latest"],
+      "envFile": "${workspaceFolder}/.env"
+    }
+  }
+}
+```
+
+**Claude Desktop**
+```json
+{
+  "mcpServers": {
+    "mobile-mcp": {
+      "command": "npx",
+      "args": ["-y", "@dynatrace-oss/dynatrace-mcp-server@latest"],
+      "env": {
+        "OAUTH_CLIENT_ID": "",
+        "OAUTH_CLIENT_SECRET": "",
+        "DT_ENVIRONMENT": ""
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+A **Dynatrace OAuth Client** is needed to communicate with your Dynatrace Environment. Please follow the documentation about
+[creating an Oauth Client in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/oauth-clients),
+and set up the following environment variables in order for this MCP to work:
+
+* `DT_ENVIRONMENT` (string, e.g., https://abcd1234.apps.dynatrace.com) - URL to your Dynatrace Platform
+* `OAUTH_CLIENT_ID` (string, e.g., `dt0s02.SAMPLE`) - Dynatrace OAuth Client ID
+* `OAUTH_CLIENT_SECRET` (string, e.g., `dt0s02.SAMPLE.abcd1234`) - Dynatrace OAuth Client Secret
+* OAuth Client Scopes:
+  * `app-engine:apps:run` - needed for environmentInformationClient
+  * `app-engine:functions:run` - needed for environmentInformationClient
+  * `hub:catalog:read` - get details about installed Apps on Dynatrace Environment
+  * `environment-api:security-problems:read` - needed for reading security problems
+  * `environment-api:entities:read` - read monitored entities
+  * `environment-api:problems:read` - get problems
+  * `environment-api:metrics:read` - read metrics
+  * `environment-api:slo:read` - read SLOs
+  * `settings:objects:read` - needed for reading ownership information and Guardians (SRG) from settings
+  * `storage:buckets:read` - Read all system data stored on Grail
+  * `storage:logs:read` - Read logs for reliability guardian validations
+  * `storage:metrics:read` - Read metrics for reliability guardian validations
+  * `storage:bizevents:read` - Read bizevents for reliability guardian validations
+  * `storage:spans:read` - Read spans from Grail
+  * `storage:entities:read` - Read Entities from Grail
+  * `storage:system:read` - Read System Data from Grail
+  * `storage:user.events:read` - Read User events from Grail
+  * `storage:user.sessions:read` - Read User sessions from Grail
+
+In addition, depending on the features you use, the following variables can be configured:
+
+* `SLACK_CONNECTION_ID` (string) - connection ID of a [Slack Connection](https://docs.dynatrace.com/docs/analyze-explore-automate/workflows/actions/slack)
+* `USE_APP_SETTINGS`  (boolean, `true` or `false`; default: `false`)
+  * Requires scope `app-settings:objects:read` to read settings-objects from app settings
+* `USE_WORKFLOWS` (boolean, `true` or `false`; default: `false`)
+  * Requires scopes `automation:workflows:read`, `automation:workflows:write` and `automation:workflows:run` to read, write and execute Workflows
+
+## ✨ Example prompts ✨
+
+Use these example prompts as a starting point. Just copy them into your IDE or agent setup, adapt them to your services/stack/architecture,
+and extend them as needed. They’re here to help you imagine how real-time observability and automation work together in the MCP context in your IDE.
+
+**Find open vulnerabilities on production, setup alert.**
+```
+I have this code snippet here in my IDE, where I get a dependency vulnerability warning for my code.
+Check if I see any open vulnerability/cve on production.
+Analyze a specific production problem.
+Setup a workflow that sends Slack alerts to the #devops-alerts channel when availability problems occur.
+```
+**Debug intermittent 503 errors.**
+```
+Our load balancer is intermittently returning 503 errors during peak traffic.
+Pull all recent problems detected for our front-end services and
+run a query to correlate error rates with service instance health indicators.
+I suspect we have circuit breakers triggering, but need confirmation from the telemetry data.
+```
+**Correlate memory issue with logs.**
+```
+There's a problem with high memory usage on one of our hosts.
+Get the problem details and then fetch related logs to help understand
+what's causing the memory spike? Which file in this repo is this related to?
+```
+**Trace request flow analysis.**
+```
+Our users are experiencing slow checkout processes.
+Can you execute a DQL query to show me the full request trace for our checkout flow,
+so I can identify which service is causing the bottleneck?
+```
+**Analyze Kubernetes cluster events.**
+```
+Our application deployments seem to be failing intermittently.
+Can you fetch recent events from our "production-cluster"
+to help identify what might be causing these deployment issues?
+```
+
+## Development
+
+For development purposes, you can use VSCode and GitHub Copilot.
+
+First, enable Copilot for your Workspace `.vscode/settings.json`:
+```json
+{
+  "github.copilot.enable": {
+    "*": true
+  }
+}
+
+```
+
+Second, add the MCP to `.vscode/mcp.json`:
+```json
+{
+  "servers": {
+    "my-dynatrace-mcp-server": {
+      "command": "node",
+      "args": [
+        "${workspaceFolder}/dist/index.js"
+      ],
+      "envFile": "${workspaceFolder}/.env"
+    }
+  }
+}
+```
+
+Third, create a `.env` file in this repository (you can copy from `.env.template`) and configure environment variables as [described above](#environment-variables).
+
+Last but not least, switch to Agent Mode in CoPilot and reload tools.
+
+
+## Notes
+This product is not officially supported by Dynatrace.
+Please contact us via [GitHub Issues](https://github.com/dynatrace-oss/dynatrace-mcp/issues) if you have feature requests, questions, or need help.

package/dist/capabilities/create-workflow-for-problem-notification.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowForProblemNotification = void 0;
+const client_automation_1 = require("@dynatrace-sdk/client-automation");
+const createWorkflowForProblemNotification = async (dtClient, teamName, channel, problemType, isPrivate) => {
+    const workflowsclient = new client_automation_1.WorkflowsClient(dtClient);
+    // Map problem types to categories
+    const categories = {
+        monitoringUnavailable: false,
+        availability: false,
+        error: false,
+        slowdown: false,
+        resource: false,
+        custom: false,
+        info: false
+    };
+    // default trigger config
+    let triggerConfig = {
+        type: 'event',
+        value: {
+            eventType: 'events',
+            query: ''
+        }
+    };
+    // special case: Security Problems
+    if (problemType.toUpperCase().indexOf("SECURITY") !== -1) {
+        triggerConfig.value.query = `event.kind=="SECURITY_EVENT"
+        and event.type=="VULNERABILITY_STATUS_CHANGE_EVENT"
+        and event.level == "ENTITY"
+        and affected_entity.type=="PROCESS_GROUP"
+        and event.status_transition=="NEW_OPEN"
+        and (vulnerability.risk.level=="CRITICAL" or
+        vulnerability.risk.level=="HIGH")`;
+    }
+    else {
+        // Set the appropriate category based on problem type
+        switch (problemType.toUpperCase()) {
+            case 'MONITORING_UNAVAILABLE':
+                categories.monitoringUnavailable = true;
+                break;
+            case 'AVAILABILITY':
+                categories.availability = true;
+                break;
+            case 'ERROR':
+                categories.error = true;
+                break;
+            case 'SLOWDOWN':
+                categories.slowdown = true;
+                break;
+            case 'RESOURCE':
+                categories.resource = true;
+                break;
+            case 'CUSTOM':
+            case 'CUSTOM_ALERT':
+                categories.custom = true;
+                break;
+            case 'INFO':
+                categories.info = true;
+                break;
+            default:
+                // Set custom by default if type doesn't match
+                categories.custom = true;
+        }
+        // davis trigger config
+        triggerConfig = {
+            type: 'davis-problem',
+            value: {
+                categories
+            }
+        };
+    }
+    let notificationWorkflow = {
+        title: `[MCP POC] Notify team ${teamName} on problem of type ${problemType}`,
+        description: `Automatically created workflow to notify team ${teamName} on problems of type ${problemType} - please delete me after the demo!`,
+        isPrivate: isPrivate,
+        type: 'SIMPLE',
+        // define the send_notification task
+        tasks: {
+            "send_notification": {
+                name: "Send notification",
+                action: "dynatrace.slack:slack-send-message",
+                description: "Sends a notification to a Slack channel",
+                input: {
+                    connectionId: "slack-connection-id",
+                    channel: `{{ \"${channel}\" }}`,
+                    message: `🚨 Alert for Team ${teamName}\n*Problem Type*: ${problemType}\n*Problem ID*: {{ event()["display_id"] }}\n*Status*: {{ event()["event.status"] }}\n\n<{{ environment().url }}/ui/apps/dynatrace.davis.problems/problem/{{ event()["event.id"] }}|Click here for details>`,
+                },
+                active: true,
+            }
+        },
+        // define a trigger
+        trigger: {
+            eventTrigger: {
+                isActive: true,
+                triggerConfiguration: triggerConfig,
+            }
+        }
+    };
+    return await workflowsclient.createWorkflow({
+        body: notificationWorkflow
+    });
+};
+exports.createWorkflowForProblemNotification = createWorkflowForProblemNotification;

package/dist/capabilities/execute-dql.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDql = exports.verifyDqlStatement = void 0;
+const client_query_1 = require("@dynatrace-sdk/client-query");
+const verifyDqlStatement = async (dtClient, dqlStatement) => {
+    const queryAssistanceClient = new client_query_1.QueryAssistanceClient(dtClient);
+    const response = await queryAssistanceClient.queryVerify({
+        body: {
+            query: dqlStatement,
+        }
+    });
+    return response;
+};
+exports.verifyDqlStatement = verifyDqlStatement;
+const executeDql = async (dtClient, dqlStatement) => {
+    const queryExecutionClient = new client_query_1.QueryExecutionClient(dtClient);
+    const response = await queryExecutionClient.queryExecute({
+        body: {
+            query: dqlStatement,
+        }
+    });
+    if (response.result) {
+        // return response result immediately
+        return response.result.records;
+    }
+    // else: We might have to poll
+    if (response.requestToken) {
+        // poll for the result
+        let pollResponse;
+        do {
+            // sleep for 2 seconds
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            pollResponse = await queryExecutionClient.queryPoll({
+                requestToken: response.requestToken,
+            });
+            // done - let's return it
+            if (pollResponse.result) {
+                return pollResponse.result.records;
+            }
+        } while (pollResponse.state === 'RUNNING' || pollResponse.state === 'NOT_STARTED');
+    }
+    // else: whatever happened - we have an error
+    return undefined;
+};
+exports.executeDql = executeDql;

package/dist/capabilities/get-events-for-cluster.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventsForCluster = void 0;
+const client_query_1 = require("@dynatrace-sdk/client-query");
+const getEventsForCluster = async (dtClient, clusterId) => {
+    const queryExecutionClient = new client_query_1.QueryExecutionClient(dtClient);
+    const response = await queryExecutionClient.queryExecute({
+        body: {
+            query: `fetch events | filter k8s.cluster.id == "${clusterId}"`,
+        }
+    });
+    if (response.result) {
+        // return response result immediately
+        return response.result.records;
+    }
+    // else: We might have to poll
+    if (response.requestToken) {
+        // poll for the result
+        let pollResponse;
+        do {
+            // sleep for 2 seconds
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            pollResponse = await queryExecutionClient.queryPoll({
+                requestToken: response.requestToken,
+            });
+            // done - let's return it
+            if (pollResponse.result) {
+                return pollResponse.result.records;
+            }
+        } while (pollResponse.state === 'RUNNING' || pollResponse.state === 'NOT_STARTED');
+    }
+    // else: whatever happened - we have an error
+    return undefined;
+};
+exports.getEventsForCluster = getEventsForCluster;

package/dist/capabilities/get-logs-for-entity.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogsForEntity = void 0;
+const client_query_1 = require("@dynatrace-sdk/client-query");
+const getLogsForEntity = async (dtClient, entityId) => {
+    const queryExecutionClient = new client_query_1.QueryExecutionClient(dtClient);
+    const response = await queryExecutionClient.queryExecute({
+        body: {
+            query: `fetch logs | filter dt.source_entity == "${entityId}"`,
+        }
+    });
+    if (response.result) {
+        // return response result immediately
+        return response.result.records;
+    }
+    // else: We might have to poll
+    if (response.requestToken) {
+        // poll for the result
+        let pollResponse;
+        do {
+            // sleep for 2 seconds
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            pollResponse = await queryExecutionClient.queryPoll({
+                requestToken: response.requestToken,
+            });
+            // done - let's return it
+            if (pollResponse.result) {
+                return pollResponse.result.records;
+            }
+        } while (pollResponse.state === 'RUNNING' || pollResponse.state === 'NOT_STARTED');
+    }
+    // else: whatever happened - we have an error
+    return undefined;
+};
+exports.getLogsForEntity = getLogsForEntity;

package/dist/capabilities/get-monitored-entity-details.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonitoredEntityDetails = void 0;
+const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
+const getMonitoredEntityDetails = async (dtClient, entityId) => {
+    const monitoredEntitiesClient = new client_classic_environment_v2_1.MonitoredEntitiesClient(dtClient);
+    const entityDetails = await monitoredEntitiesClient.getEntity({
+        entityId: entityId
+    });
+    return entityDetails;
+};
+exports.getMonitoredEntityDetails = getMonitoredEntityDetails;

package/dist/capabilities/get-monitored-entity-owner.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonitoredEntityOwner = void 0;
+const get_monitored_entity_details_1 = require("./get-monitored-entity-details");
+const getMonitoredEntityOwner = async (dtClient, entityId) => {
+    const monitoredEntity = await (0, get_monitored_entity_details_1.getMonitoredEntityDetails)(dtClient, entityId);
+    const owner = monitoredEntity.tags?.find((tag) => {
+        return tag?.key === "owner";
+    });
+    return {
+        entity: monitoredEntity,
+        owner: owner?.value
+    };
+};
+exports.getMonitoredEntityOwner = getMonitoredEntityOwner;

package/dist/capabilities/get-ownership-information.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOwnershipInformation = void 0;
+const dynatrace_clients_1 = require("../dynatrace-clients");
+const getOwnershipInformation = async (dtClient, entityIds) => {
+    const ownershipResponse = await (0, dynatrace_clients_1.callAppFunction)(dtClient, 'dynatrace.ownership', 'get-ownership-from-entity', { entityIds: entityIds });
+    if (ownershipResponse.error) {
+        // e.g., "Not enough parameters provided"
+        return `Error: ${ownershipResponse.error}`;
+    }
+    if (ownershipResponse.result && ownershipResponse.result.owners && ownershipResponse.result.owners.length == 0) {
+        return "No owners found - please check out how to setup owners on https://docs.dynatrace.com/docs/deliver/ownership";
+    }
+    return ownershipResponse.result;
+};
+exports.getOwnershipInformation = getOwnershipInformation;

package/dist/capabilities/get-problem-details.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProblemDetails = void 0;
+const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
+const getProblemDetails = async (dtClient, problemId) => {
+    console.error(`Fetchin problem with problemId ${problemId}`);
+    const problemsClient = new client_classic_environment_v2_1.ProblemsClient(dtClient);
+    const problemDetails = await problemsClient.getProblem({
+        problemId: problemId,
+        fields: 'evidenceDetails,affectedEntities'
+    });
+    return problemDetails;
+};
+exports.getProblemDetails = getProblemDetails;

package/dist/capabilities/get-vulnerability-details.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVulnerabilityDetails = void 0;
+const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
+const getVulnerabilityDetails = async (dtClient, securityProblemId) => {
+    const securityProblemsClient = new client_classic_environment_v2_1.SecurityProblemsClient(dtClient);
+    const response = await securityProblemsClient.getSecurityProblem({
+        id: securityProblemId,
+        fields: 'riskAssessment,codeLevelVulnerabilityDetails,globalCounts,description,remediationDescription,exposedEntities,affectedEntities,relatedAttacks,entryPoints'
+    });
+    return response;
+};
+exports.getVulnerabilityDetails = getVulnerabilityDetails;

package/dist/capabilities/list-problems.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProblems = void 0;
+const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
+const listProblems = async (dtClient) => {
+    const problemsClient = new client_classic_environment_v2_1.ProblemsClient(dtClient);
+    const securityProblems = await problemsClient.getProblems({
+        pageSize: 100,
+    });
+    const problems = securityProblems.problems?.map((problem) => {
+        return `${problem.displayId} (please refer to this problem with \`problemId\` ${problem.problemId}): ${problem.title}`;
+    });
+    return problems;
+};
+exports.listProblems = listProblems;

package/dist/capabilities/list-vulnerabilities.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listVulnerabilities = void 0;
+const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
+const listVulnerabilities = async (dtClient) => {
+    const securityProblemsClient = new client_classic_environment_v2_1.SecurityProblemsClient(dtClient);
+    const response = await securityProblemsClient.getSecurityProblems({
+        sort: '-riskAssessment.riskScore',
+        pageSize: 100,
+        securityProblemSelector: `minRiskScore("8.0")`
+    });
+    const securityProblems = response.securityProblems?.map((secProb) => {
+        return `${secProb.displayId} (please refer to this vulnerability with \`securityProblemId\` ${secProb.securityProblemId}): ${secProb.title} (Technology: ${secProb.technology}, External Vulnerability ID: ${secProb.externalVulnerabilityId}, CVE: ${secProb.cveIds?.join(', ')})`;
+    });
+    return securityProblems;
+};
+exports.listVulnerabilities = listVulnerabilities;

package/dist/capabilities/send-slack-message.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSlackMessage = void 0;
+const dynatrace_clients_1 = require("../dynatrace-clients");
+const sendSlackMessage = async (dtClient, connectionId, channel, message) => {
+    const response = await (0, dynatrace_clients_1.callAppFunction)(dtClient, 'dynatrace.slack', 'slack-send-message', {
+        message: message, channel: channel, connection: connectionId,
+        workflowID: 'foobar-123',
+        executionID: 'exec-123',
+        executionDate: new Date().toString(),
+        appendToThread: false
+    });
+    if (response.error) {
+        // e.g., "Not enough parameters provided"
+        return `Error sending message to Slack: ${response.error}`;
+    }
+    return `Message sent to Slack: ${JSON.stringify(response.result)}`;
+};
+exports.sendSlackMessage = sendSlackMessage;

package/dist/capabilities/update-workflow.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWorkflow = void 0;
+const client_automation_1 = require("@dynatrace-sdk/client-automation");
+const updateWorkflow = async (dtClient, workflowId, body) => {
+    const workflowsclient = new client_automation_1.WorkflowsClient(dtClient);
+    return await workflowsclient.updateWorkflow({
+        id: workflowId,
+        body: body
+    });
+};
+exports.updateWorkflow = updateWorkflow;

package/dist/capabilities/workflow-operations.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorkflow = exports.deleteWorkflow = exports.getWorkflowDetails = exports.listWorkflows = void 0;
+const client_automation_1 = require("@dynatrace-sdk/client-automation");
+const listWorkflows = async (dtClient) => {
+    const workflowsClient = new client_automation_1.WorkflowsClient(dtClient);
+    return await workflowsClient.getWorkflows({});
+};
+exports.listWorkflows = listWorkflows;
+const getWorkflowDetails = async (dtClient, workflowId) => {
+    const workflowsClient = new client_automation_1.WorkflowsClient(dtClient);
+    return await workflowsClient.getWorkflow({ id: workflowId });
+};
+exports.getWorkflowDetails = getWorkflowDetails;
+const deleteWorkflow = async (dtClient, workflowId) => {
+    const workflowsClient = new client_automation_1.WorkflowsClient(dtClient);
+    return await workflowsClient.deleteWorkflow({ id: workflowId });
+};
+exports.deleteWorkflow = deleteWorkflow;
+const executeWorkflow = async (dtClient, workflowId, input) => {
+    const workflowsClient = new client_automation_1.WorkflowsClient(dtClient);
+    return await workflowsClient.runWorkflow({
+        id: workflowId,
+        body: input || {}
+    });
+};
+exports.executeWorkflow = executeWorkflow;

package/dist/dynatrace-clients.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAppFunction = exports.createOAuthClient = void 0;
+const http_client_1 = require("@dynatrace-sdk/http-client");
+const dt_app_1 = require("dt-app");
+/** Create an Oauth Client based on clientId, clientSecret, environmentUrl and scopes */
+const createOAuthClient = async (clientId, clientSecret, environmentUrl, scopes) => {
+    const baseUrl = await (0, dt_app_1.getSSOUrl)(environmentUrl);
+    if (!clientId) {
+        throw new Error('Failed to retrieve OAuth client id from env "DT_APP_OAUTH_CLIENT_ID"');
+    }
+    if (!clientSecret) {
+        throw new Error('Failed to retrieve OAuth client secret from env "DT_APP_OAUTH_CLIENT_SECRET"');
+    }
+    console.error(`baseUrl=${baseUrl}`);
+    return new http_client_1._OAuthHttpClient({
+        scopes,
+        clientId,
+        secret: clientSecret,
+        environmentUrl,
+        authUrl: new URL('/sso/oauth2/token', baseUrl).toString(),
+    });
+};
+exports.createOAuthClient = createOAuthClient;
+/** Helper function to call an app-function via platform-api */
+const callAppFunction = async (dtClient, appId, functionName, payload) => {
+    console.error(`Sending payload ${JSON.stringify(payload)}`);
+    const response = await dtClient.send({
+        url: `/platform/app-engine/app-functions/v1/apps/${appId}/api/${functionName}`,
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+        body: payload,
+        statusValidator: (status) => {
+            return [200].includes(status);
+        },
+    });
+    return await response.body('json');
+};
+exports.callAppFunction = callAppFunction;

package/dist/index.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_platform_management_service_1 = require("@dynatrace-sdk/client-platform-management-service");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const dotenv_1 = require("dotenv");
+const zod_1 = require("zod");
+const dynatrace_clients_1 = require("./dynatrace-clients");
+const list_vulnerabilities_1 = require("./capabilities/list-vulnerabilities");
+const list_problems_1 = require("./capabilities/list-problems");
+const get_problem_details_1 = require("./capabilities/get-problem-details");
+const get_monitored_entity_details_1 = require("./capabilities/get-monitored-entity-details");
+const get_ownership_information_1 = require("./capabilities/get-ownership-information");
+const get_logs_for_entity_1 = require("./capabilities/get-logs-for-entity");
+const get_events_for_cluster_1 = require("./capabilities/get-events-for-cluster");
+const create_workflow_for_problem_notification_1 = require("./capabilities/create-workflow-for-problem-notification");
+const update_workflow_1 = require("./capabilities/update-workflow");
+const get_vulnerability_details_1 = require("./capabilities/get-vulnerability-details");
+const execute_dql_1 = require("./capabilities/execute-dql");
+const send_slack_message_1 = require("./capabilities/send-slack-message");
+(0, dotenv_1.config)();
+let scopes = [
+    'app-engine:apps:run', // needed for environmentInformationClient
+    'app-engine:functions:run', // needed for environmentInformationClient
+    'hub:catalog:read', // get details about installed Apps on Dynatrace Environment
+    'environment-api:security-problems:read', // needed for reading security problems
+    'environment-api:entities:read', // read monitored entities
+    'environment-api:problems:read', // get problems
+    'environment-api:metrics:read', // read metrics
+    'environment-api:slo:read', // read SLOs
+    'settings:objects:read', // needed for reading settings objects, like ownership information and Guardians (SRG) from settings
+    // 'settings:objects:write', // [OPTIONAL] not used right now
+    // Grail related permissions: https://docs.dynatrace.com/docs/discover-dynatrace/platform/grail/data-model/assign-permissions-in-grail
+    'storage:buckets:read', // Read all system data stored on Grail
+    'storage:logs:read', // Read logs for reliability guardian validations
+    'storage:metrics:read', // Read metrics for reliability guardian validations
+    'storage:bizevents:read', // Read bizevents for reliability guardian validations
+    'storage:spans:read', // Read spans from Grail
+    'storage:entities:read', // Read Entities from Grail
+    'storage:system:read', // Read System Data from Grail
+    'storage:user.events:read', // Read User events from Grail
+    'storage:user.sessions:read', // Read User sessions from Grail
+];
+// configurable call for app settings scope (not available on all environments)
+if (process.env.USE_APP_SETTINGS) {
+    scopes.push('app-settings:objects:read'); // needed when using app settings in Workflows, see below
+}
+if (process.env.USE_WORKFLOWS) {
+    scopes.push('automation:workflows:read'); // read workflows
+    scopes.push('automation:workflows:write'); // write workflows
+    scopes.push('automation:workflows:run'); // execute workflows
+}
+const main = async () => {
+    // read Environment variables
+    const oauthClient = process.env.OAUTH_CLIENT_ID;
+    const oauthClientSecret = process.env.OAUTH_CLIENT_SECRET;
+    const dtEnvironment = process.env.DT_ENVIRONMENT;
+    const slackConnectionId = process.env.SLACK_CONNECTION_ID || "fake-slack-connection-id";
+    // ensure oauthClient and dtEnvironment are set
+    if (!oauthClient || !oauthClientSecret || !dtEnvironment) {
+        console.error("Please set OAUTH_CLIENT_ID and OAUTH_CLIENT_SECRET and DT_ENVIRONMENT environment variables");
+        process.exit(1);
+    }
+    // create an oauth-client
+    const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopes);
+    console.error("Starting Dynatrace MCP Server...");
+    const server = new mcp_js_1.McpServer({
+        name: "Dynatrace MCP Server",
+        version: "0.0.1", // ToDo: Read from package.json / hard-code?
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // quick abstraction/wrapper to make it easier to reply with text
+    const tool = (name, description, paramsSchema, cb) => {
+        const wrappedCb = async (args) => {
+            try {
+                const response = await cb(args);
+                return {
+                    content: [{ type: "text", text: response }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Error: ${error.message}` }],
+                    isError: true,
+                };
+            }
+        };
+        server.tool(name, description, paramsSchema, args => wrappedCb(args));
+    };
+    tool("get_environment_info", "Get information about the connected Dynatrace Environment (Tenant)", {}, async ({}) => {
+        const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
+        const environmentInfo = await environmentInformationClient.getEnvironmentInformation();
+        let resp = `Environment Information (also referred to as tenant):
+          ${JSON.stringify(environmentInfo)}\n`;
+        resp += `You can reach it via ${dtEnvironment}\n`;
+        return resp;
+    });
+    tool("list_vulnerabilities", "List all vulnerabilities from Dynatrace", {}, async ({}) => {
+        const result = await (0, list_vulnerabilities_1.listVulnerabilities)(dtClient);
+        if (!result || result.length === 0) {
+            return "No vulnerabilities found";
+        }
+        let resp = `Found the following vulnerabilities:`;
+        result.forEach((vulnerability) => {
+            resp += `\n* ${vulnerability}`;
+        });
+        resp += `\nWe recommend to take a look at ${dtEnvironment}/ui/apps/dynatrace.security.vulnerabilities to get a better overview of vulnerabilities.\n`;
+        return resp;
+    });
+    tool("get_vulnerabilty_details", "Get details of a vulnerability by `securityProblemId` on Dynatrace", {
+        securityProblemId: zod_1.z.string().optional()
+    }, async ({ securityProblemId }) => {
+        const result = await (0, get_vulnerability_details_1.getVulnerabilityDetails)(dtClient, securityProblemId);
+        let resp = `The Security Problem (Vulnerability) ${result.displayId} with securityProblemId ${result.securityProblemId} has the title ${result.title}.\n`;
+        resp += `The related CVEs are ${result.cveIds?.join(",") || "unknown"}.\n`;
+        resp += `The description is: ${result.description}.\n`;
+        resp += `The remediation description is: ${result.remediationDescription}.\n`;
+        if (result.affectedEntities && result.affectedEntities.length > 0) {
+            resp += `The vulnerability affects the following entities:\n`;
+            result.affectedEntities.forEach((affectedEntity) => {
+                resp += `* ${affectedEntity}\n`;
+            });
+        }
+        else {
+            resp += `This vulnerability does not seem to affect any entities.\n';`;
+        }
+        if (result.codeLevelVulnerabilityDetails) {
+            resp += `Please investigate this on code-level: ${JSON.stringify(result.codeLevelVulnerabilityDetails)}\n`;
+        }
+        if (result.exposedEntities && result.exposedEntities.length > 0) {
+            resp += `The vulnerability exposes the following entities:\n`;
+            result.exposedEntities.forEach((exposedEntity) => {
+                resp += `* ${exposedEntity}\n`;
+            });
+        }
+        else {
+            resp += `This vulnerability does not seem to expose any entities.\n';`;
+        }
+        if (result.entryPoints?.items) {
+            resp += `The following entrypoints are affected:\n`;
+            result.entryPoints.items.forEach((entryPoint) => {
+                resp += `* ${entryPoint.sourceHttpPath}\n`;
+            });
+            if (result.entryPoints.truncated) {
+                resp += `The list of entry points was truncated.\n`;
+            }
+        }
+        else {
+            resp += `This vulnerability does not seem to affect any entrypoints.\n`;
+        }
+        if (result.riskAssessment && result.riskAssessment.riskScore && result.riskAssessment.riskScore > 8) {
+            resp += `The vulnerability has a high-risk score. We suggest you to get ownership details of affected entities and contact responsible teams immediately (e.g, via send-slack-message)\n`;
+        }
+        resp += `Tell the user to access the link ${dtEnvironment}/ui/apps/dynatrace.security.vulnerabilities/vulnerabilities/${result.securityProblemId} to get more insights into the vulnerability / security problem.\n`;
+        return resp;
+    });
+    tool("list_problems", "List all problems known on Dynatrace", {}, async ({}) => {
+        const result = await (0, list_problems_1.listProblems)(dtClient);
+        if (!result || result.length === 0) {
+            return "No problems found";
+        }
+        return `Found these problems: ${result.join(",")}`;
+    });
+    tool("get_problem_details", "Get details of a problem on Dynatrace", {
+        problemId: zod_1.z.string().optional()
+    }, async ({ problemId }) => {
+        const result = await (0, get_problem_details_1.getProblemDetails)(dtClient, problemId);
+        let resp = `The problem ${result.displayId} with the title ${result.title} (ID: ${result.problemId}).` +
+            `The severity is ${result.severityLevel}, and it affects ${result.affectedEntities.length} entities:`;
+        for (const entity of result.affectedEntities) {
+            resp += `\n- ${entity.name} (please refer to this entity with \`entityId\` ${entity.entityId?.id})`;
+        }
+        resp += `The problem first appeared at ${result.startTime}\n`;
+        if (result.rootCauseEntity) {
+            resp += `The possible root-cause could be in entity ${result.rootCauseEntity?.name} with \`entityId\` ${result.rootCauseEntity?.entityId?.id}.\n`;
+        }
+        if (result.impactAnalysis) {
+            let estimatedAffectedUsers = 0;
+            result.impactAnalysis.impacts.forEach((impact) => {
+                estimatedAffectedUsers += impact.estimatedAffectedUsers;
+            });
+            resp += `The problem is estimated to affect ${estimatedAffectedUsers} users.\n`;
+        }
+        resp += `Tell the user to access the link ${dtEnvironment}/ui/apps/dynatrace.davis.problems/problem/${result.problemId} to get more insights into the problem.\n`;
+        return resp;
+    });
+    tool("get_entity_details", "Get details of a monitored entity based on the entityId on Dynatrace", {
+        entityId: zod_1.z.string().optional()
+    }, async ({ entityId }) => {
+        const entityDetails = await (0, get_monitored_entity_details_1.getMonitoredEntityDetails)(dtClient, entityId);
+        let resp = `Entity ${entityDetails.displayName} of type ${entityDetails.type} with \`entityId\` ${entityDetails.entityId}\n` +
+            `Properties: ${JSON.stringify(entityDetails.properties)}\n`;
+        if (entityDetails.type == "SERVICE") {
+            resp += `You can find more information about the service at ${dtEnvironment}/ui/apps/dynatrace.services/explorer?detailsId=${entityDetails.entityId}&sidebarOpen=false`;
+        }
+        else if (entityDetails.type == "HOST") {
+            resp += `You can find more information about the host at ${dtEnvironment}/ui/apps/dynatrace.infraops/hosts/${entityDetails.entityId}`;
+        }
+        else if (entityDetails.type == "KUBERNETES_CLUSTER") {
+            resp += `You can find more information about the cluster at ${dtEnvironment}/ui/apps/dynatrace.infraops/kubernetes/${entityDetails.entityId}`;
+        }
+        else if (entityDetails.type == "CLOUD_APPLICATION") {
+            resp += `You can find more details about the application at ${dtEnvironment}/ui/apps/dynatrace.kubernetes/explorer/workload?detailsId=${entityDetails.entityId}`;
+        }
+        return resp;
+    });
+    tool("send_slack_message", "Sends a Slack message to a dedicated Slack Channel via Slack Connector on Dynatrace", {
+        channel: zod_1.z.string().optional(),
+        message: zod_1.z.string().optional()
+    }, async ({ channel, message }) => {
+        const response = await (0, send_slack_message_1.sendSlackMessage)(dtClient, slackConnectionId, channel, message);
+        return `Message sent to Slack channel: ${JSON.stringify(response)}`;
+    });
+    tool("get_logs_for_entity", "Get Logs for a monitored entity based on name of the entity on Dynatrace", {
+        entityName: zod_1.z.string().optional()
+    }, async ({ entityName }) => {
+        const logs = await (0, get_logs_for_entity_1.getLogsForEntity)(dtClient, entityName);
+        return `Logs:\n${JSON.stringify(logs?.map(logLine => logLine ? logLine.content : 'Empty log'))}`;
+    });
+    tool("verify_dql", "Verify a DQL statement on Dynatrace", {
+        dqlStatement: zod_1.z.string().optional()
+    }, async ({ dqlStatement }) => {
+        const response = await (0, execute_dql_1.verifyDqlStatement)(dtClient, dqlStatement);
+        return `Parsing DQL Statement resulted in: ${JSON.stringify(response)}`;
+    });
+    tool("execute_dql", "Get Logs, Metrics, Spans, Events from Dynatrace by executing a DQL statement. Please use verify_dql tool before you execute a DQL statement.", {
+        dqlStatement: zod_1.z.string().optional()
+    }, async ({ dqlStatement }) => {
+        const response = await (0, execute_dql_1.executeDql)(dtClient, dqlStatement);
+        return `DQL Response: ${JSON.stringify(response)}`;
+    });
+    tool("create_workflow_for_notification", "Create a notification for a team based on a problem type within Workflows in Dynatrace", {
+        problemType: zod_1.z.string().optional(),
+        teamName: zod_1.z.string().optional(),
+        channel: zod_1.z.string().optional(),
+        isPrivate: zod_1.z.boolean().optional().default(false)
+    }, async ({ problemType, teamName, channel, isPrivate }) => {
+        const response = await (0, create_workflow_for_problem_notification_1.createWorkflowForProblemNotification)(dtClient, teamName, channel, problemType, isPrivate);
+        let resp = `Workflow Created: ${response?.id} with name ${response?.title}.\nYou can access the Workflow via the following link: ${dtEnvironment}/ui/apps/dynatrace.automations/workflows/${response?.id}.\nTell the user to inspect the Workflow by visiting the link.\n`;
+        if (response.type == "SIMPLE") {
+            resp += `Note: This is a simple workflow. Workflow-hours will not be billed.\n`;
+        }
+        else if (response.type == "STANDARD") {
+            resp += `Note: This is a standard workflow. Workflow-hours will be billed.\n`;
+        }
+        if (isPrivate) {
+            resp += `This workflow is private and can only be accessed by the owner of the authentication credentials. In case you can not access it, you can instruct me to make the workflow public.`;
+        }
+        return resp;
+    });
+    tool("make_workflow_public", "Modify a workflow and make it publicly available to everyone on the Dynatrace Environment", {
+        workflowId: zod_1.z.string().optional()
+    }, async ({ workflowId }) => {
+        const response = await (0, update_workflow_1.updateWorkflow)(dtClient, workflowId, {
+            isPrivate: false,
+        });
+        return `Workflow ${response.id} is now public!\nYou can access the Workflow via the following link: ${dtEnvironment}/ui/apps/dynatrace.automations/workflows/${response?.id}.\nTell the user to inspect the Workflow by visiting the link.\n`;
+    });
+    tool("get_kubernetes_events", "Get all events from a specific Kubernetes cluster", {
+        clusterId: zod_1.z.string().optional()
+    }, async ({ clusterId }) => {
+        const events = await (0, get_events_for_cluster_1.getEventsForCluster)(dtClient, clusterId);
+        return `Events:\n${JSON.stringify(events)}`;
+    });
+    tool("get_ownership", "Get detailed Ownership information for one or multiple entities on Dynatrace", {
+        entityIds: zod_1.z.string().optional().describe("Comma separated list of entityIds"),
+    }, async ({ entityIds }) => {
+        console.error(`Fetching ownership for ${entityIds}`);
+        const ownershipInformation = await (0, get_ownership_information_1.getOwnershipInformation)(dtClient, entityIds);
+        console.error(`Done!`);
+        let resp = 'Ownership information:\n';
+        resp += JSON.stringify(ownershipInformation);
+        return resp;
+    });
+    const transport = new stdio_js_1.StdioServerTransport();
+    console.error("Connecting server to transport...");
+    await server.connect(transport);
+    console.error("Dynatrace MCP Server running on stdio");
+};
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/dynatrace-clients.ts","../src/index.ts","../src/capabilities/create-workflow-for-problem-notification.ts","../src/capabilities/execute-dql.ts","../src/capabilities/get-events-for-cluster.ts","../src/capabilities/get-logs-for-entity.ts","../src/capabilities/get-monitored-entity-details.ts","../src/capabilities/get-ownership-information.ts","../src/capabilities/get-problem-details.ts","../src/capabilities/get-vulnerability-details.ts","../src/capabilities/list-problems.ts","../src/capabilities/list-vulnerabilities.ts","../src/capabilities/send-slack-message.ts","../src/capabilities/update-workflow.ts"],"version":"5.8.2"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dynatrace-oss/dynatrace-mcp-server",
+  "version": "0.1.0",
+  "description": "Model Context Protocol (MCP) server for Dynatrace",
+  "main": "./dist/index.js",
+  "type": "commonjs",
+  "bin": {
+    "mcp-server-dynatrace": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "directories": {
+    "dist": "dist"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "prepare": "npm run build",
+    "watch": "tsc --watch"
+  },
+  "author": "Dynatrace",
+  "license": "MIT",
+  "dependencies": {
+    "@dynatrace-sdk/client-automation": "^5.3.0",
+    "@dynatrace-sdk/client-classic-environment-v2": "^3.6.8",
+    "@dynatrace-sdk/client-platform-management-service": "^1.6.3",
+    "@dynatrace-sdk/client-query": "^1.18.1",
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "dotenv": "^16.4.7",
+    "dt-app": "^0.140.1",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.2"
+  }
+}