@kontent-ai/mcp-server 0.2.0 → 0.4.0

package/README.md

@@ -5,9 +5,9 @@ This server provides a Model Context Protocol (MCP) interface for interacting wi
 ## Features
 
 - Retrieve content items, variants, and assets
-- Get content types and their structure
 - List available languages and assets
-- Create new content types and snippets
+- Get, List, and Create content types and snippets
+- Get, List, and Create taxonomies
 
 ## Getting Started
 
@@ -16,41 +16,53 @@ This server provides a Model Context Protocol (MCP) interface for interacting wi
 - Node.js (version specified in `.nvmrc`)
 - Kontent.ai account with API keys
 
-### Environment Variables
+### Running
 
-The following environment variables are needed:
+You can run this server with either stdio or sse transport.
 
-```
-KONTENT_ENVIRONMENT_ID=your_environment_id
-KONTENT_API_KEY=your_api_key
+### Stdio transport
+
+To run the server with stdio transport configure your MCP client with the command to run and the necessary environment variables.
+Example:
+```json
+{
+  "kontent-ai-stdio": {
+      "command": "npx @kontent-ai/mcp-server@latest stdio",
+      "env": {
+        "KONTENT_API_KEY": "<management-api-key>",
+        "KONTENT_ENVIRONMENT_ID": "<environment-id>"
+      }
+    }
+}
 ```
 
-### Using with npx
+### SSE transport
 
-You can run the server directly with npx:
+You can also run your server manually with the SSE transport and configure your MCP client to connect to the port the server is running on.
+Run the following command to start the server and ensure the environment variables are defined for it either by providing `.env` file in the `cwd` or providing the variables to the process any other way.
 
 ```bash
-# Run with SSE transport
-npx @kontent-ai/mcp-server sse
-
-# Run with STDIO transport
-npx @kontent-ai/mcp-server stdio
+npx @kontent-ai/mcp-server@latest sse
+```
+```env
+KONTENT_API_KEY=<management-api-key>
+KONTENT_ENVIRONMENT_ID=<environment-id>
+PORT=<port-number> # optionally specify port, defaults to 3001
 ```
 
-### Example mcp.json usage
-
+Then configure your MCP client to connect to the running server.
+Example:
 ```json
 {
-  "kontent-ai-stdio": {
-      "command": "npx @kontent-ai/mcp stdio",
-      "env": {
-        "KONTENT_API_KEY": "<management-api-key>",
-        "KONTENT_ENVIRONMENT_ID": "<environment-id>"
-      }
-    },
+  "kontent-ai-sse": {
+    "url": "http://localhost:3001/sse"
+  }
 }
 ```
 
+
+## Development
+
 ### Local Installation
 
 ```bash
