@influxdata/influxdb3-mcp-server 1.3.0

package/build/resources/index.js

@@ -0,0 +1,223 @@
+/**
+ * MCP Resources Definitions
+ *
+ * Defines resources that provide read-only data access
+ */
+/**
+ * Create all MCP resources for InfluxDB data access
+ */
+export function createResources(influxService) {
+    return [
+        {
+            name: "influx-config",
+            uri: "influx://config",
+            description: "InfluxDB configuration and connection status",
+            handler: async () => {
+                const connectionInfo = influxService.getConnectionInfo();
+                const pingResult = await influxService.ping();
+                const isConnected = pingResult.ok;
+                const config = {
+                    connection: {
+                        url: connectionInfo.url,
+                        hasToken: connectionInfo.hasToken,
+                        database: connectionInfo.database,
+                        isConnected,
+                    },
+                };
+                return {
+                    contents: [
+                        {
+                            uri: "influx://config",
+                            text: JSON.stringify(config, null, 2),
+                            mimeType: "application/json",
+                        },
+                    ],
+                };
+            },
+        },
+        {
+            name: "influx-status",
+            uri: "influx://status",
+            description: "Comprehensive status of the InfluxDB connection including ping and health check results",
+            handler: async () => {
+                try {
+                    const pingResult = await influxService.ping();
+                    let healthStatus;
+                    try {
+                        healthStatus = await influxService.getHealthStatus();
+                    }
+                    catch (healthError) {
+                        healthStatus = {
+                            status: "unavailable",
+                            error: healthError.message,
+                        };
+                    }
+                    const status = {
+                        timestamp: new Date().toISOString(),
+                        ping: {
+                            ok: pingResult.ok,
+                            version: pingResult.version || null,
+                            build: pingResult.build || null,
+                            message: pingResult.message || null,
+                        },
+                        health: healthStatus,
+                        overall: {
+                            status: pingResult.ok && healthStatus.status !== "fail"
+                                ? "healthy"
+                                : "unhealthy",
+                            connection: pingResult.ok ? "connected" : "disconnected",
+                        },
+                    };
+                    return {
+                        contents: [
+                            {
+                                uri: "influx://status",
+                                text: JSON.stringify(status, null, 2),
+                                mimeType: "application/json",
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    const errorStatus = {
+                        timestamp: new Date().toISOString(),
+                        ping: {
+                            ok: false,
+                            error: error.message,
+                        },
+                        health: {
+                            status: "unavailable",
+                            error: "Could not perform health check",
+                        },
+                        overall: {
+                            status: "error",
+                            connection: "failed",
+                        },
+                        error: error.message,
+                    };
+                    return {
+                        contents: [
+                            {
+                                uri: "influx://status",
+                                text: JSON.stringify(errorStatus, null, 2),
+                                mimeType: "application/json",
+                            },
+                        ],
+                    };
+                }
+            },
+        },
+        {
+            name: "influx-databases",
+            uri: "influx://databases",
+            description: "List of all databases in the InfluxDB instance",
+            handler: async () => {
+                try {
+                    const databases = await influxService.database.listDatabases();
+                    const databaseList = {
+                        timestamp: new Date().toISOString(),
+                        databases: databases,
+                        count: databases.length,
+                        status: "success",
+                    };
+                    return {
+                        contents: [
+                            {
+                                uri: "influx://databases",
+                                text: JSON.stringify(databaseList, null, 2),
+                                mimeType: "application/json",
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    const errorInfo = {
+                        timestamp: new Date().toISOString(),
+                        databases: [],
+                        count: 0,
+                        status: "error",
+                        error: error.message,
+                        connectionInfo: influxService.getConnectionInfo(),
+                    };
+                    return {
+                        contents: [
+                            {
+                                uri: "influx://databases",
+                                text: JSON.stringify(errorInfo, null, 2),
+                                mimeType: "application/json",
+                            },
+                        ],
+                    };
+                }
+            },
+        },
+        {
+            name: "context-file",
+            uri: "influx://context",
+            description: "Custom context file with user-defined database descriptions or documentation",
+            handler: async () => {
+                try {
+                    const contextFile = await influxService.contextFile.loadContextFile();
+                    if (!contextFile) {
+                        return {
+                            contents: [
+                                {
+                                    uri: "influx://context",
+                                    text: JSON.stringify({
+                                        timestamp: new Date().toISOString(),
+                                        status: "not_found",
+                                        message: "No context file found. Create a file in /context/ folder or name a file with 'context' in the name (.json, .txt, .md)",
+                                        searchPaths: [
+                                            "./context/ (any .json, .txt, .md file)",
+                                            "./ (files with 'context' in name)",
+                                        ],
+                                    }, null, 2),
+                                    mimeType: "application/json",
+                                },
+                            ],
+                        };
+                    }
+                    let mimeType = "text/plain";
+                    switch (contextFile.extension) {
+                        case "json":
+                            mimeType = "application/json";
+                            break;
+                        case "md":
+                            mimeType = "text/markdown";
+                            break;
+                        case "txt":
+                        default:
+                            mimeType = "text/plain";
+                            break;
+                    }
+                    return {
+                        contents: [
+                            {
+                                uri: "influx://context",
+                                text: contextFile.content,
+                                mimeType: mimeType,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    const errorInfo = {
+                        timestamp: new Date().toISOString(),
+                        status: "error",
+                        error: error.message,
+                        message: "Failed to load context file",
+                    };
+                    return {
+                        contents: [
+                            {
+                                uri: "influx://context",
+                                text: JSON.stringify(errorInfo, null, 2),
+                                mimeType: "application/json",
+                            },
+                        ],
+                    };
+                }
+            },
+        },
+    ];
+}

package/build/server/index.js

@@ -0,0 +1,104 @@
+/**
+ * MCP Server Factory
+ *
+ * Creates and configures the MCP server with all capabilities
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, PingRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { loadConfig, validateConfig } from "../config.js";
+import { InfluxDBMasterService } from "../services/influxdb-master.service.js";
+import { createTools } from "../tools/index.js";
+import { createResources } from "../resources/index.js";
+import { createPrompts } from "../prompts/index.js";
+/**
+ * Create and configure the MCP server
+ */
+export function createServer() {
+    const config = loadConfig();
+    validateConfig(config);
+    const influxService = new InfluxDBMasterService(config);
+    const tools = createTools(influxService);
+    const resources = createResources(influxService);
+    const prompts = createPrompts(influxService);
+    const server = new Server({
+        name: config.server.name,
+        version: config.server.version,
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            })),
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const tool = tools.find((t) => t.name === name);
+        if (!tool) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        const validatedArgs = tool.zodSchema.parse(args || {});
+        try {
+            return await tool.handler(validatedArgs);
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        return {
+            resources: resources.map((resource) => ({
+                name: resource.name,
+                uri: resource.uri,
+                description: resource.description,
+                mimeType: "application/json",
+            })),
+        };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const { uri } = request.params;
+        const resource = resources.find((r) => r.uri === uri);
+        if (!resource) {
+            throw new Error(`Unknown resource: ${uri}`);
+        }
+        return await resource.handler();
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: prompts.map((prompt) => ({
+                name: prompt.name,
+                description: prompt.description,
+                arguments: prompt.arguments || [],
+            })),
+        };
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const prompt = prompts.find((p) => p.name === name);
+        if (!prompt) {
+            throw new Error(`Unknown prompt: ${name}`);
+        }
+        return await prompt.handler(args);
+    });
+    server.setRequestHandler(PingRequestSchema, async () => {
+        return {};
+    });
+    console.warn(`[MCP] Server initialized with ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`);
+    return server;
+}

package/build/services/base-connection.service.js

@@ -0,0 +1,318 @@
+/**
+ * Base InfluxDB Connection Service
+ *
+ * Handles connection management, health checks, and provides base client access
+ * for other specialized services
+ */
+import { InfluxDBClient } from "@influxdata/influxdb3-client";
+import { HttpClientService } from "./http-client.service.js";
+import { InfluxProductType } from "../helpers/enums/influx-product-types.enum.js";
+export class BaseConnectionService {
+    client = null;
+    config;
+    httpClient;
+    constructor(config) {
+        this.config = config;
+        this.httpClient = new HttpClientService();
+        this.initializeClient();
+    }
+    /**
+     * Get the correct host for query/write operations (data plane)
+     */
+    getDataHost() {
+        const influx = this.config.influx;
+        if (influx.type === InfluxProductType.CloudDedicated && influx.cluster_id) {
+            return `https://${influx.cluster_id}.a.influxdb.io`;
+        }
+        if (influx.type === InfluxProductType.CloudServerless) {
+            return influx.url;
+        }
+        return influx.url;
+    }
+    /**
+     * Get the correct host for management operations (control plane)
+     */
+    getManagementHost() {
+        const influx = this.config.influx;
+        if (influx.type === InfluxProductType.CloudDedicated) {
+            return "https://console.influxdata.com";
+        }
+        if (influx.type === InfluxProductType.CloudServerless) {
+            return influx.url;
+        }
+        return influx.url;
+    }
+    /**
+     * Initialize InfluxDB client
+     */
+    initializeClient() {
+        try {
+            const influxConfig = this.config.influx;
+            if (this.isValidConfig(influxConfig)) {
+                const clientConfig = {
+                    host: this.getDataHost(),
+                    token: influxConfig.token,
+                };
+                this.client = new InfluxDBClient(clientConfig);
+            }
+        }
+        catch (error) {
+            console.error("Failed to initialize InfluxDB client:", error);
+            this.client = null;
+        }
+    }
+    /**
+     * Check if configuration is valid for data operations (requires data client)
+     */
+    isValidConfig(config) {
+        if (config.type === InfluxProductType.CloudDedicated) {
+            return !!(config.cluster_id && config.token);
+        }
+        if (config.type === InfluxProductType.CloudServerless) {
+            return !!(config.url && config.token);
+        }
+        return !!(config.url && config.token);
+    }
+    /**
+     * Check if we have data capabilities (query/write operations)
+     */
+    hasDataCapabilities() {
+        return this.isValidConfig(this.config.influx);
+    }
+    /**
+     * Check if we have management capabilities
+     */
+    hasManagementCapabilities() {
+        const config = this.config.influx;
+        if (config.type === InfluxProductType.CloudDedicated) {
+            return !!(config.cluster_id &&
+                config.account_id &&
+                config.management_token);
+        }
+        if (config.type === InfluxProductType.Clustered) {
+            return !!config.management_token;
+        }
+        if (config.type === InfluxProductType.CloudServerless) {
+            return !!(config.url && config.token);
+        }
+        return !!(config.url && config.token);
+    }
+    /**
+     * Validate that we can perform data operations (query/write)
+     * Throws an error if we don't have the necessary configuration
+     */
+    validateDataCapabilities() {
+        if (!this.hasDataCapabilities()) {
+            const config = this.config.influx;
+            if (config.type === InfluxProductType.CloudDedicated) {
+                if (!config.cluster_id) {
+                    throw new Error("Cloud Dedicated data operations require cluster_id in configuration");
+                }
+                if (!config.token) {
+                    throw new Error("Cloud Dedicated data operations require database token in configuration");
+                }
+            }
+            else if (config.type === InfluxProductType.CloudServerless) {
+                if (!config.url) {
+                    throw new Error("Cloud Serverless data operations require url (region-specific endpoint) in configuration");
+                }
+                if (!config.token) {
+                    throw new Error("Cloud Serverless data operations require database token in configuration");
+                }
+            }
+            else {
+                if (!config.url) {
+                    throw new Error("Core/Enterprise data operations require url in configuration");
+                }
+                if (!config.token) {
+                    throw new Error("Core/Enterprise data operations require token in configuration");
+                }
+            }
+        }
+    }
+    /**
+     * Validate that we can perform management operations
+     * Throws an error if we don't have the necessary configuration
+     */
+    validateManagementCapabilities() {
+        if (!this.hasManagementCapabilities()) {
+            const config = this.config.influx;
+            if (config.type === InfluxProductType.CloudDedicated ||
+                config.type === InfluxProductType.Clustered) {
+                const missing = [];
+                if (!config.cluster_id)
+                    missing.push("cluster_id");
+                if (!config.account_id)
+                    missing.push("account_id");
+                if (!config.management_token)
+                    missing.push("management_token");
+                throw new Error(`Cloud Dedicated/Clustered management operations require: ${missing.join(", ")}`);
+            }
+            else if (config.type === InfluxProductType.CloudServerless) {
+                if (!config.url) {
+                    throw new Error("Cloud Serverless management operations require url (region-specific endpoint) in configuration");
+                }
+                if (!config.token) {
+                    throw new Error("Cloud Serverless management operations require database token in configuration");
+                }
+            }
+            else {
+                if (!config.url) {
+                    throw new Error("Core/Enterprise management operations require url in configuration");
+                }
+                if (!config.token) {
+                    throw new Error("Core/Enterprise management operations require token with management permissions");
+                }
+            }
+        }
+    }
+    /**
+     * Validate operation is supported for current product type
+     */
+    validateOperationSupport(operation, supportedTypes) {
+        const currentType = this.config.influx.type;
+        if (!supportedTypes.includes(currentType)) {
+            const supportedNames = supportedTypes
+                .map((type) => {
+                switch (type) {
+                    case InfluxProductType.Core:
+                        return "Core";
+                    case InfluxProductType.Enterprise:
+                        return "Enterprise";
+                    case InfluxProductType.CloudDedicated:
+                        return "Cloud Dedicated";
+                    case InfluxProductType.CloudServerless:
+                        return "Cloud Serverless";
+                    case InfluxProductType.Clustered:
+                        return "Clustered";
+                    default:
+                        return type;
+                }
+            })
+                .join(", ");
+            const currentName = currentType === InfluxProductType.Core
+                ? "Core"
+                : currentType === InfluxProductType.Enterprise
+                    ? "Enterprise"
+                    : currentType === InfluxProductType.CloudDedicated
+                        ? "Cloud Dedicated"
+                        : currentType === InfluxProductType.CloudServerless
+                            ? "Cloud Serverless"
+                            : currentType === InfluxProductType.Clustered
+                                ? "Clustered"
+                                : currentType;
+            throw new Error(`Operation '${operation}' is not supported for ${currentName}. Supported types: ${supportedNames}`);
+        }
+    }
+    /**
+     * Get the main client instance
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Get connection information
+     */
+    getConnectionInfo() {
+        const influxConfig = this.config.influx;
+        return {
+            isDataClientInitialized: !!this.client,
+            url: this.getDataHost() || "",
+            hasToken: !!influxConfig.token,
+            type: influxConfig.type,
+        };
+    }
+    /**
+     * Ping InfluxDB instance (returns version and build info if available)
+     */
+    async ping() {
+        const url = this.getDataHost();
+        if (!url) {
+            return { ok: false, message: "No data host configured" };
+        }
+        try {
+            const response = await fetch(`${url.replace(/\/$/, "")}/ping`, {
+                headers: {
+                    Authorization: `Token ${this.config.influx.token}`,
+                },
+            });
+            if (response.ok) {
+                const version = response.headers.get("x-influxdb-version") || undefined;
+                let build = response.headers.get("x-influxdb-build") || undefined;
+                if (!build) {
+                    if (version) {
+                        build = "Other";
+                    }
+                }
+                return { ok: true, version, build };
+            }
+            else {
+                return {
+                    ok: false,
+                    message: `Ping failed with status ${response.status}`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Get health status
+     */
+    async getHealthStatus() {
+        const url = this.getDataHost();
+        if (!url || !this.client) {
+            return { status: "fail" };
+        }
+        try {
+            const response = await fetch(`${url.replace(/\/$/, "")}/health`, {
+                headers: {
+                    Authorization: `Token ${this.config.influx.token}`,
+                },
+            });
+            if (response.ok) {
+                try {
+                    const healthData = await response.json();
+                    return healthData;
+                }
+                catch {
+                    return { status: "pass" };
+                }
+            }
+            else {
+                return { status: "fail" };
+            }
+        }
+        catch (_error) {
+            return { status: "fail" };
+        }
+    }
+    /**
+     * Get pre-configured HTTP client for InfluxDB API calls
+     * For cloud-dedicated, use data host for query/write, management host for admin
+     */
+    getInfluxHttpClient(forManagement = false) {
+        const influxConfig = this.config.influx;
+        const host = (forManagement ? this.getManagementHost() : this.getDataHost()) || "";
+        let token = "";
+        if (forManagement &&
+            (influxConfig.type === InfluxProductType.CloudDedicated ||
+                influxConfig.type === InfluxProductType.Clustered)) {
+            token = influxConfig.management_token || "";
+        }
+        else {
+            token = influxConfig.token || "";
+        }
+        return HttpClientService.createInfluxClient(host, token, influxConfig.type);
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+}