@kontent-ai/mcp-server 0.16.0 → 0.18.0

package/README.md

@@ -48,10 +48,10 @@ You can run the Kontent.ai MCP Server with npx:
 npx @kontent-ai/mcp-server@latest stdio
 ```
 
-#### SSE Transport
+#### Streamable HTTP Transport
 
 ```bash
-npx @kontent-ai/mcp-server@latest sse
+npx @kontent-ai/mcp-server@latest shttp
 ```
 
 ## 🛠️ Available Tools
@@ -111,13 +111,25 @@ npx @kontent-ai/mcp-server@latest sse
 
 ## ⚙️ Configuration
 
-The server requires the following environment variables:
+The server supports two configuration modes:
+
+### Single-Tenant Mode (Default)
+
+For single-tenant mode, configure environment variables:
 
 | Variable | Description | Required |
 |----------|-------------|----------|
 | KONTENT_API_KEY | Your Kontent.ai Management API key | ✅ |
 | KONTENT_ENVIRONMENT_ID | Your environment ID | ✅ |
-| PORT | Port for SSE transport (defaults to 3001) | ❌ |
+| PORT | Port for HTTP transport (defaults to 3001) | ❌ |
+
+### Multi-Tenant Mode
+
+For multi-tenant mode (Streamable HTTP only), the server accepts:
+- **Environment ID** as a URL path parameter: `/{environmentId}/mcp`
+- **API Key** via Bearer token in the Authorization header: `Authorization: Bearer <api-key>`
+
+This mode allows a single server instance to handle requests for multiple Kontent.ai environments securely without requiring environment variables.
 
 ## 🚀 Transport Options
 
@@ -138,14 +150,16 @@ To run the server with STDIO transport, configure your MCP client with:
 }
 ```
 
-### 🌐 SSE Transport
+### 🌊 Streamable HTTP Transport
 
-For SSE transport, first start the server:
+For Streamable HTTP transport, first start the server:
 
 ```bash
-npx @kontent-ai/mcp-server@latest sse
+npx @kontent-ai/mcp-server@latest shttp
 ```
 
+#### Single-Tenant Mode
+
 With environment variables in a `.env` file, or otherwise accessible to the process:
 ```env
 KONTENT_API_KEY=<management-api-key>
@@ -156,36 +170,112 @@ PORT=3001  # optional, defaults to 3001
 Then configure your MCP client:
 ```json
 {
-  "kontent-ai-sse": {
-    "url": "http://localhost:3001/sse"
+  "kontent-ai-http": {
+    "url": "http://localhost:3001/mcp"
   }
 }
 ```
 
-### 🌊 Streamable HTTP Transport
+#### Multi-Tenant Mode
 
-For Streamable HTTP transport, first start the server:
+No environment variables required. The server accepts requests for multiple environments using URL path parameters and Bearer authentication.
 
-```bash
-npx @kontent-ai/mcp-server@latest shttp
+##### VS Code Configuration
+
+Create a `.vscode/mcp.json` file in your workspace:
+
+```json
+{
+  "servers": {
+    "kontent-ai-multi": {
+      "uri": "http://localhost:3001/<environment-id>/mcp",
+      "headers": {
+        "Authorization": "Bearer <management-api-key>"
+      }
+    }
+  }
+}
 ```
 
-With environment variables in a `.env` file, or otherwise accessible to the process:
-```env
-KONTENT_API_KEY=<management-api-key>
-KONTENT_ENVIRONMENT_ID=<environment-id>
-PORT=3001  # optional, defaults to 3001
+For secure configuration with input prompts:
+
+```json
+{
+  "inputs": [
+    {
+      "id": "apiKey",
+      "type": "password",
+      "description": "Kontent.ai API Key"
+    },
+    {
+      "id": "environmentId",
+      "type": "text",
+      "description": "Environment ID"
+    }
+  ],
+  "servers": {
+    "kontent-ai-multi": {
+      "uri": "http://localhost:3001/${inputs.environmentId}/mcp",
+      "headers": {
+        "Authorization": "Bearer ${inputs.apiKey}"
+      }
+    }
+  }
+}
 ```
 
-Then configure your MCP client:
+##### Claude Desktop Configuration
+
+Update your Claude Desktop configuration file:
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+Use `mcp-remote` as a proxy to add authentication headers:
+
 ```json
 {
-  "kontent-ai-http": {
-    "url": "http://localhost:3001/mcp"
+  "mcpServers": {
+    "kontent-ai-multi": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "http://localhost:3001/<environment-id>/mcp",
+        "--header",
+        "Authorization: Bearer <management-api-key>"
+      ]
+    }
   }
 }
 ```
 
+##### Claude Code Configuration
+
+For Claude Code (claude.ai/code), add the server configuration:
+
+```bash
+# Add the multi-tenant server
+claude mcp add \
+  --url "http://localhost:3001/<environment-id>/mcp" \
+  --header "Authorization: Bearer <management-api-key>" \
+  kontent-ai-multi
+```
+
+Or configure directly in the settings:
+
+```json
+{
+  "kontent-ai-multi": {
+    "url": "http://localhost:3001/<environment-id>/mcp",
+    "headers": {
+      "Authorization": "Bearer <management-api-key>"
+    }
+  }
+}
+```
+
+**Important**: Replace `<environment-id>` with your actual Kontent.ai environment ID (GUID format) and `<management-api-key>` with your Management API key.
+
 ## 💻 Development
 
 ### 🛠 Local Installation
@@ -202,12 +292,10 @@ npm ci
 npm run build
 
 # Start the server
-npm run start:sse  # For SSE transport
 npm run start:stdio  # For STDIO transport
 npm run start:shttp  # For Streamable HTTP transport
 
 # Start the server with automatic reloading (no need to build first)
-npm run dev:sse  # For SSE transport
 npm run dev:stdio  # For STDIO transport
 npm run dev:shttp  # For Streamable HTTP transport
 ```
