@kontent-ai/mcp-server 0.21.11 → 0.22.1

package/README.md

@@ -89,7 +89,13 @@ npx @kontent-ai/mcp-server@latest shttp
 
 * **get-item-mapi** – Get Kontent.ai item by internal ID from Management API
 * **get-item-dapi** – Get Kontent.ai item by codename from Delivery API
-* **get-variant-mapi** – Get Kontent.ai language variant of content item from Management API
+* **get-latest-variant-mapi** – Get latest version of Kontent.ai language variant from Management API
+* **get-published-variant-mapi** – Get published version of Kontent.ai language variant from Management API
+* **list-variants-item-mapi** – List all Kontent.ai language variants of a content item from Management API
+* **list-variants-collection-mapi** – List Kontent.ai language variants by collection from Management API (paginated)
+* **list-variants-type-mapi** – List Kontent.ai language variants by content type from Management API (paginated)
+* **list-variants-components-type-mapi** – List Kontent.ai language variants containing components of a specific content type from Management API (paginated)
+* **list-variants-space-mapi** – List Kontent.ai language variants by space from Management API (paginated)
 * **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
@@ -107,6 +113,17 @@ npx @kontent-ai/mcp-server@latest shttp
 ### Language Management
 
 * **list-languages-mapi** – Get all Kontent.ai languages from Management API
+* **add-language-mapi** – Add new Kontent.ai language via Management API
+* **patch-language-mapi** – Update Kontent.ai language using replace operations via Management API
+
+### Collection Management
+
+* **list-collections-mapi** – Get all Kontent.ai collections from Management API. Collections set boundaries for content items in your environment and help organize content by team, brand, or project
+* **patch-collections-mapi** – Update Kontent.ai collections using patch operations (addInto to add new collections, move to reorder, remove to delete empty collections, replace to rename)
+
+### Space Management
+
+* **list-spaces-mapi** – Get all Kontent.ai spaces from Management API
 
 ### Workflow Management
 
@@ -217,7 +234,8 @@ Then configure your MCP client:
 
 No environment variables required. The server accepts requests for multiple environments using URL path parameters and Bearer authentication.
 
-##### VS Code Configuration
+<details>
+<summary><strong>VS Code</strong></summary>
 
 Create a `.vscode/mcp.json` file in your workspace:
 
@@ -261,7 +279,10 @@ For secure configuration with input prompts:
 }
 ```
 
-##### Claude Desktop Configuration
+</details>
+
+<details>
+<summary><strong>Claude Desktop</strong></summary>
 
 Update your Claude Desktop configuration file:
 - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
@@ -286,32 +307,25 @@ Use `mcp-remote` as a proxy to add authentication headers:
 }
 ```
 
-##### Claude Code Configuration
+</details>
+
+<details>
+<summary><strong>Claude Code</strong></summary>
 
-For Claude Code (claude.ai/code), add the server configuration:
+Add the server using the CLI:
 
 ```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
+claude mcp add --transport http kontent-ai-multi \
+  "http://localhost:3001/<environment-id>/mcp" \
+  --header "Authorization: Bearer <management-api-key>"
 ```
 
-Or configure directly in the settings:
+> **Note**: You can also configure this in your Claude Code settings JSON with the `url` and `headers` properties.
 
-```json
-{
-  "kontent-ai-multi": {
-    "url": "http://localhost:3001/<environment-id>/mcp",
-    "headers": {
-      "Authorization": "Bearer <management-api-key>"
-    }
-  }
-}
-```
+</details>
 
-**Important**: Replace `<environment-id>` with your actual Kontent.ai environment ID (GUID format) and `<management-api-key>` with your Management API key.
+> [!IMPORTANT]
+> Replace `<environment-id>` with your Kontent.ai environment ID (GUID) and `<management-api-key>` with your Management API key.
 
 ## 💻 Development
 

