@influxdata/influxdb3-mcp-server 1.3.0

package/build/tools/categories/token.tools.js

@@ -0,0 +1,378 @@
+/**
+ * Token Management Tools (Core/Enterprise)
+ */
+import { z } from "zod";
+export function createTokenTools(influxService) {
+    return [
+        {
+            name: "create_admin_token",
+            description: "Create a new InfluxDB named admin token with full administrative permissions (Core/Enterprise only). Named admin tokens can manage databases, users, and resource tokens, but cannot manage other admin tokens.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: 'Optional name for the admin token (e.g., "backup-admin-token"). If not provided, a unique name will be generated.',
+                    },
+                },
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                name: z
+                    .string()
+                    .optional()
+                    .describe("Optional name for the admin token"),
+            }),
+            handler: async (args) => {
+                try {
+                    const tokenService = influxService.getTokenManagementService();
+                    const result = await tokenService.createAdminToken(args.name);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Admin token created successfully:\nToken ID: ${result.id}\nToken: ${result.token}\n\n⚠️ Store this token securely - it won't be shown again!`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "list_admin_tokens",
+            description: "List all admin tokens (operator and named admin tokens) with optional filtering by token name (Core/Enterprise only). Named admin tokens have full administrative access including resource token management.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenName: {
+                        type: "string",
+                        description: "Optional filter to search for tokens with names containing this text (case-insensitive partial match)",
+                    },
+                },
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                tokenName: z
+                    .string()
+                    .optional()
+                    .describe("Optional filter for token name (partial match)"),
+            }),
+            handler: async (args) => {
+                try {
+                    const tokenService = influxService.getTokenManagementService();
+                    const filters = {};
+                    if (args.tokenName) {
+                        filters.tokenName = args.tokenName;
+                    }
+                    const result = await tokenService.listAdminTokens(Object.keys(filters).length > 0 ? filters : undefined);
+                    const resultText = `Admin tokens retrieved successfully:\n${JSON.stringify(result, null, 2)}`;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: resultText,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "list_resource_tokens",
+            description: "List all resource tokens with optional filtering by database name and/or token name, and ordering (Core/Enterprise only).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    databaseName: {
+                        type: "string",
+                        description: "Optional filter to show only tokens that have access to this database (partial match)",
+                    },
+                    tokenName: {
+                        type: "string",
+                        description: "Optional filter to search for tokens with names containing this text (case-insensitive partial match)",
+                    },
+                    orderBy: {
+                        type: "string",
+                        enum: ["created_at", "token_id", "name"],
+                        description: "Optional field to order results by",
+                    },
+                    orderDirection: {
+                        type: "string",
+                        enum: ["ASC", "DESC"],
+                        description: "Optional direction for ordering (ASC or DESC). Defaults to ASC.",
+                        default: "ASC",
+                    },
+                },
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                databaseName: z
+                    .string()
+                    .optional()
+                    .describe("Optional filter for database name (partial match)"),
+                tokenName: z
+                    .string()
+                    .optional()
+                    .describe("Optional filter for token name (partial match)"),
+                orderBy: z
+                    .enum(["created_at", "token_id", "name"])
+                    .optional()
+                    .describe("Field to order results by"),
+                orderDirection: z
+                    .enum(["ASC", "DESC"])
+                    .optional()
+                    .default("ASC")
+                    .describe("Ordering direction"),
+            }),
+            handler: async (args) => {
+                try {
+                    const tokenService = influxService.getTokenManagementService();
+                    const filters = {};
+                    if (args.databaseName) {
+                        filters.databaseName = args.databaseName;
+                    }
+                    if (args.tokenName) {
+                        filters.tokenName = args.tokenName;
+                    }
+                    if (args.orderBy) {
+                        filters.order = {
+                            field: args.orderBy,
+                            direction: args.orderDirection || "ASC",
+                        };
+                    }
+                    const result = await tokenService.listResourceTokens(Object.keys(filters).length > 0 ? filters : undefined);
+                    const resultText = `Resource tokens retrieved successfully:\n${JSON.stringify(result, null, 2)}`;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: resultText,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "regenerate_operator_token",
+            description: "Regenerate the InfluxDB operator token (Core/Enterprise only). Returns the new token value. ⚠️ This action invalidates current operator token and is irreversible. Receive the explicit user confirmation before proceeding.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false,
+            },
+            zodSchema: z.object({}),
+            handler: async () => {
+                try {
+                    const tokenService = influxService.getTokenManagementService();
+                    const result = await tokenService.regenerateOperatorToken();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Operator token regenerated successfully:\nToken ID: ${result.id}\nToken: ${result.token}\n\n⚠️ Store this token securely - it won't be shown again!\n⚠️ The old operator token is now invalid.`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "create_resource_token",
+            description: 'Create a new InfluxDB resource token with specific database permissions (Core/Enterprise only). Example: databases=["mydb", "testdb"], actions=["read", "write"]',
+            inputSchema: {
+                type: "object",
+                properties: {
+                    description: {
+                        type: "string",
+                        description: 'Description/name for the resource token (e.g., "My App Token")',
+                    },
+                    databases: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: 'Array of database names this token can access. Example: ["database1", "database2"]. Use exact database names from your InfluxDB instance.',
+                        minItems: 1,
+                    },
+                    actions: {
+                        type: "array",
+                        items: { type: "string", enum: ["read", "write"] },
+                        description: 'Array of permissions for the databases. Example: ["read"] for read-only, ["read", "write"] for full access, or ["write"] for write-only.',
+                        minItems: 1,
+                    },
+                    expiry_secs: {
+                        type: "number",
+                        description: "Optional expiration time in seconds (e.g., 3600 for 1 hour, 86400 for 1 day, 604800 for 1 week). If not specified, token never expires.",
+                        minimum: 1,
+                    },
+                },
+                required: ["description", "databases", "actions"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                description: z
+                    .string()
+                    .describe('Description/name for the resource token (e.g., "My App Token")'),
+                databases: z
+                    .array(z.string())
+                    .min(1)
+                    .describe('Array of database names this token can access. Example: ["database1", "database2"]'),
+                actions: z
+                    .array(z.enum(["read", "write"]))
+                    .min(1)
+                    .describe('Array of permissions: ["read"], ["write"], or ["read", "write"]'),
+                expiry_secs: z
+                    .number()
+                    .min(1)
+                    .optional()
+                    .describe("Optional expiration time in seconds (e.g., 3600, 86400, 604800)"),
+            }),
+            handler: async (args) => {
+                try {
+                    const tokenService = influxService.getTokenManagementService();
+                    const permissions = [
+                        {
+                            resource_type: "db",
+                            resource_names: args.databases,
+                            actions: args.actions,
+                        },
+                    ];
+                    const expiry_secs = args.expiry_secs;
+                    const result = await tokenService.createResourceToken(args.description, permissions, expiry_secs);
+                    let expiryInfo = "\nExpires: Never";
+                    if (args.expiry_secs) {
+                        const hours = Math.floor(args.expiry_secs / 3600);
+                        const days = Math.floor(hours / 24);
+                        if (days > 0) {
+                            expiryInfo = `\nExpires: In ${days} day${days !== 1 ? "s" : ""} (${args.expiry_secs} seconds)`;
+                        }
+                        else if (hours > 0) {
+                            expiryInfo = `\nExpires: In ${hours} hour${hours !== 1 ? "s" : ""} (${args.expiry_secs} seconds)`;
+                        }
+                        else {
+                            expiryInfo = `\nExpires: In ${args.expiry_secs} seconds`;
+                        }
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Resource token created successfully:\nToken ID: ${result.id}\nToken: ${result.token}\nDatabases: ${args.databases.join(", ")}\nActions: ${args.actions.join(", ")}${expiryInfo}\n\n⚠️ Store this token securely - it won't be shown again!`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+        {
+            name: "delete_token",
+            description: "Delete an InfluxDB token by name (Core/Enterprise only).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token_name: {
+                        type: "string",
+                        description: "Name of the token to delete (required)",
+                    },
+                },
+                required: ["token_name"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                token_name: z.string().describe("Name of the token to delete"),
+            }),
+            handler: async (args) => {
+                try {
+                    const tokenService = influxService.getTokenManagementService();
+                    const result = await tokenService.deleteToken(args.token_name);
+                    if (result) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Token '${args.token_name}' deleted successfully.`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Failed to delete token '${args.token_name}'.`,
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+    ];
+}

package/build/tools/categories/write.tools.js

@@ -0,0 +1,104 @@
+/**
+ * Data Writing Tools
+ */
+import { z } from "zod";
+export function createWriteTools(influxService) {
+    return [
+        {
+            name: "write_line_protocol",
+            description: `Write data to InfluxDB using line protocol format (all versions). Supports single records or batches.
+
+Line Protocol Syntax:
+measurement,tag1=value1,tag2=value2 field1=value1,field2=value2 timestamp
+
+Components:
+- measurement: table/measurement name (required)
+- tags: indexed metadata (optional) - comma-separated key=value pairs
+- fields: actual data (required) - space-separated from tags, comma-separated key=value pairs  
+- timestamp: optional timestamp (precision must be specified in tool parameters)
+
+Field Value Types:
+- Strings: "quoted string"
+- Floats: 123.45
+- Integers: 123i (note the 'i' suffix)
+- Booleans: t or f
+
+Examples:
+Single record: temperature,location=office,building=main value=23.5,humidity=45i 1640995200
+Batch (separate with newlines):
+temperature,location=office value=23.5 1640995200
+humidity,location=office value=45i 1640995201
+
+Important: Always specify correct precision parameter to match your timestamp format. Use any precision if writing data with no timestamp. Escaping required for special characters in tags/fields.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    database: {
+                        type: "string",
+                        description: "Name of the database/bucket to write to",
+                    },
+                    data: {
+                        type: "string",
+                        description: "Line protocol formatted data. For multiple records, separate each line with \\n",
+                    },
+                    precision: {
+                        type: "string",
+                        enum: ["nanosecond", "microsecond", "millisecond", "second"],
+                        description: "Precision of timestamps",
+                    },
+                    acceptPartial: {
+                        type: "boolean",
+                        description: "Accept partial writes",
+                        default: true,
+                    },
+                    noSync: {
+                        type: "boolean",
+                        description: "Acknowledge without waiting for WAL persistence",
+                        default: false,
+                    },
+                },
+                required: ["database", "data", "precision"],
+                additionalProperties: false,
+            },
+            zodSchema: z.object({
+                database: z
+                    .string()
+                    .describe("Name of the database/bucket to write to"),
+                data: z.string().describe("Line protocol formatted data"),
+                precision: z
+                    .enum(["nanosecond", "microsecond", "millisecond", "second"])
+                    .describe("Precision of timestamps"),
+                acceptPartial: z.boolean().optional().default(true),
+                noSync: z.boolean().optional().default(false),
+            }),
+            handler: async (args) => {
+                try {
+                    await influxService.write.writeLineProtocol(args.data, args.database, {
+                        precision: args.precision,
+                        acceptPartial: args.acceptPartial,
+                        noSync: args.noSync,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Data written successfully to database/bucket '${args.database}'`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            },
+        },
+    ];
+}

package/build/tools/index.js

@@ -0,0 +1,27 @@
+/**
+ * MCP Tools Definitions
+ *
+ * Defines all the tools available through the MCP server
+ */
+import { createHelpTools } from "./categories/help.tools.js";
+import { createWriteTools } from "./categories/write.tools.js";
+import { createDatabaseTools } from "./categories/database.tools.js";
+import { createQueryTools } from "./categories/query.tools.js";
+import { createTokenTools } from "./categories/token.tools.js";
+import { createCloudTokenTools } from "./categories/cloud-token.tools.js";
+import { createHealthTools } from "./categories/health.tools.js";
+/**
+ * Creates all MCP tools by aggregating them from organized categories
+ */
+export function createTools(influxService) {
+    return [
+        ...createHelpTools(influxService),
+        ...createWriteTools(influxService),
+        ...createDatabaseTools(influxService),
+        ...createQueryTools(influxService),
+        ...createTokenTools(influxService),
+        ...createCloudTokenTools(influxService),
+        // ...createSchemaTools(influxService),
+        ...createHealthTools(influxService),
+    ];
+}

package/env.example

@@ -0,0 +1,17 @@
+# InfluxDB MCP Server Configuration - Core/Enterprise
+# Copy this file to .env and update with your InfluxDB details
+# For Cloud Dedicated setup, see env.cloud-dedicated.example
+# For Cloud Serverless setup, see env.cloud-serverless.example
+
+# InfluxDB Instance Configuration
+# For local InfluxDB (Docker with port mapping): http://localhost:8181/
+# For remote InfluxDB: http://your-influx-host:port/
+INFLUX_DB_INSTANCE_URL=http://localhost:8181/
+
+# Your InfluxDB operator/admin/resource token
+INFLUX_DB_TOKEN=your_influxdb_token_here
+
+# InfluxDB Product Type: core, enterprise, cloud-dedicated, or cloud-serverless
+# For cloud-dedicated, see env.cloud-dedicated.example
+# For cloud-serverless, see env.cloud-serverless.example
+INFLUX_DB_PRODUCT_TYPE=core

package/example-cloud-dedicated.mcp.json

@@ -0,0 +1,15 @@
+{
+  "mcpServers": {
+    "influxdb": {
+      "command": "npx",
+      "args": ["-y", "@influx/influx-mcp-server@latest"],
+      "env": {
+        "INFLUX_DB_PRODUCT_TYPE": "cloud-dedicated",
+        "INFLUX_DB_CLUSTER_ID": "your_cluster_id_here",
+        "INFLUX_DB_ACCOUNT_ID": "your_account_id_here",
+        "INFLUX_DB_TOKEN": "your_database_token_here",
+        "INFLUX_DB_MANAGEMENT_TOKEN": "your_management_token_here"
+      }
+    }
+  }
+}

package/example-cloud-serverless.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "influxdb": {
+      "command": "node",
+      "args": ["/path/to/influx-mcp-standalone/build/index.js"],
+      "env": {
+        "INFLUX_DB_PRODUCT_TYPE": "cloud-serverless",
+        "INFLUX_DB_INSTANCE_URL": "https://your-region.aws.cloud2.influxdata.com",
+        "INFLUX_DB_TOKEN": "your_database_token_here"
+      }
+    }
+  }
+}

