@kontent-ai/mcp-server 0.15.0 → 0.17.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
@@ -88,7 +88,8 @@ npx @kontent-ai/mcp-server@latest sse
 * **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
 * **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
 * **delete-content-item-mapi** – Delete Kontent.ai content item by internal ID from Management API
-* **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. Elements should be provided as JSON string in the format expected by the SDK
+* **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
+* **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
 * **delete-language-variant-mapi** – Delete Kontent.ai language variant from Management API
 * **filter-variants-mapi** – Search and filter Kontent.ai language variants of content items using Management API
 
@@ -110,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
 
@@ -137,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>
@@ -155,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
@@ -201,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
 ```
@@ -231,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,11 +1,12 @@
 #!/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 { createServer } from "./server.js";
+import { extractBearerToken } from "./utils/extractBearerToken.js";
+import { isValidGuid } from "./utils/isValidGuid.js";
 const version = packageJson.version;
 async function startStreamableHTTP() {
     const app = express();
@@ -39,7 +40,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 +50,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,25 +59,80 @@ 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();
+            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() {
@@ -91,18 +145,13 @@ async function main() {
     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();
-    }
     else if (transportType === "shttp") {
         await startStreamableHTTP();
     }

package/build/server.js

@@ -5,6 +5,7 @@ import { registerTool as registerAddContentTypeMapi } from "./tools/add-content-
 import { registerTool as registerAddContentTypeSnippetMapi } from "./tools/add-content-type-snippet-mapi.js";
 import { registerTool as registerAddTaxonomyGroupMapi } from "./tools/add-taxonomy-group-mapi.js";
 import { registerTool as registerChangeVariantWorkflowStepMapi } from "./tools/change-variant-workflow-step-mapi.js";
+import { registerTool as registerCreateVariantVersionMapi } from "./tools/create-variant-version-mapi.js";
 import { registerTool as registerDeleteContentItemMapi } from "./tools/delete-content-item-mapi.js";
 import { registerTool as registerDeleteContentTypeMapi } from "./tools/delete-content-type-mapi.js";
 import { registerTool as registerDeleteLanguageVariantMapi } from "./tools/delete-language-variant-mapi.js";
@@ -61,6 +62,7 @@ export const createServer = () => {
     registerUpdateContentItemMapi(server);
     registerDeleteContentItemMapi(server);
     registerUpsertLanguageVariantMapi(server);
+    registerCreateVariantVersionMapi(server);
     registerDeleteLanguageVariantMapi(server);
     registerListWorkflowsMapi(server);
     registerChangeVariantWorkflowStepMapi(server);

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

@@ -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);
         try {
             const response = await client
                 .addContentItem()

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

@@ -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);
         try {
             const response = await client
                 .addContentType()

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

@@ -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);
         try {
             const response = await client
                 .addContentTypeSnippet()

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

@@ -3,8 +3,8 @@ 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();
+    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);
         try {
             const response = await client
                 .addTaxonomy()

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

@@ -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);
         try {
             const response = await client
                 .changeWorkflowOfLanguageVariant()

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

@@ -0,0 +1,32 @@
+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) => {
+    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()
+            .uuid()
+            .describe("Internal ID (UUID) of the content item whose language variant you want to create a new version of"),
+        languageId: z
+            .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 }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .createNewVersionOfLanguageVariant()
+                .byItemId(itemId)
+                .byLanguageId(languageId)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Successfully created new version of language variant '${languageId}' for content item '${itemId}'`,
+                result: response.data,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Variant Version Creation");
+        }
+    });
+};

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .deleteContentItem()

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .deleteContentType()

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

@@ -8,8 +8,8 @@ export const registerTool = (server) => {
         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);
         try {
             const response = await client
                 .deleteLanguageVariant()

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

@@ -3,7 +3,7 @@ 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, }) => {
+    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,10 +23,13 @@ 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 apiKey = token ?? process.env.KONTENT_API_KEY;
+            if (!apiKey) {
+                throwError("Missing required API key");
             }
             const url = `https://manage.kontent.ai/v2/projects/${environmentId}/early-access/variants/filter`;
             const headers = {

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .viewAsset()

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .viewContentItem()

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .getTaxonomy()

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .viewContentType()

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

@@ -5,8 +5,8 @@ import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
     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);
         try {
             const response = await client
                 .viewContentTypeSnippet()

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

@@ -8,8 +8,8 @@ export const registerTool = (server) => {
         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);
         try {
             const response = await client
                 .viewLanguageVariant()

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

@@ -2,8 +2,8 @@ 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();
+    server.tool("list-assets-mapi", "Get all Kontent.ai assets from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listAssets().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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

@@ -2,8 +2,8 @@ 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();
+    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);
         try {
             const response = await client.listContentTypeSnippets().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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

@@ -2,8 +2,8 @@ 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();
+    server.tool("list-content-types-mapi", "Get all Kontent.ai content types from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listContentTypes().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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

@@ -2,8 +2,8 @@ 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();
+    server.tool("list-languages-mapi", "Get all Kontent.ai languages from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listLanguages().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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

@@ -2,8 +2,8 @@ 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();
+    server.tool("list-taxonomy-groups-mapi", "Get all Kontent.ai taxonomy groups from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listTaxonomies().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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

@@ -2,8 +2,8 @@ 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();
+    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);
         try {
             const response = await client.listWorkflows().toPromise();
             return createMcpToolSuccessResponse(response.data);

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

@@ -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);
         try {
             // Apply patch operations using the modifyContentType method
             const response = await client

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

@@ -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);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

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

@@ -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);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

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

@@ -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);
         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

@@ -4,18 +4,20 @@ import { languageVariantElementSchema } from "../schemas/contentItemSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
-    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. Elements should be provided as JSON string in the format expected by the SDK.", {
+    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
             .string()
             .describe("Internal ID of the language variant (e.g., '00000000-0000-0000-0000-000000000000' for default language)"),
-        elements: z.array(languageVariantElementSchema),
+        elements: z
+            .array(languageVariantElementSchema)
+            .describe("Array of content elements, each with 'element' (reference object with id/codename/external_id) and 'value' properties. Additional properties may be required depending on element type (e.g., 'mode' for URL slugs)."),
         workflow_step_id: z
             .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);
         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.15.0",
+  "version": "0.17.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"