package/build/schemas/collectionSchemas.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { referenceObjectSchema } from "./referenceObjectSchema.js";
+const addIntoOperationSchema = z.object({
+    op: z.literal("addInto"),
+    value: z.object({
+        name: z.string(),
+        codename: z.string().optional(),
+        external_id: z.string().optional(),
+    }),
+    before: referenceObjectSchema.optional(),
+    after: referenceObjectSchema.optional(),
+});
+const moveOperationSchema = z.object({
+    op: z.literal("move"),
+    reference: referenceObjectSchema,
+    before: referenceObjectSchema.optional(),
+    after: referenceObjectSchema.optional(),
+});
+const removeOperationSchema = z.object({
+    op: z.literal("remove"),
+    reference: referenceObjectSchema,
+});
+const replaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    reference: referenceObjectSchema,
+    property_name: z.enum(["name"]),
+    value: z.string(),
+});
+export const collectionPatchOperationSchema = z.discriminatedUnion("op", [
+    addIntoOperationSchema,
+    moveOperationSchema,
+    removeOperationSchema,
+    replaceOperationSchema,
+]);
+export const collectionPatchOperationsSchema = z
+    .array(collectionPatchOperationSchema)
+    .min(1);

package/build/schemas/languageSchemas.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { referenceObjectSchema } from "./referenceObjectSchema.js";
+export const addLanguageSchema = z.object({
+    name: z.string().describe("Display name of the language"),
+    codename: z.string().describe("Codename identifier for the language"),
+    is_active: z
+        .boolean()
+        .optional()
+        .describe("Whether the language is active (defaults to true)"),
+    fallback_language: referenceObjectSchema
+        .optional()
+        .describe("Reference to fallback language (by id, codename, or external_id)"),
+    external_id: z.string().optional().describe("External ID for the language"),
+});
+const languageReplaceOperationSchema = z.discriminatedUnion("property_name", [
+    z.object({
+        op: z.literal("replace"),
+        property_name: z.literal("codename"),
+        value: z.string(),
+    }),
+    z.object({
+        op: z.literal("replace"),
+        property_name: z.literal("name"),
+        value: z.string(),
+    }),
+    z.object({
+        op: z.literal("replace"),
+        property_name: z.literal("is_active"),
+        value: z.boolean(),
+    }),
+    z.object({
+        op: z.literal("replace"),
+        property_name: z.literal("fallback_language"),
+        value: referenceObjectSchema,
+    }),
+]);
+export const patchLanguageSchema = z.object({
+    languageId: z.string().describe("Language ID to modify"),
+    operations: z
+        .array(languageReplaceOperationSchema)
+        .min(1)
+        .describe("Array of replace operations for codename, name, is_active, or fallback_language. Note: Only active languages can be modified - if language is deactivated, is_active: true must be first operation."),
+});

package/build/schemas/listSchemas.js