package/example-clustered.mcp.json

@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "influxdb": {
+      "command": "node",
+      "args": ["/path/to/influx-mcp-standalone/build/index.js"],
+      "env": {
+        "INFLUX_DB_PRODUCT_TYPE": "clustered",
+        "INFLUX_DB_INSTANCE_URL": "https://your-cluster.example.com",
+        "INFLUX_DB_TOKEN": "your_database_token_here",
+        "INFLUX_DB_MANAGEMENT_TOKEN": "your_management_token_here"
+      }
+    }
+  }
+}

package/example-docker.mcp.json

@@ -0,0 +1,25 @@
+{
+  "mcpServers": {
+    "influxdb": {
+      "command": "docker",
+      "args": [
+        "run",
+        "--rm",
+        "-i",
+        "--add-host=host.docker.internal:host-gateway",
+        "-e",
+        "INFLUX_DB_INSTANCE_URL",
+        "-e",
+        "INFLUX_DB_TOKEN",
+        "-e",
+        "INFLUX_DB_PRODUCT_TYPE",
+        "influxdb-mcp-server"
+      ],
+      "env": {
+        "INFLUX_DB_INSTANCE_URL": "http://host.docker.internal:8086/",
+        "INFLUX_DB_TOKEN": "<YOUR_INFLUXDB_OPERATOR_TOKEN>",
+        "INFLUX_DB_PRODUCT_TYPE": "core"
+      }
+    }
+  }
+}

package/example-local.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "influxdb": {
+      "command": "node",
+      "args": ["/path/to/influx-mcp-standalone/build/index.js"],
+      "env": {
+        "INFLUX_DB_INSTANCE_URL": "http://localhost:8086/",
+        "INFLUX_DB_TOKEN": "<YOUR_INFLUXDB_OPERATOR_TOKEN>",
+        "INFLUX_DB_PRODUCT_TYPE": "core"
+      }
+    }
+  }
+}

package/example-npx.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "influxdb": {
+      "command": "npx",
+      "args": ["-y", "@influxdata/influxdb3-mcp-server"],
+      "env": {
+        "INFLUX_DB_INSTANCE_URL": "http://localhost:8086/",
+        "INFLUX_DB_TOKEN": "<YOUR_INFLUXDB_OPERATOR_TOKEN>",
+        "INFLUX_DB_PRODUCT_TYPE": "core"
+      }
+    }
+  }
+}