@kontent-ai/mcp-server 0.12.0 → 0.14.0

package/README.md

@@ -65,6 +65,8 @@ npx @kontent-ai/mcp-server@latest sse
 * **get-type-mapi** – Get Kontent.ai content type by internal ID from Management API
 * **list-content-types-mapi** – Get all Kontent.ai content types from Management API
 * **add-content-type-mapi** – Add new Kontent.ai content type via Management API
+* **patch-content-type-mapi** – Update an existing Kontent.ai content type by codename using patch operations (move, addInto, remove, replace)
+* **delete-content-type-mapi** – Delete a Kontent.ai content type by codename
 
 ### Content Type Snippet Management
 
@@ -159,6 +161,30 @@ Then configure your MCP client:
 }
 ```
 
+### 🌊 Streamable HTTP Transport
+
+For Streamable HTTP transport, first start the server:
+
+```bash
+npx @kontent-ai/mcp-server@latest shttp
+```
+
+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
+```
+
+Then configure your MCP client:
+```json
+{
+  "kontent-ai-http": {
+    "url": "http://localhost:3001/mcp"
+  }
+}
+```
+
 ## 💻 Development
 
 ### 🛠 Local Installation
@@ -177,10 +203,12 @@ 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
 ```
 
 ### 📂 Project Structure

package/build/bin.js

@@ -1,11 +1,70 @@
 #!/usr/bin/env node
-import "dotenv/config";
 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";
 const version = packageJson.version;
+async function startStreamableHTTP() {
+    const app = express();
+    app.use(express.json());
+    app.post("/mcp", async (req, res) => {
+        try {
+            const { server } = createServer();
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            res.on("close", () => {
+                console.log("Request closed");
+                transport.close();
+                server.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, 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,
+                });
+            }
+        }
+    });
+    app.get("/mcp", async (_, res) => {
+        console.log("Received GET MCP request");
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
+    });
+    app.delete("/mcp", async (_, res) => {
+        console.log("Received DELETE MCP request");
+        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} (Streamable HTTP) running on port ${PORT}`);
+    });
+}
 async function startSSE() {
     const app = express();
     const { server } = createServer();
@@ -32,8 +91,10 @@ async function main() {
     const args = process.argv.slice(2);
     const transportType = args[0]?.toLowerCase();
     if (!transportType ||
-        (transportType !== "stdio" && transportType !== "sse")) {
-        console.error("Please specify a valid transport type: stdio or sse");
+        (transportType !== "stdio" &&
+            transportType !== "sse" &&
+            transportType !== "shttp")) {
+        console.error("Please specify a valid transport type: stdio, sse, or shttp");
         process.exit(1);
     }
     if (transportType === "stdio") {
@@ -42,6 +103,9 @@ async function main() {
     else if (transportType === "sse") {
         await startSSE();
     }
+    else if (transportType === "shttp") {
+        await startStreamableHTTP();
+    }
 }
 main().catch((error) => {
     console.error("Fatal error:", error);

package/build/schemas/contentTypeSchemas.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 // Define a reusable reference object schema
-const referenceObjectSchema = z
+export const referenceObjectSchema = z
     .object({
     id: z.string().optional(),
     codename: z.string().optional(),
@@ -26,7 +26,7 @@ const namedElementSchema = {
 };
 // Limit schemas
 const conditionEnum = z.enum(["at_most", "exactly", "at_least"]);
-const countLimitSchema = z
+export const countLimitSchema = z
     .object({
     value: z.number(),
     condition: conditionEnum,
@@ -47,21 +47,21 @@ const imageLimitSchema = {
         .optional(),
 };
 // Default value schemas
-const arrayDefaultSchema = z
+export const arrayDefaultSchema = z
     .object({
     global: z.object({
         value: z.array(referenceObjectSchema),
     }),
 })
     .optional();
-const stringDefaultSchema = z
+export const stringDefaultSchema = z
     .object({
     global: z.object({
         value: z.string(),
     }),
 })
     .optional();
-const numberDefaultSchema = z
+export const numberDefaultSchema = z
     .object({
     global: z.object({
         value: z.number(),
@@ -69,7 +69,7 @@ const numberDefaultSchema = z
 })
     .optional();
 // Regex validation schema
-const regexValidationSchema = z
+export const regexValidationSchema = z
     .object({
     is_active: z.boolean(),
     regex: z.string(),
@@ -78,7 +78,7 @@ const regexValidationSchema = z
 })
     .optional();
 // Text length limit schema
-const textLengthLimitSchema = z
+export const textLengthLimitSchema = z
     .object({
     value: z.number(),
     applies_to: z.enum(["words", "characters"]),
@@ -133,15 +133,16 @@ const subpagesElementSchema = {
         .optional(),
     item_count_limit: countLimitSchema,
 };
+export const optionSchema = z.object({
+    name: z.string(),
+    codename: z.string().optional(),
+    external_id: z.string().optional(),
+});
 const multipleChoiceElementSchema = {
     type: z.literal("multiple_choice"),
     ...namedElementSchema,
     mode: z.enum(["single", "multiple"]),
-    options: z.array(z.object({
-        name: z.string(),
-        codename: z.string().optional(),
-        external_id: z.string().optional(),
-    })),
+    options: z.array(optionSchema),
     default: arrayDefaultSchema.describe("Default value of the multiple choice element. Reference one of the options by its codename."),
 };
 const numberElementSchema = {
@@ -149,67 +150,78 @@ const numberElementSchema = {
     ...namedElementSchema,
     default: numberDefaultSchema,
 };
+export const allowedBlockSchema = z.enum([
+    "images",
+    "text",
+    "tables",
+    "components-and-items",
+]);
+export const allowedFormattingSchema = z.enum([
+    "unstyled",
+    "bold",
+    "italic",
+    "code",
+    "link",
+    "subscript",
+    "superscript",
+]);
+export const allowedTextBlockSchema = z.enum([
+    "paragraph",
+    "heading-one",
+    "heading-two",
+    "heading-three",
+    "heading-four",
+    "heading-five",
+    "heading-six",
+    "ordered-list",
+    "unordered-list",
+]);
+export const allowedTableBlockSchema = z.enum(["images", "text"]);
+export const allowedTableFormattingSchema = z.enum([
+    "unstyled",
+    "bold",
+    "italic",
+    "code",
+    "link",
+    "subscript",
+    "superscript",
+]);
+export const allowedTableTextBlockSchema = z.enum([
+    "paragraph",
+    "heading-one",
+    "heading-two",
+    "heading-three",
+    "heading-four",
+    "heading-five",
+    "heading-six",
+    "ordered-list",
+    "unordered-list",
+]);
 const richTextElementSchema = {
     type: z.literal("rich_text"),
     ...namedElementSchema,
     allowed_blocks: z
-        .array(z.enum(["images", "text", "tables", "components-and-items"]))
+        .array(allowedBlockSchema)
         .optional()
         .describe("Specifies allowed blocks. Use an empty array to allow all options."),
     allowed_formatting: z
-        .array(z.enum([
-        "unstyled",
-        "bold",
-        "italic",
-        "code",
-        "link",
-        "subscript",
-        "superscript",
-    ]))
+        .array(allowedFormattingSchema)
         .optional()
         .describe("Specifies allowed formatting options. Use an empty array to allow all options."),
     allowed_text_blocks: z
-        .array(z.enum([
-        "paragraph",
-        "heading-one",
-        "heading-two",
-        "heading-three",
-        "heading-four",
-        "heading-five",
-        "heading-six",
-        "ordered-list",
-        "unordered-list",
-    ]))
+        .array(allowedTextBlockSchema)
         .optional()
         .describe("Specifies allowed text blocks. Use an empty array to allow all options."),
     allowed_table_blocks: z
-        .array(z.enum(["images", "text"]))
+        .array(allowedTableBlockSchema)
         .optional()
         .describe("Specifies allowed table blocks. Use an empty array to allow all options."),
     allowed_table_formatting: z
-        .array(z.enum([
-        "unstyled",
-        "bold",
-        "italic",
-        "code",
-        "link",
-        "subscript",
-        "superscript",
-    ]))
+        .array(allowedTableFormattingSchema)
         .optional()
         .describe("Specifies allowed table formatting options. Use an empty array to allow all options."),
     allowed_table_text_blocks: z
-        .array(z.enum([
-        "paragraph",
-        "heading-one",
-        "heading-two",
-        "heading-three",
-        "heading-four",
-        "heading-five",
-        "heading-six",
-        "ordered-list",
-        "unordered-list",
-    ]))
+        .array(allowedTableTextBlockSchema)
         .optional()
         .describe("Specifies allowed table text blocks. Use an empty array to allow all options."),
     allowed_content_types: z
@@ -244,17 +256,16 @@ const textElementSchema = {
     validation_regex: regexValidationSchema,
     default: stringDefaultSchema,
 };
+export const dependsOnSchema = z.object({
+    element: referenceObjectSchema.describe("An object with an id or codename property referencing an element."),
+    snippet: referenceObjectSchema
+        .describe("An object with an id or codename property referencing a content type snippet.")
+        .optional(),
+});
 const urlSlugElementSchema = {
     type: z.literal("url_slug"),
     ...namedElementSchema,
-    depends_on: z
-        .object({
-        element: referenceObjectSchema.describe("An object with an id or codename property referencing an element."),
-        snippet: referenceObjectSchema
-            .describe("An object with an id or codename property referencing a content type snippet.")
-            .optional(),
-    })
-        .describe("The element the URL slug depends on. If this element is within a snippet, the snippet must also be specified."),
+    depends_on: dependsOnSchema.describe("The element the URL slug depends on. If this element is within a snippet, the snippet must also be specified."),
     validation_regex: regexValidationSchema,
 };
 // Define a union type of all possible element types for content types

package/build/schemas/patchSchemas/contentTypePatchSchemas.js

@@ -0,0 +1,118 @@
+// Patch operation schemas for content type modifications
+// Based on: https://kontent.ai/learn/docs/apis/openapi/management-api-v2/#operation/modify-a-content-type
+import { z } from "zod";
+import { allowedBlockSchema, allowedFormattingSchema, allowedTableBlockSchema, allowedTableFormattingSchema, allowedTableTextBlockSchema, allowedTextBlockSchema, arrayDefaultSchema, contentGroupSchema, countLimitSchema, dependsOnSchema, elementSchema, numberDefaultSchema, optionSchema, referenceObjectSchema, regexValidationSchema, stringDefaultSchema, textLengthLimitSchema, } from "../contentTypeSchemas.js";
+// Move operation - Move elements within content type
+const moveOperationSchema = z.object({
+    op: z.literal("move"),
+    path: z
+        .string()
+        .describe(`Identifies the object you want to move using a path reference. The path reference should be in format 'id:{uuid}'. Examples:
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000' - Move an element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/options/id:987fcdeb-51a2-43d1-9f4e-123456789abc' - Move a multiple choice option (first reference is element, second is option)
+    • '/content_groups/id:456e7890-a12b-34c5-d678-901234567def' - Move a content group`),
+    before: referenceObjectSchema
+        .describe("A reference to the object before which you want to move the object. For example, to move an element before an existing element with id:uuid 'text', set before to {codename: 'text'}. The before and after properties are mutually exclusive.")
+        .optional(),
+    after: referenceObjectSchema
+        .describe("A reference to the object after which you want to move the object. For example, to move an element after an existing element with id:uuid 'Text', set after to {codename: 'text'}. The before and after properties are mutually exclusive.")
+        .optional(),
+});
+// AddInto operation - Add new elements to content type
+const addIntoOperationSchema = z.object({
+    op: z.literal("addInto"),
+    path: z
+        .string()
+        .describe(`JSON Pointer path where to add the item. The path reference should be in format 'id:{uuid}'. Examples:
+    • '/elements' - Add a new element to the content type
+    • '/content_groups' - Add a new content group
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_content_types' - Add allowed content type to rich text or linked items element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_elements' - Add allowed element to custom element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/options' - Add multiple choice option
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_blocks' - Add block for rich text element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_formatting' - Add formatting option for rich text element
+    (Replace with actual element UUID)
+
+    - CRITICAL: When adding a url slug that references a snippet element, first add the snippet element to the content type if it’s not already included.`),
+    value: z
+        .union([
+        elementSchema,
+        optionSchema,
+        contentGroupSchema,
+        referenceObjectSchema,
+        allowedBlockSchema,
+        allowedFormattingSchema,
+        allowedTextBlockSchema,
+        allowedTableBlockSchema,
+        allowedTableFormattingSchema,
+        allowedTableTextBlockSchema,
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.null(),
+        z.any(),
+    ])
+        .describe("The item to add (element, content group, option, etc.)"),
+});
+// Remove operation - Remove elements from content type
+const removeOperationSchema = z.object({
+    op: z.literal("remove"),
+    path: z
+        .string()
+        .describe(`JSON Pointer path to the item being removed. The path reference should be in format 'id:{uuid}'. Examples:
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000' - Remove an element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_content_types/id:987fcdeb-51a2-43d1-9f4e-123456789abc' - Remove allowed content type from rich text/linked items element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_element/id:456e7890-a12b-34c5-d678-901234567def' - Remove allowed element from custom element
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/options/id:321dcba9-87f6-54e3-21b0-fedcba987654' - Remove multiple choice option
+    • '/content_groups/id:456e7890-a12b-34c5-d678-901234567def' - Remove content group (removes all elements within the group)
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_blocks/images' - Remove rich-text element limitation (where {block} is the limitation type)
+    (Replace with actual UUIDs)`),
+});
+// Replace operation - Replace/update existing elements in content type
+const replaceOperationSchema = z.object({
+    op: z.literal("replace"),
+    path: z
+        .string()
+        .describe(`JSON Pointer path to the item or property being replaced. The path reference should be in format 'id:{uuid}' Examples:
+    • '/name' - Change the content type's name
+    • '/codename' - Change the content type's codename
+    • '/content_groups/id:456e7890-a12b-34c5-d678-901234567def/name' - Change the name of a content group
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/name' - Change an element property (property depends on element type)
+    • '/elements/id:123e4567-e89b-12d3-a456-426614174000/options/id:321dcba9-87f6-54e3-21b0-fedcba987654/name' - Change multiple choice option property (name or codename)
+    (Replace with actual element/group UUIDs)
+    
+    REPLACE OPERATION RULES:
+    • CAN modify: Most element properties based on element type (name, guidelines, validation, etc.)
+    • CANNOT modify: external_id, id, or type of elements
+    • CANNOT replace individual object values - must replace the entire object at once
+    • FOR rich text elements: CANNOT replace individual items in allowed_blocks, allowed_formatting, allowed_text_blocks, allowed_table_blocks, allowed_table_formatting, allowed_table_text_blocks, allowed_content_types, allowed_item_link_types arrays - use addInto/remove operations instead for individual items
+    • FOR multiple choice options: Can modify name and codename properties`),
+    value: z
+        .union([
+        dependsOnSchema,
+        regexValidationSchema,
+        textLengthLimitSchema,
+        countLimitSchema,
+        arrayDefaultSchema,
+        stringDefaultSchema,
+        numberDefaultSchema,
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.null(),
+        z.any(), // in Union zod tries to match from top to down. any if there is something missing so agent dont fail on validation.
+    ])
+        .describe("The new value to replace the existing one"),
+});
+// Union type for all patch operations
+export const patchOperationSchema = z.discriminatedUnion("op", [
+    moveOperationSchema,
+    addIntoOperationSchema,
+    removeOperationSchema,
+    replaceOperationSchema,
+]);
+// Schema for array of patch operations
+export const patchOperationsSchema = z
+    .array(patchOperationSchema)
+    .min(1)
+    .describe("Array of patch operations to apply to the content type. Must contain at least one operation.");

package/build/server.js

@@ -6,6 +6,7 @@ import { registerTool as registerAddContentTypeSnippetMapi } from "./tools/add-c
 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 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";
 import { registerTool as registerFilterVariantsMapi } from "./tools/filter-variants-mapi.js";
 import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js";
@@ -22,6 +23,7 @@ import { registerTool as registerListContentTypesMapi } from "./tools/list-conte
 import { registerTool as registerListLanguagesMapi } from "./tools/list-languages-mapi.js";
 import { registerTool as registerListTaxonomyGroupsMapi } from "./tools/list-taxonomy-groups-mapi.js";
 import { registerTool as registerListWorkflowsMapi } from "./tools/list-workflows-mapi.js";
+import { registerTool as registerPatchContentTypeMapi } from "./tools/patch-content-type-mapi.js";
 import { registerTool as registerPublishVariantMapi } from "./tools/publish-variant-mapi.js";
 import { registerTool as registerUnpublishVariantMapi } from "./tools/unpublish-variant-mapi.js";
 import { registerTool as registerUpdateContentItemMapi } from "./tools/update-content-item-mapi.js";
@@ -43,10 +45,12 @@ export const createServer = () => {
     registerGetVariantMapi(server);
     registerGetTypeMapi(server);
     registerListContentTypesMapi(server);
+    registerDeleteContentTypeMapi(server);
     registerListLanguagesMapi(server);
     registerGetAssetMapi(server);
     registerListAssetsMapi(server);
     registerAddContentTypeMapi(server);
+    registerPatchContentTypeMapi(server);
     registerAddContentTypeSnippetMapi(server);
     registerGetTypeSnippetMapi(server);
     registerListContentTypeSnippetsMapi(server);

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

@@ -0,0 +1,24 @@
+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("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();
+        try {
+            const response = await client
+                .deleteContentType()
+                .byTypeCodename(codename)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Content type '${codename}' deleted successfully`,
+                deletedType: response.data,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, "Content Type Deletion");
+        }
+    });
+};

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+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) => {
+    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).
+        
+        CRITICAL REQUIREMENTS:
+        - ALWAYS call get-type-mapi tool before patching to get the latest content type schema
+        - Use addInto/remove for array operations (adding/removing items from arrays like elements and element's array properties - allowed_content_types, allowed_item_link_types, allowed_blocks, allowed_text_blocks, allowed_formatting, allowed_table_blocks, allowed_table_text_blocks, allowed_table_formatting)
+        - Never ever use replace for element's array properties - use addInto/remove instead
+        - Use replace for element's primitive data types and object properties (maximum_text_length, validation_regex, etc.)
+        - External_id and type cannot be modified after creation
+        - Patch operations with URL Slug elements referencing snippet elements MUST ensure snippet is present first
+        - When adding to allowed_formatting or allowed_table_formatting, 'unstyled' must be the first item in the array. If it is not present, then add it as first operation.
+        
+        RICH TEXT ELEMENT PROPERTIES:
+        - allowed_content_types: Array of content type references. Specifies allowed content types for components and linked items. Empty array allows all.
+        - allowed_item_link_types: Array of content type references. Specifies content types allowed in text links (applies to text and tables). Empty array allows all.
+        - allowed_blocks: Available options: "images", "text", "tables", "components-and-items". Empty array allows all blocks.
+        - allowed_image_types: Available options: "adjustable" (only transformable images), "any" (all image files).
+        - allowed_text_blocks: Available options: "paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six", "ordered-list", "unordered-list". Empty array allows all.
+        - allowed_formatting: Available options: "unstyled", "bold", "italic", "code", "link", "subscript", "superscript". "unstyled" must be first if used. Empty array allows all.
+        - allowed_table_blocks: Available options: "images", "text". Use ["text"] for text-only or empty array for both text and images.
+        - allowed_table_text_blocks: Available options: "paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six", "ordered-list", "unordered-list". Empty array allows all.
+        - allowed_table_formatting: Available options: "unstyled", "bold", "italic", "code", "link", "subscript", "superscript". "unstyled" must be first if used. Empty array allows all.
+        
+        OPERATION TYPES:
+        1. move: Reorganize elements, options, or content groups. Uses 'before' or 'after' reference.
+        2. addInto: Add new elements, options, content groups, or array items. Use for all array operations.
+        3. remove: Remove elements, options, content groups, or array items. Use for all array removals.
+        4. replace: Update existing properties of primitive data types and objects. Cannot modify external_id, id, or type.
+        
+        PATH FORMATS:
+        - Use JSON Pointer paths with id:{uuid} format for referencing objects
+        - Element: /elements/id:123e4567-e89b-12d3-a456-426614174000
+        - Element property: /elements/id:123e4567-e89b-12d3-a456-426614174000/name
+        - Multiple choice option: /elements/id:123e4567-e89b-12d3-a456-426614174000/options/id:987fcdeb-51a2-43d1-9f4e-123456789abc
+        - Content group: /content_groups/id:456e7890-a12b-34c5-d678-901234567def
+        - Rich text array property: /elements/id:123e4567-e89b-12d3-a456-426614174000/allowed_content_types/id:987fcdeb-51a2-43d1-9f4e-123456789abc
+        
+        SPECIAL TECHNIQUES:
+        - To remove content groups while keeping elements: Set ALL elements' content_group to null AND remove ALL content groups in ONE request (atomic operation)
+        - URL Slug with snippet dependency: First add snippet element, then add URL slug with depends_on reference
+        
+        BEST PRACTICES:
+        - Use descriptive codenames following naming conventions
+        - Group related operations in a single patch request when possible
+        - Use proper reference formats (id:{uuid}) in paths
+        - Validate element dependencies before adding URL slug elements
+        - 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();
+        try {
+            // Apply patch operations using the modifyContentType method
+            const response = await client
+                .modifyContentType()
+                .byTypeCodename(codename)
+                .withData(operations)
+                .toPromise();
+            return createMcpToolSuccessResponse({
+                message: `Content type '${codename}' updated successfully with ${operations.length} operation(s)`,
+                contentType: response.rawData,
+                appliedOperations: operations,
+            });
+        }
+        catch (error) {
+            return handleMcpToolError(error, `Content Type Patch`);
+        }
+    });
+};

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.12.0",
+  "version": "0.14.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"
   },