@@ -24,3 +24,19 @@ export const listContentTypeSnippetsSchema = z.object({
 export const listAssetsSchema = z.object({
     continuation_token: continuationTokenField,
 });
+export const listVariantsCollectionSchema = z.object({
+    collectionId: z.string().describe("Collection ID"),
+    continuation_token: continuationTokenField,
+});
+export const listVariantsTypeSchema = z.object({
+    contentTypeId: z.string().describe("Content type ID"),
+    continuation_token: continuationTokenField,
+});
+export const listVariantsComponentsTypeSchema = z.object({
+    contentTypeId: z.string().describe("Content type ID"),
+    continuation_token: continuationTokenField,
+});
+export const listVariantsSpaceSchema = z.object({
+    spaceId: z.string().describe("Space ID"),
+    continuation_token: continuationTokenField,
+});

package/build/schemas/taxonomySchemas.js

@@ -4,7 +4,7 @@ const taxonomyTermSchema = z.object({
     name: z.string(),
     codename: z.string().optional(),
     external_id: z.string().optional(),
-    terms: z.lazy(() => z.array(taxonomyTermSchema)),
+    terms: z.lazy(() => z.array(taxonomyTermSchema)).optional(),
 });
 // Schema for a taxonomy group
 export const taxonomyGroupSchemas = {
@@ -14,5 +14,8 @@ export const taxonomyGroupSchemas = {
         .optional()
         .describe("Codename (auto-generated if omitted)"),
     external_id: z.string().optional().describe("External ID"),
-    terms: z.array(taxonomyTermSchema).describe("Taxonomy terms hierarchy"),
+    terms: z
+        .array(taxonomyTermSchema)
+        .optional()
+        .describe("Taxonomy terms hierarchy"),
 };

package/build/server.js

@@ -3,6 +3,7 @@ import packageJson from "../package.json" with { type: "json" };
 import { registerTool as registerAddContentItemMapi } from "./tools/add-content-item-mapi.js";
 import { registerTool as registerAddContentTypeMapi } from "./tools/add-content-type-mapi.js";
 import { registerTool as registerAddContentTypeSnippetMapi } from "./tools/add-content-type-snippet-mapi.js";
+import { registerTool as registerAddLanguageMapi } from "./tools/add-language-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";
@@ -13,17 +14,27 @@ import { registerTool as registerFilterVariantsMapi } from "./tools/filter-varia
 import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js";
 import { registerTool as registerGetInitialContext } from "./tools/get-initial-context.js";
 import { registerTool as registerGetItemMapi } from "./tools/get-item-mapi.js";
+import { registerTool as registerGetLatestVariantMapi } from "./tools/get-latest-variant-mapi.js";
+import { registerTool as registerGetPublishedVariantMapi } from "./tools/get-published-variant-mapi.js";
 import { registerTool as registerGetTaxonomyGroupMapi } from "./tools/get-taxonomy-group-mapi.js";
 import { registerTool as registerGetTypeMapi } from "./tools/get-type-mapi.js";
 import { registerTool as registerGetTypeSnippetMapi } from "./tools/get-type-snippet-mapi.js";
-import { registerTool as registerGetVariantMapi } from "./tools/get-variant-mapi.js";
 import { registerTool as registerListAssetsMapi } from "./tools/list-assets-mapi.js";
+import { registerTool as registerListCollectionsMapi } from "./tools/list-collections-mapi.js";
 import { registerTool as registerListContentTypeSnippetsMapi } from "./tools/list-content-type-snippets-mapi.js";
 import { registerTool as registerListContentTypesMapi } from "./tools/list-content-types-mapi.js";
 import { registerTool as registerListLanguagesMapi } from "./tools/list-languages-mapi.js";
+import { registerTool as registerListSpacesMapi } from "./tools/list-spaces-mapi.js";
 import { registerTool as registerListTaxonomyGroupsMapi } from "./tools/list-taxonomy-groups-mapi.js";
+import { registerTool as registerListVariantsCollectionMapi } from "./tools/list-variants-collection-mapi.js";
+import { registerTool as registerListVariantsComponentsTypeMapi } from "./tools/list-variants-components-type-mapi.js";
+import { registerTool as registerListVariantsItemMapi } from "./tools/list-variants-item-mapi.js";
+import { registerTool as registerListVariantsSpaceMapi } from "./tools/list-variants-space-mapi.js";
+import { registerTool as registerListVariantsTypeMapi } from "./tools/list-variants-type-mapi.js";
 import { registerTool as registerListWorkflowsMapi } from "./tools/list-workflows-mapi.js";
+import { registerTool as registerPatchCollectionsMapi } from "./tools/patch-collections-mapi.js";
 import { registerTool as registerPatchContentTypeMapi } from "./tools/patch-content-type-mapi.js";
+import { registerTool as registerPatchLanguageMapi } from "./tools/patch-language-mapi.js";
 import { registerTool as registerPublishVariantMapi } from "./tools/publish-variant-mapi.js";
 import { registerTool as registerSearchVariantsMapi } from "./tools/search-variants-mapi.js";
 import { registerTool as registerUnpublishVariantMapi } from "./tools/unpublish-variant-mapi.js";
@@ -42,11 +53,22 @@ export const createServer = () => {
     // Register all tools
     registerGetInitialContext(server);
     registerGetItemMapi(server);
-    registerGetVariantMapi(server);
+    registerGetLatestVariantMapi(server);
+    registerGetPublishedVariantMapi(server);
+    registerListVariantsItemMapi(server);
+    registerListVariantsCollectionMapi(server);
+    registerListVariantsTypeMapi(server);
+    registerListVariantsComponentsTypeMapi(server);
+    registerListVariantsSpaceMapi(server);
     registerGetTypeMapi(server);
     registerListContentTypesMapi(server);
     registerDeleteContentTypeMapi(server);
     registerListLanguagesMapi(server);
+    registerAddLanguageMapi(server);
+    registerPatchLanguageMapi(server);
+    registerListCollectionsMapi(server);
+    registerPatchCollectionsMapi(server);
+    registerListSpacesMapi(server);
     registerGetAssetMapi(server);
     registerListAssetsMapi(server);
     registerAddContentTypeMapi(server);

package/build/test/utils/responseHelper.spec.js

@@ -53,18 +53,18 @@ describe("isEmptyOrDefault", () => {
     });
 });
 describe("removeEmptyValues", () => {
-    describe("primitive values", () => {
-        it("returns undefined for null", () => {
-            assert.strictEqual(removeEmptyValues(null), undefined);
+    describe("primitive values at root level - preserved as-is", () => {
+        it("returns null for null", () => {
+            assert.strictEqual(removeEmptyValues(null), null);
         });
         it("returns undefined for undefined", () => {
             assert.strictEqual(removeEmptyValues(undefined), undefined);
         });
-        it("returns undefined for empty string", () => {
-            assert.strictEqual(removeEmptyValues(""), undefined);
+        it("preserves empty string at root level", () => {
+            assert.strictEqual(removeEmptyValues(""), "");
         });
-        it("returns undefined for rich text empty paragraph", () => {
-            assert.strictEqual(removeEmptyValues("<p><br/></p>"), undefined);
+        it("preserves rich text empty paragraph at root level", () => {
+            assert.strictEqual(removeEmptyValues("<p><br/></p>"), "<p><br/></p>");
         });
         it("preserves non-empty string", () => {
             assert.strictEqual(removeEmptyValues("hello"), "hello");
@@ -77,14 +77,14 @@ describe("removeEmptyValues", () => {
         });
     });
     describe("arrays", () => {
-        it("returns undefined for empty array", () => {
-            assert.strictEqual(removeEmptyValues([]), undefined);
+        it("returns empty array for empty array at root level", () => {
+            assert.deepStrictEqual(removeEmptyValues([]), []);
         });
         it("removes empty values from array", () => {
             assert.deepStrictEqual(removeEmptyValues([1, null, 2, "", 3]), [1, 2, 3]);
         });
-        it("returns undefined when all array items are empty", () => {
-            assert.strictEqual(removeEmptyValues([null, "", [], {}]), undefined);
+        it("returns empty array when all array items are empty at root level", () => {
+            assert.deepStrictEqual(removeEmptyValues([null, "", [], {}]), []);
         });
         it("recursively cleans nested arrays", () => {
             assert.deepStrictEqual(removeEmptyValues([1, [2, null, 3], [null, ""]]), [
@@ -94,8 +94,8 @@ describe("removeEmptyValues", () => {
         });
     });
     describe("objects", () => {
-        it("returns undefined for empty object", () => {
-            assert.strictEqual(removeEmptyValues({}), undefined);
+        it("returns empty object for empty object at root level", () => {
+            assert.deepStrictEqual(removeEmptyValues({}), {});
         });
         it("removes null properties", () => {
             assert.deepStrictEqual(removeEmptyValues({ a: 1, b: null }), { a: 1 });
@@ -119,8 +119,8 @@ describe("removeEmptyValues", () => {
                 a: 1,
             });
         });
-        it("returns undefined when all properties are empty", () => {
-            assert.strictEqual(removeEmptyValues({ a: null, b: "", c: [], d: {} }), undefined);
+        it("returns empty object when all properties are empty at root level", () => {
+            assert.deepStrictEqual(removeEmptyValues({ a: null, b: "", c: [], d: {} }), {});
         });
     });
     describe("nested structures", () => {
@@ -448,3 +448,137 @@ describe("variant with all empty elements", () => {
         assert.deepStrictEqual(result, {}, "All empty elements should be removed, resulting in an empty object");
     });
 });
+describe("top-level empty value preservation", () => {
+    describe("createMcpToolSuccessResponse", () => {
+        it("returns empty array when input is empty array", () => {
+            const response = createMcpToolSuccessResponse([]);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, []);
+        });
+        it("returns empty object when input is empty object", () => {
+            const response = createMcpToolSuccessResponse({});
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, {});
+        });
+        it("returns empty object when all properties are removed", () => {
+            const input = { a: null, b: "", c: [] };
+            const response = createMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, {});
+        });
+        it("returns empty array when all array items are removed", () => {
+            const input = [null, "", [], {}];
+            const response = createMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, []);
+        });
+        it("returns valid JSON string (not undefined)", () => {
+            const response = createMcpToolSuccessResponse([]);
+            assert.strictEqual(typeof response.content[0].text, "string");
+            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
+        });
+        it("handles filter-variants-like response with empty data array", () => {
+            const input = {
+                data: [],
+                pagination: {
+                    continuation_token: null,
+                },
+            };
+            const response = createMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, {});
+        });
+    });
+    describe("createVariantMcpToolSuccessResponse", () => {
+        it("returns empty array when input is empty array", () => {
+            const response = createVariantMcpToolSuccessResponse([]);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, []);
+        });
+        it("returns empty object when input is empty object", () => {
+            const response = createVariantMcpToolSuccessResponse({});
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, {});
+        });
+        it("returns empty object when all properties are removed", () => {
+            const input = { a: null, b: "", c: [] };
+            const response = createVariantMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, {});
+        });
+        it("returns empty array when all array items are removed", () => {
+            const input = [null, "", [], {}];
+            const response = createVariantMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, []);
+        });
+        it("returns valid JSON string (not undefined)", () => {
+            const response = createVariantMcpToolSuccessResponse([]);
+            assert.strictEqual(typeof response.content[0].text, "string");
+            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
+        });
+        it("handles filter-variants-like response with empty data array", () => {
+            const input = {
+                data: [],
+                pagination: {
+                    continuation_token: null,
+                },
+            };
+            const response = createVariantMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            assert.deepStrictEqual(parsed, {});
+        });
+        it("handles filter-variants response with variants array becoming empty", () => {
+            const input = {
+                variants: [
+                    {
+                        elements: [
+                            { element: { id: "el-1" }, value: null },
+                            { element: { id: "el-2" }, value: "" },
+                        ],
+                    },
+                ],
+                pagination: {
+                    continuation_token: null,
+                },
+            };
+            const response = createVariantMcpToolSuccessResponse(input);
+            const parsed = JSON.parse(response.content[0].text);
+            // variants array should still be present (with empty variant objects)
+            assert.ok(parsed.variants !== undefined);
+            assert.strictEqual(parsed.variants.length, 1);
+        });
+    });
+});
+describe("undefined input handling - MCP protocol compliance", () => {
+    describe("createMcpToolSuccessResponse", () => {
+        it("returns string when input is undefined", () => {
+            const response = createMcpToolSuccessResponse(undefined);
+            assert.strictEqual(typeof response.content[0].text, "string");
+        });
+        it("returns 'undefined' text when input is undefined", () => {
+            const response = createMcpToolSuccessResponse(undefined);
+            assert.strictEqual(response.content[0].text, "undefined");
+        });
+        it("returns valid JSON string when input is null", () => {
+            const response = createMcpToolSuccessResponse(null);
+            assert.strictEqual(typeof response.content[0].text, "string");
+            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
+        });
+    });
+    describe("createVariantMcpToolSuccessResponse", () => {
+        it("returns string when input is undefined", () => {
+            const response = createVariantMcpToolSuccessResponse(undefined);
+            assert.strictEqual(typeof response.content[0].text, "string");
+        });
+        it("returns 'undefined' text when input is undefined", () => {
+            const response = createVariantMcpToolSuccessResponse(undefined);
+            assert.strictEqual(response.content[0].text, "undefined");
+        });
+        it("returns valid JSON string when input is null", () => {
+            const response = createVariantMcpToolSuccessResponse(null);
+            assert.strictEqual(typeof response.content[0].text, "string");
+            assert.doesNotThrow(() => JSON.parse(response.content[0].text));
+        });
+    });
+});

package/build/tools/add-language-mapi.js

@@ -0,0 +1,25 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { addLanguageSchema } from "../schemas/languageSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("add-language-mapi", "Add new Kontent.ai language via Management API", addLanguageSchema.shape, async ({ name, codename, is_active, fallback_language, external_id }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .addLanguage()
+                .withData({
+                name,
+                codename,
+                is_active,
+                fallback_language,
+                external_id,
+            })
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Language Creation");
+        }
+    });
+};

package/build/tools/context/initial-context.js

@@ -17,6 +17,12 @@ Content types define the structure and blueprint for language variants. They spe
 ### Content Type Snippets
 Content type snippets are reusable field groups that promote consistency across multiple content types. Following the DRY principle (define once, use everywhere), one snippet can be used across multiple content types. This prevents duplication and ensures consistency when you need the same fields across different content types.
 
+### Collections
+Collections organize content items into logical groups by team, brand, or project. Each content item belongs to exactly one collection.
+
+### Languages
+Languages define available locales for content. Each language can have a fallback language for content inheritance and can be activated or deactivated.
+
 ## Understanding Key Relationships
 
 The content structure flows from Content Type → Content Item → Language Variant(s). For reusability, Content Type Snippets can be included in multiple Content Types. For localization, each Content Item can have one Language Variant per language.

package/build/tools/{get-variant-mapi.js → get-latest-variant-mapi.js}

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createVariantMcpToolSuccessResponse } from "../utils/responseHelper.js";
 export const registerTool = (server) => {
-    server.tool("get-variant-mapi", "Get Kontent.ai variant", {
+    server.tool("get-latest-variant-mapi", "Get latest version of Kontent.ai language variant from Management API", {
         itemId: z.string().describe("Item ID"),
         languageId: z.string().describe("Language variant ID"),
     }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
@@ -17,7 +17,7 @@ export const registerTool = (server) => {
             return createVariantMcpToolSuccessResponse(response.rawData);
         }
         catch (error) {
-            return handleMcpToolError(error, "Language Variant Retrieval");
+            return handleMcpToolError(error, "Latest Language Variant Retrieval");
         }
     });
 };

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { createMapiClient } from "../clients/kontentClients.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createVariantMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("get-published-variant-mapi", "Get published version of Kontent.ai language variant from Management API", {
+        itemId: z.string().describe("Item ID"),
+        languageId: z.string().describe("Language variant ID"),
+    }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .viewLanguageVariant()
+                .byItemId(itemId)
+                .byLanguageId(languageId)
+                .published()
+                .toPromise();
+            return createVariantMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Published Language Variant Retrieval");
+        }
+    });
+};

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

@@ -0,0 +1,15 @@
+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-collections-mapi", "Get all Kontent.ai collections", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client.listCollections().toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Collections Listing");
+        }
+    });
+};

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

@@ -0,0 +1,15 @@
+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-spaces-mapi", "Get all Kontent.ai spaces from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client.listSpaces().toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Spaces Listing");
+        }
+    });
+};