@@ -232,7 +320,7 @@ For debugging, you can use the MCP inspector:
 npx @modelcontextprotocol/inspector -e KONTENT_API_KEY=<key> -e KONTENT_ENVIRONMENT_ID=<env-id> node path/to/build/bin.js
 ```
 
-Or use the MCP inspector on a running sse server:
+Or use the MCP inspector on a running streamable HTTP server:
 
 ```bash
 npx @modelcontextprotocol/inspector

package/build/bin.js

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import "dotenv/config";
 import express from "express";
 import packageJson from "../package.json" with { type: "json" };
+import { loadAppConfiguration, } from "./config/appConfiguration.js";
 import { createServer } from "./server.js";
+import { extractBearerToken } from "./utils/extractBearerToken.js";
+import { isValidGuid } from "./utils/isValidGuid.js";
 const version = packageJson.version;
-async function startStreamableHTTP() {
+async function startStreamableHTTP(config) {
     const app = express();
     app.use(express.json());
     app.post("/mcp", async (req, res) => {
         try {
-            const { server } = createServer();
+            const { server } = createServer(config);
             const transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: undefined,
             });
@@ -39,7 +41,6 @@ async function startStreamableHTTP() {
         }
     });
     app.get("/mcp", async (_, res) => {
-        console.log("Received GET MCP request");
         res.writeHead(405).end(JSON.stringify({
             jsonrpc: "2.0",
             error: {
@@ -50,7 +51,6 @@ async function startStreamableHTTP() {
         }));
     });
     app.delete("/mcp", async (_, res) => {
-        console.log("Received DELETE MCP request");
         res.writeHead(405).end(JSON.stringify({
             jsonrpc: "2.0",
             error: {
@@ -60,51 +60,102 @@ async function startStreamableHTTP() {
             id: null,
         }));
     });
-    const PORT = process.env.PORT || 3001;
-    app.listen(PORT, () => {
-        console.log(`Kontent.ai MCP Server v${version} (Streamable HTTP) running on port ${PORT}`);
+    app.post("/:environmentId/mcp", async (req, res) => {
+        try {
+            const { environmentId } = req.params;
+            if (!isValidGuid(environmentId)) {
+                res.status(400).json({
+                    error: "Invalid environment ID format. Must be a valid GUID.",
+                });
+                return;
+            }
+            const { server } = createServer(config);
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            res.on("close", () => {
+                console.log("Request closed");
+                transport.close();
+                server.close();
+            });
+            const authToken = extractBearerToken(req);
+            if (!authToken) {
+                res.status(401).json({
+                    error: "Authorization header with Bearer token is required.",
+                });
+                return;
+            }
+            await server.connect(transport);
+            await transport.handleRequest(Object.assign(req, {
+                auth: {
+                    clientId: environmentId,
+                    token: authToken,
+                    scopes: [],
+                },
+            }), res, req.body);
+        }
+        catch (error) {
+            console.error("Error handling MCP request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
     });
-}
-async function startSSE() {
-    const app = express();
-    const { server } = createServer();
-    let transport;
-    app.get("/sse", async (_req, res) => {
-        transport = new SSEServerTransport("/message", res);
-        await server.connect(transport);
+    app.get("/:environmentId/mcp", async (_, res) => {
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
     });
-    app.post("/message", async (req, res) => {
-        await transport.handlePostMessage(req, res);
+    app.delete("/:environmentId/mcp", async (_, res) => {
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
     });
     const PORT = process.env.PORT || 3001;
     app.listen(PORT, () => {
-        console.log(`Kontent.ai MCP Server v${version} (SSE) running on port ${PORT}`);
+        console.log(`Kontent.ai MCP Server v${version} (Streamable HTTP) running on port ${PORT}.
+Available endpoints:
+/mcp
+/{environmentId}/mcp (requires Bearer authentication)`);
     });
 }
-async function startStdio() {
-    const { server } = createServer();
+async function startStdio(config) {
+    const { server } = createServer(config);
     const transport = new StdioServerTransport();
     console.log(`Kontent.ai MCP Server v${version} (stdio) starting`);
     await server.connect(transport);
 }
 async function main() {
+    const config = await loadAppConfiguration();
     const args = process.argv.slice(2);
     const transportType = args[0]?.toLowerCase();
     if (!transportType ||
-        (transportType !== "stdio" &&
-            transportType !== "sse" &&
-            transportType !== "shttp")) {
-        console.error("Please specify a valid transport type: stdio, sse, or shttp");
+        (transportType !== "stdio" && transportType !== "shttp")) {
+        console.error("Please specify a valid transport type: stdio or shttp");
         process.exit(1);
     }
     if (transportType === "stdio") {
-        await startStdio();
-    }
-    else if (transportType === "sse") {
-        await startSSE();
+        await startStdio(config);
     }
     else if (transportType === "shttp") {
-        await startStreamableHTTP();
+        await startStreamableHTTP(config);
     }
 }
 main().catch((error) => {

package/build/clients/kontentClients.js

@@ -6,9 +6,10 @@ const sourceTrackingHeaderName = "X-KC-SOURCE";
  * Creates a Kontent.ai Management API client
  * @param environmentId Optional environment ID (defaults to process.env.KONTENT_ENVIRONMENT_ID)
  * @param apiKey Optional API key (defaults to process.env.KONTENT_API_KEY)
+ * @param config Optional configuration object
  * @returns Management API client instance
  */
-export const createMapiClient = (environmentId, apiKey) => {
+export const createMapiClient = (environmentId, apiKey, config) => {
     return createManagementClient({
         apiKey: apiKey ??
             process.env.KONTENT_API_KEY ??
@@ -22,5 +23,6 @@ export const createMapiClient = (environmentId, apiKey) => {
                 value: `${packageJson.name};${packageJson.version}`,
             },
         ],
+        baseUrl: config ? `${config.manageApiUrl}v2` : undefined,
     });
 };

package/build/config/appConfiguration.js

@@ -0,0 +1,51 @@
+import { load } from "@azure/app-configuration-provider";
+import { DefaultAzureCredential } from "@azure/identity";
+function loadIndexedEnvVars(prefix) {
+    const values = [];
+    let index = 0;
+    while (true) {
+        const envVar = process.env[`${prefix}__${index}`];
+        if (!envVar)
+            break;
+        const trimmed = envVar.trim();
+        if (trimmed) {
+            values.push(trimmed);
+        }
+        index++;
+    }
+    return values;
+}
+function getConfigValue(configMap, key) {
+    const value = configMap.get(key);
+    return value && typeof value === "string" ? value : undefined;
+}
+export async function loadAppConfiguration() {
+    try {
+        const appConfigEndpoint = process.env.ConfigStore__Endpoints__0;
+        const labels = loadIndexedEnvVars("ConfigStore__Labels");
+        if (!appConfigEndpoint || labels.length === 0) {
+            return null;
+        }
+        const selectors = labels.flatMap((label) => [
+            { keyFilter: "ApplicationInsights:*", labelFilter: label },
+            { keyFilter: "Global:Runtime:*", labelFilter: label },
+            { keyFilter: "Draft:ManageApi:*", labelFilter: label },
+            { keyFilter: "Deliver:ApiClient:Domains:*", labelFilter: label },
+        ]);
+        const credential = new DefaultAzureCredential();
+        const configMap = await load(appConfigEndpoint, credential, {
+            selectors: selectors,
+            keyVaultOptions: {
+                credential: credential,
+            },
+        });
+        return {
+            manageApiUrl: getConfigValue(configMap, "Draft:ManageApi:Url"),
+            deliveryApiUrl: getConfigValue(configMap, "Deliver:ApiClient:Domains:LiveContentDomain"),
+        };
+    }
+    catch (error) {
+        console.log("Failed to load App Configuration:", error);
+        return null;
+    }
+}

package/build/server.js

@@ -30,7 +30,7 @@ import { registerTool as registerUnpublishVariantMapi } from "./tools/unpublish-
 import { registerTool as registerUpdateContentItemMapi } from "./tools/update-content-item-mapi.js";
 import { registerTool as registerUpsertLanguageVariantMapi } from "./tools/upsert-language-variant-mapi.js";
 // Create server instance
-export const createServer = () => {
+export const createServer = (config) => {
     const server = new McpServer({
         name: "kontent-ai",
         version: packageJson.version,
@@ -41,33 +41,33 @@ export const createServer = () => {
     });
     // Register all tools
     registerGetInitialContext(server);
-    registerGetItemMapi(server);
-    registerGetItemDapi(server);
-    registerGetVariantMapi(server);
-    registerGetTypeMapi(server);
-    registerListContentTypesMapi(server);
-    registerDeleteContentTypeMapi(server);
-    registerListLanguagesMapi(server);
-    registerGetAssetMapi(server);
-    registerListAssetsMapi(server);
-    registerAddContentTypeMapi(server);
-    registerPatchContentTypeMapi(server);
-    registerAddContentTypeSnippetMapi(server);
-    registerGetTypeSnippetMapi(server);
-    registerListContentTypeSnippetsMapi(server);
-    registerAddTaxonomyGroupMapi(server);
-    registerListTaxonomyGroupsMapi(server);
-    registerGetTaxonomyGroupMapi(server);
-    registerAddContentItemMapi(server);
-    registerUpdateContentItemMapi(server);
-    registerDeleteContentItemMapi(server);
-    registerUpsertLanguageVariantMapi(server);
-    registerCreateVariantVersionMapi(server);
-    registerDeleteLanguageVariantMapi(server);
-    registerListWorkflowsMapi(server);
-    registerChangeVariantWorkflowStepMapi(server);
-    registerFilterVariantsMapi(server);
-    registerPublishVariantMapi(server);
-    registerUnpublishVariantMapi(server);
+    registerGetItemMapi(server, config);
+    registerGetItemDapi(server, config);
+    registerGetVariantMapi(server, config);
+    registerGetTypeMapi(server, config);
+    registerListContentTypesMapi(server, config);
+    registerDeleteContentTypeMapi(server, config);
+    registerListLanguagesMapi(server, config);
+    registerGetAssetMapi(server, config);
+    registerListAssetsMapi(server, config);
+    registerAddContentTypeMapi(server, config);
+    registerPatchContentTypeMapi(server, config);
+    registerAddContentTypeSnippetMapi(server, config);
+    registerGetTypeSnippetMapi(server, config);
+    registerListContentTypeSnippetsMapi(server, config);
+    registerAddTaxonomyGroupMapi(server, config);
+    registerListTaxonomyGroupsMapi(server, config);
+    registerGetTaxonomyGroupMapi(server, config);
+    registerAddContentItemMapi(server, config);
+    registerUpdateContentItemMapi(server, config);
+    registerDeleteContentItemMapi(server, config);
+    registerUpsertLanguageVariantMapi(server, config);
+    registerCreateVariantVersionMapi(server, config);
+    registerDeleteLanguageVariantMapi(server, config);
+    registerListWorkflowsMapi(server, config);
+    registerChangeVariantWorkflowStepMapi(server, config);
+    registerFilterVariantsMapi(server, config);
+    registerPublishVariantMapi(server, config);
+    registerUnpublishVariantMapi(server, config);
     return { server };
 };

package/build/tools/add-content-item-mapi.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("add-content-item-mapi", "Add new Kontent.ai content item via Management API. This creates the content item structure but does not add content to language variants. Use upsert-language-variant-mapi to add content to the item.", {
         name: z
             .string()
@@ -32,8 +32,8 @@ export const registerTool = (server) => {
         })
             .optional()
             .describe("Reference to a collection by id, codename, or external_id (optional)"),
-    }, async ({ name, type, codename, external_id, collection }) => {
-        const client = createMapiClient();
+    }, async ({ name, type, codename, external_id, collection }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .addContentItem()

package/build/tools/add-content-type-mapi.js

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { contentGroupSchema, elementSchema, } from "../schemas/contentTypeSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("add-content-type-mapi", "Add new Kontent.ai content type via Management API", {
         name: z.string().describe("Display name of the content type"),
         codename: z
@@ -21,8 +21,8 @@ export const registerTool = (server) => {
             .array(contentGroupSchema)
             .optional()
             .describe("Array of content groups (optional)"),
-    }, async ({ name, codename, external_id, elements, content_groups }) => {
-        const client = createMapiClient();
+    }, async ({ name, codename, external_id, elements, content_groups }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .addContentType()

package/build/tools/add-content-type-snippet-mapi.js

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { snippetElementSchema } from "../schemas/contentTypeSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("add-content-type-snippet-mapi", "Add new Kontent.ai content type snippet via Management API", {
         name: z.string().describe("Display name of the content type snippet"),
         codename: z
@@ -17,8 +17,8 @@ export const registerTool = (server) => {
         elements: z
             .array(snippetElementSchema)
             .describe("Array of elements that define the structure of the content type snippet"),
-    }, async ({ name, codename, external_id, elements }) => {
-        const client = createMapiClient();
+    }, async ({ name, codename, external_id, elements }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .addContentTypeSnippet()

package/build/tools/add-taxonomy-group-mapi.js

@@ -2,9 +2,9 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { taxonomyGroupSchemas } from "../schemas/taxonomySchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("add-taxonomy-group-mapi", "Add new Kontent.ai taxonomy group via Management API", taxonomyGroupSchemas, async (taxonomyGroup) => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("add-taxonomy-group-mapi", "Add new Kontent.ai taxonomy group via Management API", taxonomyGroupSchemas, async (taxonomyGroup, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .addTaxonomy()

package/build/tools/change-variant-workflow-step-mapi.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("change-variant-workflow-step-mapi", "Change the workflow step of a language variant in Kontent.ai. This operation moves a language variant to a different step in the workflow, enabling content lifecycle management such as moving content from draft to review, review to published, etc.", {
         itemId: z
             .string()
@@ -20,8 +20,8 @@ export const registerTool = (server) => {
             .string()
             .uuid()
             .describe("Internal ID (UUID) of the target workflow step. This must be a valid step ID from the specified workflow. Common steps include Draft, Review, Published, and Archived, but the actual IDs depend on your specific workflow configuration"),
-    }, async ({ itemId, languageId, workflowId, workflowStepId }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId, workflowId, workflowStepId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .changeWorkflowOfLanguageVariant()

package/build/tools/create-variant-version-mapi.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("create-variant-version-mapi", "Create new version of Kontent.ai language variant via Management API. This operation creates a new version of an existing language variant, useful for content versioning and creating new drafts from published content.", {
         itemId: z
             .string()
@@ -12,8 +12,8 @@ export const registerTool = (server) => {
             .string()
             .uuid()
             .describe("Internal ID (UUID) of the language variant to create a new version of. Use '00000000-0000-0000-0000-000000000000' for the default language"),
-    }, async ({ itemId, languageId }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .createNewVersionOfLanguageVariant()

package/build/tools/delete-content-item-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("delete-content-item-mapi", "Delete Kontent.ai content item by internal ID from Management API", {
         id: z.string().describe("Internal ID of the content item to delete"),
-    }, async ({ id }) => {
-        const client = createMapiClient();
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .deleteContentItem()

package/build/tools/delete-content-type-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("delete-content-type-mapi", "Delete a content type by codename from Management API", {
         codename: z.string().describe("Codename of the content type to delete"),
-    }, async ({ codename }) => {
-        const client = createMapiClient();
+    }, async ({ codename }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .deleteContentType()

package/build/tools/delete-language-variant-mapi.js

@@ -2,14 +2,14 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("delete-language-variant-mapi", "Delete Kontent.ai language variant from Management API", {
         itemId: z.string().describe("Internal ID of the content item"),
         languageId: z
             .string()
             .describe("Internal ID of the language variant to delete"),
-    }, async ({ itemId, languageId }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .deleteLanguageVariant()

package/build/tools/filter-variants-mapi.js

@@ -2,8 +2,8 @@ import { filterVariantsSchema } from "../schemas/filterVariantSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 import { throwError } from "../utils/throwError.js";
-export const registerTool = (server) => {
-    server.tool("filter-variants-mapi", "Search and filter Kontent.ai language variants of content items using Management API", filterVariantsSchema.shape, async ({ search_phrase, content_types, contributors, has_no_contributors, completion_statuses, language, workflow_steps, taxonomy_groups, order_by, order_direction, continuation_token, }) => {
+export const registerTool = (server, config) => {
+    server.tool("filter-variants-mapi", "Search and filter Kontent.ai language variants of content items using Management API", filterVariantsSchema.shape, async ({ search_phrase, content_types, contributors, has_no_contributors, completion_statuses, language, workflow_steps, taxonomy_groups, order_by, order_direction, continuation_token, }, { authInfo: { token, clientId } = {} }) => {
         try {
             const requestPayload = {
                 filters: {
@@ -23,12 +23,18 @@ export const registerTool = (server) => {
                     }
                     : null,
             };
-            const environmentId = process.env.KONTENT_ENVIRONMENT_ID;
-            const apiKey = process.env.KONTENT_API_KEY;
-            if (!environmentId || !apiKey) {
-                throwError("Missing required environment variables");
+            const environmentId = clientId ?? process.env.KONTENT_ENVIRONMENT_ID;
+            if (!environmentId) {
+                throwError("Missing required environment ID");
             }
-            const url = `https://manage.kontent.ai/v2/projects/${environmentId}/early-access/variants/filter`;
+            const apiKey = token ?? process.env.KONTENT_API_KEY;
+            if (!apiKey) {
+                throwError("Missing required API key");
+            }
+            const baseUrl = config
+                ? `${config.manageApiUrl}`
+                : `https://manage.kontent.ai/`;
+            const url = `${baseUrl}v2/projects/${environmentId}/early-access/variants/filter`;
             const headers = {
                 Authorization: `Bearer ${apiKey}`,
                 "Content-Type": "application/json",

package/build/tools/get-asset-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-asset-mapi", "Get a specific Kontent.ai asset by internal ID from Management API", {
         assetId: z.string().describe("Internal ID of the asset to retrieve"),
-    }, async ({ assetId }) => {
-        const client = createMapiClient();
+    }, async ({ assetId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .viewAsset()

package/build/tools/get-item-dapi.js

@@ -2,7 +2,7 @@ import { createDeliveryClient } from "@kontent-ai/delivery-sdk";
 import { z } from "zod";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-item-dapi", "Get Kontent.ai item by codename from Delivery API", {
         codename: z.string().describe("Codename of the item to get"),
         environmentId: z
@@ -11,6 +11,9 @@ export const registerTool = (server) => {
     }, async ({ codename, environmentId }) => {
         const client = createDeliveryClient({
             environmentId,
+            proxy: {
+                baseUrl: config ? `https://${config.deliveryApiUrl}` : undefined,
+            },
         });
         try {
             const response = await client.item(codename).toPromise();

package/build/tools/get-item-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-item-mapi", "Get Kontent.ai item by internal ID from Management API", {
         id: z.string().describe("Internal ID of the item to get"),
-    }, async ({ id }) => {
-        const client = createMapiClient();
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .viewContentItem()

package/build/tools/get-taxonomy-group-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-taxonomy-group-mapi", "Get Kontent.ai taxonomy group by internal ID from Management API", {
         id: z.string().describe("Internal ID of the taxonomy group to get"),
-    }, async ({ id }) => {
-        const client = createMapiClient();
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .getTaxonomy()

package/build/tools/get-type-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-type-mapi", "Get Kontent.ai content type by internal ID from Management API", {
         id: z.string().describe("Internal ID of the content type to get"),
-    }, async ({ id }) => {
-        const client = createMapiClient();
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .viewContentType()

package/build/tools/get-type-snippet-mapi.js

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-type-snippet-mapi", "Get Kontent.ai content type snippet by internal ID from Management API", {
         id: z.string().describe("Internal ID of the content type snippet to get"),
-    }, async ({ id }) => {
-        const client = createMapiClient();
+    }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .viewContentTypeSnippet()

package/build/tools/get-variant-mapi.js

@@ -2,14 +2,14 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("get-variant-mapi", "Get Kontent.ai language variant of content item from Management API", {
         itemId: z.string().describe("Internal ID of the content item"),
         languageId: z
             .string()
             .describe("Internal ID of the language variant to get"),
-    }, async ({ itemId, languageId }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .viewLanguageVariant()

package/build/tools/list-assets-mapi.js

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("list-assets-mapi", "Get all Kontent.ai assets from Management API", {}, async () => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("list-assets-mapi", "Get all Kontent.ai assets from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listAssets().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

package/build/tools/list-content-type-snippets-mapi.js

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("list-content-type-snippets-mapi", "Get all Kontent.ai content type snippets from Management API", {}, async () => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("list-content-type-snippets-mapi", "Get all Kontent.ai content type snippets from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listContentTypeSnippets().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

package/build/tools/list-content-types-mapi.js

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("list-content-types-mapi", "Get all Kontent.ai content types from Management API", {}, async () => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("list-content-types-mapi", "Get all Kontent.ai content types from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listContentTypes().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

package/build/tools/list-languages-mapi.js

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("list-languages-mapi", "Get all Kontent.ai languages from Management API", {}, async () => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("list-languages-mapi", "Get all Kontent.ai languages from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listLanguages().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

package/build/tools/list-taxonomy-groups-mapi.js

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("list-taxonomy-groups-mapi", "Get all Kontent.ai taxonomy groups from Management API", {}, async () => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("list-taxonomy-groups-mapi", "Get all Kontent.ai taxonomy groups from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listTaxonomies().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

package/build/tools/list-workflows-mapi.js

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
-    server.tool("list-workflows-mapi", "Get all Kontent.ai workflows from Management API. Workflows define the content lifecycle stages and transitions between them.", {}, async () => {
-        const client = createMapiClient();
+export const registerTool = (server, config) => {
+    server.tool("list-workflows-mapi", "Get all Kontent.ai workflows from Management API. Workflows define the content lifecycle stages and transitions between them.", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listWorkflows().toPromise();
             return createMcpToolSuccessResponse(response.data);

package/build/tools/patch-content-type-mapi.js

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { patchOperationsSchema } from "../schemas/patchSchemas/contentTypePatchSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("patch-content-type-mapi", "Update an existing Kontent.ai content type by codename via Management API. Supports move, addInto, remove, and replace operations following RFC 6902 JSON Patch specification.", {
         codename: z.string().describe("Codename of the content type to update"),
         operations: patchOperationsSchema.describe(`Array of patch operations to apply. Supports: 'move' (reorganize elements), 'addInto' (add new elements), 'remove' (delete elements), 'replace' (update existing elements/properties).
@@ -54,8 +54,8 @@ export const registerTool = (server) => {
         - Consider element ordering when using move operations
         - Use atomic operations for complex changes like removing content groups
         - When adding to allowed_formatting or allowed_table_formatting, always ensure 'unstyled' is the first item in the array`),
-    }, async ({ codename, operations }) => {
-        const client = createMapiClient();
+    }, async ({ codename, operations }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             // Apply patch operations using the modifyContentType method
             const response = await client

package/build/tools/publish-variant-mapi.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("publish-variant-mapi", "Publish or schedule a language variant of a content item in Kontent.ai. This operation can either immediately publish the variant (publishing happens right now) or schedule it for publication at a specific future date and time. For immediate publishing: the variant is published immediately and becomes available through the Delivery API. For scheduled publishing: the variant moves to a 'Scheduled' workflow state and will automatically transition to 'Published' at the specified time. The variant must be in a valid state with all required fields filled and validation rules satisfied. A variant can only be published if a transition is defined between the variant's current workflow step and the Published workflow step.", {
         itemId: z
             .string()
@@ -21,8 +21,8 @@ export const registerTool = (server) => {
             .string()
             .optional()
             .describe("The timezone identifier for displaying the scheduled time in the Kontent.ai UI (e.g., 'America/New_York', 'Europe/London', 'UTC'). This parameter is used for scheduled publishing to specify the timezone context for the scheduled_to parameter. If not provided, the system will use the default timezone. This helps content creators understand when content will be published in their local context."),
-    }, async ({ itemId, languageId, scheduledTo, displayTimezone }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId, scheduledTo, displayTimezone }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

package/build/tools/unpublish-variant-mapi.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("unpublish-variant-mapi", "Unpublish or schedule unpublishing of a language variant of a content item in Kontent.ai. This operation can either immediately unpublish the variant (making it unavailable through the Delivery API) or schedule it for unpublishing at a specific future date and time. For immediate unpublishing: the variant is unpublished right away and moves to the 'Archived' workflow step, becoming unavailable through the Delivery API. For scheduled unpublishing: the variant remains published but is scheduled to be automatically unpublished at the specified time. The variant must currently be in the 'Published' state for this operation to succeed.", {
         itemId: z
             .string()
@@ -21,8 +21,8 @@ export const registerTool = (server) => {
             .string()
             .optional()
             .describe("The timezone identifier for displaying the scheduled time in the Kontent.ai UI (e.g., 'America/New_York', 'Europe/London', 'UTC'). This parameter is used for scheduled unpublishing to specify the timezone context for the scheduled_to parameter. If not provided, the system will use the default timezone. This helps content creators understand when content will be unpublished in their local context."),
-    }, async ({ itemId, languageId, scheduledTo, displayTimezone }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId, scheduledTo, displayTimezone }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

package/build/tools/update-content-item-mapi.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("update-content-item-mapi", "Update existing Kontent.ai content item by internal ID via Management API. The content item must already exist - this tool will not create new items.", {
         id: z.string().describe("Internal ID of the content item to update"),
         name: z
@@ -19,8 +19,8 @@ export const registerTool = (server) => {
         })
             .optional()
             .describe("Reference to a collection by id, codename, or external_id (optional)"),
-    }, async ({ id, name, collection }) => {
-        const client = createMapiClient();
+    }, async ({ id, name, collection }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         try {
             // First, verify the item exists by trying to get it
             await client.viewContentItem().byItemId(id).toPromise();

package/build/tools/upsert-language-variant-mapi.js

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { languageVariantElementSchema } from "../schemas/contentItemSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     server.tool("upsert-language-variant-mapi", "Create or update Kontent.ai language variant of a content item via Management API. This adds actual content to the content item elements. When updating an existing variant, only the provided elements will be modified.", {
         itemId: z.string().describe("Internal ID of the content item"),
         languageId: z
@@ -16,8 +16,8 @@ export const registerTool = (server) => {
             .string()
             .optional()
             .describe("Internal ID of the workflow step (optional)"),
-    }, async ({ itemId, languageId, elements, workflow_step_id }) => {
-        const client = createMapiClient();
+    }, async ({ itemId, languageId, elements, workflow_step_id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token, config);
         const data = {
             elements,
         };

package/build/utils/errorHandler.js

@@ -50,7 +50,7 @@ export const handleMcpToolError = (error, context) => {
             content: [
                 {
                     type: "text",
-                    text: `${contextPrefix}HTTP Error ${error.response.status}: ${error.response.statusText || "Unknown HTTP error"}\n\nResponse: ${JSON.stringify(error.response.data, null, 2)}`,
+                    text: `${contextPrefix}HTTP Error ${error.response.status}: ${error.response.statusText || "Unknown HTTP error"}\n\nResponse: ${JSON.stringify(error.response.data)}`,
                 },
             ],
             isError: true,
@@ -61,7 +61,7 @@ export const handleMcpToolError = (error, context) => {
         content: [
             {
                 type: "text",
-                text: `${contextPrefix}Unexpected error: ${error instanceof Error ? error.message : "Unknown error occurred"}\n\nFull error: ${JSON.stringify(error, null, 2)}`,
+                text: `${contextPrefix}Unexpected error: ${error instanceof Error ? error.message : "Unknown error occurred"}\n\nFull error: ${JSON.stringify(error)}`,
             },
         ],
         isError: true,

package/build/utils/extractBearerToken.js

@@ -0,0 +1,12 @@
+/**
+ * Extracts Bearer token from request authorization header
+ * @param req Express request object
+ * @returns Bearer token string or null if not found
+ */
+export const extractBearerToken = (req) => {
+    const authHeader = req.headers.authorization;
+    if (authHeader?.startsWith("Bearer ")) {
+        return authHeader.substring(7); // Remove 'Bearer ' prefix
+    }
+    return null;
+};

package/build/utils/isValidGuid.js

@@ -0,0 +1,9 @@
+/**
+ * Validates if a string is a valid GUID format
+ * @param guid String to validate
+ * @returns true if valid GUID format, false otherwise
+ */
+export const isValidGuid = (guid) => {
+    const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return guidRegex.test(guid);
+};

package/build/utils/responseHelper.js

@@ -11,7 +11,7 @@ export const createMcpToolSuccessResponse = (data) => {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(data, null, 2),
+                text: JSON.stringify(data),
             },
         ],
     };

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "type": "module",
   "scripts": {
     "build": "rimraf build && tsc",
     "start:stdio": "node build/bin.js stdio",
-    "start:sse": "node build/bin.js sse",
     "start:shttp": "node build/bin.js shttp",
     "dev:stdio": "tsx watch src/bin.ts stdio",
-    "dev:sse": "tsx watch src/bin.ts sse",
     "dev:shttp": "tsx watch src/bin.ts shttp",
     "format": "cross-env node node_modules/@biomejs/biome/bin/biome ci ./ --config-path=./biome.json",
     "format:fix": "cross-env node node_modules/@biomejs/biome/bin/biome check ./ --fix --unsafe  --config-path=./biome.json"
@@ -23,9 +21,13 @@
   "author": "Jiri Lojda",
   "license": "MIT",
   "dependencies": {
+    "@azure/app-configuration": "^1.9.0",
+    "@azure/app-configuration-provider": "^2.2.0",
+    "@azure/identity": "^4.11.1",
     "@kontent-ai/delivery-sdk": "^16.2.0",
     "@kontent-ai/management-sdk": "^7.9.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "applicationinsights": "^2.9.8",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "zod": "^3.25.30"