@@ -69,8 +81,6 @@ npm run start:sse  # For SSE transport
 npm run start:stdio  # For STDIO transport
 ```
 
-## Development
-
 ### Available Scripts
 
 - `npm run build` - Compile TypeScript to JavaScript

package/build/clients/kontentClients.js

@@ -1,4 +1,9 @@
 import { createManagementClient } from '@kontent-ai/management-sdk';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const packageJsonPath = join(import.meta.dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const sourceTrackingHeaderName = 'X-KC-SOURCE';
 /**
  * Creates a Kontent.ai Management API client
  * @param environmentId Optional environment ID (defaults to process.env.KONTENT_ENVIRONMENT_ID)
@@ -9,6 +14,10 @@ export const createMapiClient = (environmentId, apiKey) => {
     return createManagementClient({
         apiKey: apiKey ?? process.env.KONTENT_API_KEY ?? throwError("KONTENT_API_KEY is not set"),
         environmentId: environmentId ?? process.env.KONTENT_ENVIRONMENT_ID ?? throwError("KONTENT_ENVIRONMENT_ID is not set"),
+        headers: [{
+                header: sourceTrackingHeaderName,
+                value: `${packageJson.name};${packageJson.version}`,
+            }],
     });
 };
 const throwError = (message) => {

package/build/schemas/contentTypeSchemas.js

@@ -8,7 +8,9 @@ const referenceObjectSchema = z.object({
 const baseElementSchema = {
     codename: z.string().optional(),
     external_id: z.string().optional(),
-    content_group: referenceObjectSchema.optional(),
+    content_group: referenceObjectSchema
+        .describe("An object with an id or codename property referencing a content group.")
+        .optional(),
 };
 const namedElementSchema = {
     ...baseElementSchema,
@@ -61,120 +63,131 @@ const textLengthLimitSchema = z.object({
     value: z.number(),
     applies_to: z.enum(['words', 'characters'])
 }).optional();
+// Individual element type schemas
+const assetElementSchema = z.object({
+    type: z.literal('asset'),
+    ...namedElementSchema,
+    asset_count_limit: countLimitSchema,
+    maximum_file_size: z.number().optional(),
+    allowed_file_types: z.enum(['adjustable', 'any']).optional(),
+    ...imageLimitSchema,
+    default: arrayDefaultSchema(),
+});
+const customElementSchema = z.object({
+    type: z.literal('custom'),
+    ...namedElementSchema,
+    source_url: z.string(),
+    json_parameters: z.string().optional(),
+    allowed_elements: z.array(referenceObjectSchema
+        .describe("An object with an id or codename property referencing an element.")).optional(),
+});
+const dateTimeElementSchema = z.object({
+    type: z.literal('date_time'),
+    ...namedElementSchema,
+    default: stringDefaultSchema,
+});
+const guidelinesElementSchema = z.object({
+    type: z.literal('guidelines'),
+    guidelines: z.string(),
+    ...baseElementSchema,
+});
+const modularContentElementSchema = z.object({
+    type: z.literal('modular_content'),
+    ...namedElementSchema,
+    allowed_content_types: z.array(referenceObjectSchema
+        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    item_count_limit: countLimitSchema,
+    default: arrayDefaultSchema(),
+});
+const subpagesElementSchema = z.object({
+    type: z.literal('subpages'),
+    ...namedElementSchema,
+    allowed_content_types: z.array(referenceObjectSchema
+        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    item_count_limit: countLimitSchema,
+});
+const multipleChoiceElementSchema = z.object({
+    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(),
+    })),
+    default: arrayDefaultSchema(),
+});
+const numberElementSchema = z.object({
+    type: z.literal('number'),
+    ...namedElementSchema,
+    default: numberDefaultSchema,
+});
+const richTextElementSchema = z.object({
+    type: z.literal('rich_text'),
+    ...namedElementSchema,
+    allowed_blocks: z.array(z.enum(['images', 'text', 'tables', 'components-and-items'])).optional(),
+    allowed_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
+    allowed_text_blocks: z.array(z.enum(['paragraph', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'ordered-list', 'unordered-list'])).optional(),
+    allowed_table_blocks: z.array(z.enum(['images', 'text'])).optional(),
+    allowed_table_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
+    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'])).optional(),
+    allowed_content_types: z.array(referenceObjectSchema
+        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    allowed_item_link_types: z.array(referenceObjectSchema
+        .describe("An object with an id or codename property referencing a content type.")).optional(),
+    ...imageLimitSchema,
+    allowed_image_types: z.enum(['adjustable', 'any']).optional(),
+    maximum_image_size: z.number().optional(),
+    maximum_text_length: textLengthLimitSchema,
+});
+const snippetElement = z.object({
+    type: z.literal('snippet'),
+    snippet: referenceObjectSchema
+        .describe("An object with an id or codename property referencing a snippet."),
+    ...baseElementSchema,
+});
+const taxonomyElementSchema = z.object({
+    type: z.literal('taxonomy'),
+    taxonomy_group: referenceObjectSchema
+        .describe("An object with an id or codename property referencing a taxonomy group."),
+    ...namedElementSchema,
+    term_count_limit: countLimitSchema,
+    default: arrayDefaultSchema(),
+});
+const textElementSchema = z.object({
+    type: z.literal('text'),
+    ...namedElementSchema,
+    maximum_text_length: textLengthLimitSchema,
+    validation_regex: regexValidationSchema,
+    default: stringDefaultSchema,
+});
+const urlSlugElementSchema = z.object({
+    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(),
+    }),
+    validation_regex: regexValidationSchema,
+});
 // Define a union type of all possible element types for content types
-export const elementSchema = z.union([
-    // Asset element
-    z.object({
-        type: z.literal('asset'),
-        ...namedElementSchema,
-        asset_count_limit: countLimitSchema,
-        maximum_file_size: z.number().optional(),
-        allowed_file_types: z.enum(['adjustable', 'any']).optional(),
-        ...imageLimitSchema,
-        default: arrayDefaultSchema(),
-    }),
-    // Custom element
-    z.object({
-        type: z.literal('custom'),
-        ...namedElementSchema,
-        source_url: z.string(),
-        json_parameters: z.string().optional(),
-        allowed_elements: z.array(referenceObjectSchema).optional(),
-    }),
-    // Date time element
-    z.object({
-        type: z.literal('date_time'),
-        ...namedElementSchema,
-        default: stringDefaultSchema,
-    }),
-    // Guidelines element
-    z.object({
-        type: z.literal('guidelines'),
-        guidelines: z.string(),
-        ...baseElementSchema,
-    }),
-    // Linked items (modular content) element
-    z.object({
-        type: z.literal('modular_content'),
-        ...namedElementSchema,
-        allowed_content_types: z.array(referenceObjectSchema).optional(),
-        item_count_limit: countLimitSchema,
-        default: arrayDefaultSchema(),
-    }),
-    // Subpages element
-    z.object({
-        type: z.literal('subpages'),
-        ...namedElementSchema,
-        allowed_content_types: z.array(referenceObjectSchema).optional(),
-        item_count_limit: countLimitSchema,
-    }),
-    // Multiple choice element
-    z.object({
-        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(),
-        })),
-        default: arrayDefaultSchema(),
-    }),
-    // Number element
-    z.object({
-        type: z.literal('number'),
-        ...namedElementSchema,
-        default: numberDefaultSchema,
-    }),
-    // Rich text element
-    z.object({
-        type: z.literal('rich_text'),
-        ...namedElementSchema,
-        allowed_blocks: z.array(z.enum(['images', 'text', 'tables', 'components-and-items'])).optional(),
-        allowed_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
-        allowed_text_blocks: z.array(z.enum(['paragraph', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'ordered-list', 'unordered-list'])).optional(),
-        allowed_table_blocks: z.array(z.enum(['images', 'text'])).optional(),
-        allowed_table_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
-        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'])).optional(),
-        allowed_content_types: z.array(referenceObjectSchema).optional(),
-        allowed_item_link_types: z.array(referenceObjectSchema).optional(),
-        ...imageLimitSchema,
-        allowed_image_types: z.enum(['adjustable', 'any']).optional(),
-        maximum_image_size: z.number().optional(),
-        maximum_text_length: textLengthLimitSchema,
-    }),
-    // Snippet element
-    z.object({
-        type: z.literal('snippet'),
-        snippet: referenceObjectSchema,
-        ...baseElementSchema,
-    }),
-    // Taxonomy element
-    z.object({
-        type: z.literal('taxonomy'),
-        taxonomy_group: referenceObjectSchema,
-        ...namedElementSchema,
-        term_count_limit: countLimitSchema,
-        default: arrayDefaultSchema(),
-    }),
-    // Text element
-    z.object({
-        type: z.literal('text'),
-        ...namedElementSchema,
-        maximum_text_length: textLengthLimitSchema,
-        validation_regex: regexValidationSchema,
-        default: stringDefaultSchema,
-    }),
-    // URL slug element
-    z.object({
-        type: z.literal('url_slug'),
-        ...namedElementSchema,
-        depends_on: z.object({
-            element: referenceObjectSchema,
-            snippet: referenceObjectSchema.optional(),
-        }),
-        validation_regex: regexValidationSchema,
-    }),
+export const elementSchema = z.discriminatedUnion('type', [
+    assetElementSchema,
+    customElementSchema,
+    dateTimeElementSchema,
+    guidelinesElementSchema,
+    modularContentElementSchema,
+    subpagesElementSchema,
+    multipleChoiceElementSchema,
+    numberElementSchema,
+    richTextElementSchema,
+    snippetElement,
+    taxonomyElementSchema,
+    textElementSchema,
+    urlSlugElementSchema,
 ]);
 // Define schema for content groups
 export const contentGroupSchema = z.object({
@@ -183,101 +196,16 @@ export const contentGroupSchema = z.object({
     codename: z.string().optional(),
 });
 // Define a union type for snippet elements (excluding url_slug and snippet elements)
-export const snippetElementSchema = z.union([
-    // Asset element
-    z.object({
-        type: z.literal('asset'),
-        ...namedElementSchema,
-        asset_count_limit: countLimitSchema,
-        maximum_file_size: z.number().optional(),
-        allowed_file_types: z.enum(['adjustable', 'any']).optional(),
-        ...imageLimitSchema,
-        default: arrayDefaultSchema(),
-    }),
-    // Custom element
-    z.object({
-        type: z.literal('custom'),
-        ...namedElementSchema,
-        source_url: z.string(),
-        json_parameters: z.string().optional(),
-        allowed_elements: z.array(referenceObjectSchema).optional(),
-    }),
-    // Date time element
-    z.object({
-        type: z.literal('date_time'),
-        ...namedElementSchema,
-        default: stringDefaultSchema,
-    }),
-    // Guidelines element
-    z.object({
-        type: z.literal('guidelines'),
-        guidelines: z.string(),
-        ...baseElementSchema,
-    }),
-    // Linked items (modular content) element
-    z.object({
-        type: z.literal('modular_content'),
-        ...namedElementSchema,
-        allowed_content_types: z.array(referenceObjectSchema).optional(),
-        item_count_limit: countLimitSchema,
-        default: arrayDefaultSchema(),
-    }),
-    // Subpages element
-    z.object({
-        type: z.literal('subpages'),
-        ...namedElementSchema,
-        allowed_content_types: z.array(referenceObjectSchema).optional(),
-        item_count_limit: countLimitSchema,
-    }),
-    // Multiple choice element
-    z.object({
-        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(),
-        })),
-        default: arrayDefaultSchema(),
-    }),
-    // Number element
-    z.object({
-        type: z.literal('number'),
-        ...namedElementSchema,
-        default: numberDefaultSchema,
-    }),
-    // Rich text element
-    z.object({
-        type: z.literal('rich_text'),
-        ...namedElementSchema,
-        allowed_blocks: z.array(z.enum(['images', 'text', 'tables', 'components-and-items'])).optional(),
-        allowed_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
-        allowed_text_blocks: z.array(z.enum(['paragraph', 'heading-one', 'heading-two', 'heading-three', 'heading-four', 'heading-five', 'heading-six', 'ordered-list', 'unordered-list'])).optional(),
-        allowed_table_blocks: z.array(z.enum(['images', 'text'])).optional(),
-        allowed_table_formatting: z.array(z.enum(['unstyled', 'bold', 'italic', 'code', 'link', 'subscript', 'superscript'])).optional(),
-        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'])).optional(),
-        allowed_content_types: z.array(referenceObjectSchema).optional(),
-        allowed_item_link_types: z.array(referenceObjectSchema).optional(),
-        ...imageLimitSchema,
-        allowed_image_types: z.enum(['adjustable', 'any']).optional(),
-        maximum_image_size: z.number().optional(),
-        maximum_text_length: textLengthLimitSchema,
-    }),
-    // Taxonomy element
-    z.object({
-        type: z.literal('taxonomy'),
-        taxonomy_group: referenceObjectSchema,
-        ...namedElementSchema,
-        term_count_limit: countLimitSchema,
-        default: arrayDefaultSchema(),
-    }),
-    // Text element
-    z.object({
-        type: z.literal('text'),
-        ...namedElementSchema,
-        maximum_text_length: textLengthLimitSchema,
-        validation_regex: regexValidationSchema,
-        default: stringDefaultSchema,
-    }),
+export const snippetElementSchema = z.discriminatedUnion('type', [
+    assetElementSchema,
+    customElementSchema,
+    dateTimeElementSchema,
+    guidelinesElementSchema,
+    modularContentElementSchema,
+    subpagesElementSchema,
+    multipleChoiceElementSchema,
+    numberElementSchema,
+    richTextElementSchema,
+    taxonomyElementSchema,
+    textElementSchema,
 ]);

package/build/schemas/taxonomySchemas.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+// Schema for a taxonomy term
+const taxonomyTermSchema = z.object({
+    name: z.string(),
+    codename: z.string().optional(),
+    external_id: z.string().optional(),
+    terms: z.lazy(() => z.array(taxonomyTermSchema)),
+});
+// Schema for a taxonomy group
+export const taxonomyGroupSchemas = {
+    name: z.string().describe("Display name of the taxonomy group"),
+    codename: z.string().optional().describe("Codename of the taxonomy group (optional, will be generated if not provided)"),
+    external_id: z.string().optional().describe("External ID of the taxonomy group (optional)"),
+    terms: z.array(taxonomyTermSchema).describe("Hierarchical structure of taxonomy terms"),
+};

package/build/server.js

@@ -9,6 +9,11 @@ import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js"
 import { registerTool as registerListAssetsMapi } from "./tools/list-assets-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 registerGetTypeSnippetMapi } from "./tools/get-type-snippet-mapi.js";
+import { registerTool as registerListContentTypeSnippetsMapi } from "./tools/list-content-type-snippets-mapi.js";
+import { registerTool as registerAddTaxonomyGroupMapi } from "./tools/add-taxonomy-group-mapi.js";
+import { registerTool as registerListTaxonomyGroupsMapi } from "./tools/list-taxonomy-groups-mapi.js";
+import { registerTool as registerGetTaxonomyGroupMapi } from "./tools/get-taxonomy-group-mapi.js";
 // Create server instance
 export const createServer = () => {
     const server = new McpServer({
@@ -30,5 +35,10 @@ export const createServer = () => {
     registerListAssetsMapi(server);
     registerAddContentTypeMapi(server);
     registerAddContentTypeSnippetMapi(server);
+    registerGetTypeSnippetMapi(server);
+    registerListContentTypeSnippetsMapi(server);
+    registerAddTaxonomyGroupMapi(server);
+    registerListTaxonomyGroupsMapi(server);
+    registerGetTaxonomyGroupMapi(server);
     return { server };
 };

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

@@ -0,0 +1,19 @@
+import { createMapiClient } from '../clients/kontentClients.js';
+import { taxonomyGroupSchemas } from '../schemas/taxonomySchemas.js';
+export const registerTool = (server) => {
+    server.tool("add-taxonomy-group-mapi", "Add a new taxonomy group via Management API", taxonomyGroupSchemas, async (taxonomyGroup) => {
+        const client = createMapiClient();
+        const response = await client
+            .addTaxonomy()
+            .withData(taxonomyGroup)
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data),
+                },
+            ],
+        };
+    });
+};

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { createMapiClient } from '../clients/kontentClients.js';
+export const registerTool = (server) => {
+    server.tool("get-taxonomy-group-mapi", "Get taxonomy group by codename from Management API", {
+        codename: z.string().describe("Codename of the taxonomy group to get")
+    }, async ({ codename }) => {
+        const client = createMapiClient();
+        const response = await client
+            .getTaxonomy()
+            .byTaxonomyCodename(codename)
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data),
+                },
+            ],
+        };
+    });
+};

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { createMapiClient } from '../clients/kontentClients.js';
+export const registerTool = (server) => {
+    server.tool("get-type-snippet-mapi", "Get content type snippet by codename from Management API", {
+        codename: z.string().describe("Codename of the content type snippet to get")
+    }, async ({ codename }) => {
+        const client = createMapiClient();
+        const response = await client
+            .viewContentTypeSnippet()
+            .byTypeCodename(codename)
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data),
+                },
+            ],
+        };
+    });
+};

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

@@ -0,0 +1,17 @@
+import { createMapiClient } from '../clients/kontentClients.js';
+export const registerTool = (server) => {
+    server.tool("list-content-type-snippets-mapi", "Get all content type snippets from Management API", {}, async () => {
+        const client = createMapiClient();
+        const response = await client
+            .listContentTypeSnippets()
+            .toAllPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data),
+                },
+            ],
+        };
+    });
+};

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

@@ -0,0 +1,17 @@
+import { createMapiClient } from '../clients/kontentClients.js';
+export const registerTool = (server) => {
+    server.tool("list-taxonomy-groups-mapi", "Get all taxonomy groups from Management API", {}, async () => {
+        const client = createMapiClient();
+        const response = await client
+            .listTaxonomies()
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data),
+                },
+            ],
+        };
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "scripts": {
     "build": "tsc",
@@ -17,16 +17,16 @@
   "author": "Jiri Lojda",
   "license": "MIT",
   "dependencies": {
-    "@kontent-ai/delivery-sdk": "^16.1.0",
+    "@kontent-ai/delivery-sdk": "^16.2.0",
     "@kontent-ai/management-sdk": "^7.9.0",
-    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@modelcontextprotocol/sdk": "^1.11.4",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
-    "zod": "^3.24.2"
+    "zod": "^3.25.7"
   },
   "devDependencies": {
-    "@types/express": "^5.0.1",
-    "@types/node": "^22.14.1",
+    "@types/express": "^5.0.2",
+    "@types/node": "^22.15.19",
     "typescript": "^5.8.3"
   }
 }