package/build/tools/list-variants-collection-mapi.js

@@ -0,0 +1,26 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listVariantsCollectionSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("list-variants-collection-mapi", "List Kontent.ai language variants by collection from Management API (paginated)", listVariantsCollectionSchema.describe("Use list-collections-mapi to get collection ID if not provided").shape, async ({ collectionId, continuation_token }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const query = client
+                .listLanguageVariantsByCollection()
+                .byCollectionId(collectionId);
+            const response = await (continuation_token
+                ? query.xContinuationToken(continuation_token)
+                : query).toPromise();
+            return createMcpToolSuccessResponse({
+                variants: response.rawData.variants,
+                pagination: {
+                    continuation_token: response.data.pagination.continuationToken,
+                },
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Collection Variants Listing");
+        }
+    });
+};

package/build/tools/list-variants-components-type-mapi.js

@@ -0,0 +1,26 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listVariantsComponentsTypeSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("list-variants-components-type-mapi", "List Kontent.ai language variants containing components of a specific content type from Management API (paginated)", listVariantsComponentsTypeSchema.shape, async ({ contentTypeId, continuation_token }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const query = client
+                .listLanguageVariantsOfContentTypeWithComponents()
+                .byTypeId(contentTypeId);
+            const response = await (continuation_token
+                ? query.xContinuationToken(continuation_token)
+                : query).toPromise();
+            return createMcpToolSuccessResponse({
+                variants: response.rawData.variants,
+                pagination: {
+                    continuation_token: response.data.pagination.continuationToken,
+                },
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Variants With Components Listing");
+        }
+    });
+};

package/build/tools/list-variants-item-mapi.js

@@ -0,0 +1,21 @@
+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("list-variants-item-mapi", "List all Kontent.ai language variants of a content item from Management API", {
+        itemId: z.string().describe("Content item ID"),
+    }, async ({ itemId }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .listLanguageVariantsOfItem()
+                .byItemId(itemId)
+                .toPromise();
+            return createMcpToolSuccessResponse(response.rawData);
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Item Variants Listing");
+        }
+    });
+};

package/build/tools/list-variants-space-mapi.js

@@ -0,0 +1,24 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listVariantsSpaceSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("list-variants-space-mapi", "List Kontent.ai language variants by space from Management API (paginated)", listVariantsSpaceSchema.shape, async ({ spaceId, continuation_token }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const query = client.listLanguageVariantsBySpace().bySpaceId(spaceId);
+            const response = await (continuation_token
+                ? query.xContinuationToken(continuation_token)
+                : query).toPromise();
+            return createMcpToolSuccessResponse({
+                variants: response.rawData.variants,
+                pagination: {
+                    continuation_token: response.data.pagination.continuationToken,
+                },
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Space Variants Listing");
+        }
+    });
+};

package/build/tools/list-variants-type-mapi.js

@@ -0,0 +1,26 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { listVariantsTypeSchema } from "../schemas/listSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("list-variants-type-mapi", "List Kontent.ai language variants by content type from Management API (paginated)", listVariantsTypeSchema.shape, async ({ contentTypeId, continuation_token }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const query = client
+                .listLanguageVariantsOfContentType()
+                .byTypeId(contentTypeId);
+            const response = await (continuation_token
+                ? query.xContinuationToken(continuation_token)
+                : query).toPromise();
+            return createMcpToolSuccessResponse({
+                variants: response.rawData.variants,
+                pagination: {
+                    continuation_token: response.data.pagination.continuationToken,
+                },
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Variants Listing");
+        }
+    });
+};

package/build/tools/patch-collections-mapi.js

@@ -0,0 +1,25 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { collectionPatchOperationsSchema } from "../schemas/collectionSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("patch-collections-mapi", "Update Kontent.ai collections using patch operations (addInto, move, remove, replace)", {
+        operations: collectionPatchOperationsSchema.describe("Patch operations array. Call list-collections-mapi first. Use addInto to add new collections, move to reorder, remove to delete empty collections, replace to rename."),
+    }, async ({ operations }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .setCollections()
+                .withData(operations)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Collections updated successfully with ${operations.length} operation(s)`,
+                collections: response.rawData,
+                appliedOperations: operations,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Collections Patch");
+        }
+    });
+};

package/build/tools/patch-language-mapi.js

@@ -0,0 +1,24 @@
+import { createMapiClient } from "../clients/kontentClients.js";
+import { patchLanguageSchema } from "../schemas/languageSchemas.js";
+import { handleMcpToolError } from "../utils/errorHandler.js";
+import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
+export const registerTool = (server) => {
+    server.tool("patch-language-mapi", "Update Kontent.ai language using replace operations via Management API. Only active languages can be modified - if deactivated, is_active: true must be first operation.", patchLanguageSchema.shape, async ({ languageId, operations }, { authInfo: { token, clientId } = {} }) => {
+        const client = createMapiClient(clientId, token);
+        try {
+            const response = await client
+                .modifyLanguage()
+                .byLanguageId(languageId)
+                .withData(operations)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Language updated with ${operations.length} operation(s)`,
+                language: response.rawData,
+                appliedOperations: operations,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Language Patch");
+        }
+    });
+};

package/build/utils/responseHelper.js

@@ -55,7 +55,7 @@ export function removeEmptyElementsFromVariant(obj) {
     }
     return result;
 }
-export function removeEmptyValues(obj) {
+function removeEmptyValuesRecursive(obj) {
     if (obj === null || obj === undefined) {
         return undefined;
     }
@@ -64,13 +64,13 @@ export function removeEmptyValues(obj) {
     }
     if (Array.isArray(obj)) {
         const cleaned = obj
-            .map((item) => removeEmptyValues(item))
+            .map((item) => removeEmptyValuesRecursive(item))
             .filter((item) => item !== undefined);
         return cleaned.length === 0 ? undefined : cleaned;
     }
     const cleaned = {};
     for (const [key, value] of Object.entries(obj)) {
-        const cleanedValue = removeEmptyValues(value);
+        const cleanedValue = removeEmptyValuesRecursive(value);
         if (cleanedValue !== undefined) {
             cleaned[key] = cleanedValue;
         }
@@ -78,25 +78,51 @@ export function removeEmptyValues(obj) {
     const keys = Object.keys(cleaned);
     return keys.length === 0 ? undefined : cleaned;
 }
-export const createMcpToolSuccessResponse = (data) => {
+export function removeEmptyValues(obj) {
+    // At root level, preserve the structure even if empty
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj
+            .map((item) => removeEmptyValuesRecursive(item))
+            .filter((item) => item !== undefined);
+    }
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const cleanedValue = removeEmptyValuesRecursive(value);
+        if (cleanedValue !== undefined) {
+            cleaned[key] = cleanedValue;
+        }
+    }
+    return cleaned;
+}
+/**
+ * Converts data to MCP tool success response format.
+ * Handles undefined separately as JSON.stringify(undefined) returns undefined (not a string).
+ * Skips stringify for strings as they don't need JSON encoding for MCP text response.
+ */
+const toMcpSuccessResponse = (data) => {
+    const text = data === undefined
+        ? "undefined"
+        : typeof data === "string"
+            ? data
+            : JSON.stringify(data);
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(removeEmptyValues(data)),
+                text,
             },
         ],
     };
 };
+export const createMcpToolSuccessResponse = (data) => {
+    const cleaned = removeEmptyValues(data);
+    return toMcpSuccessResponse(cleaned);
+};
 export const createVariantMcpToolSuccessResponse = (data) => {
     const cleaned = removeEmptyValues(data);
     const optimized = removeEmptyElementsFromVariant(cleaned);
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(optimized),
-            },
-        ],
-    };
+    return toMcpSuccessResponse(optimized);
 };

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.21.11",
+  "version": "0.22.1",
   "type": "module",
   "mcpName": "io.github.kontent-ai/mcp-server",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kontent-ai/mcp-server"
+  },
   "scripts": {
     "build": "rimraf build && tsc --project scripts/tsconfig.json && tsc",
     "start:stdio": "node build/bin.js stdio",
@@ -25,7 +29,7 @@
   "author": "Jiri Lojda",
   "license": "MIT",
   "dependencies": {
-    "@kontent-ai/management-sdk": "^7.11.0",
+    "@kontent-ai/management-sdk": "^8.1.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "applicationinsights": "^2.9.8",
     "dotenv": "^16.5.0",