@kontent-ai/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,79 @@
+# Kontent.ai MCP Server
+
+This server provides a Model Context Protocol (MCP) interface for interacting with Kontent.ai's Management and Delivery APIs. It enables AI assistants to access and manipulate Kontent.ai content using standardized tools.
+
+## Features
+
+- Retrieve content items, variants, and assets
+- Get content types and their structure
+- List available languages and assets
+- Create new content types and snippets
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js (version specified in `.nvmrc`)
+- Kontent.ai account with API keys
+
+### Environment Variables
+
+Create a `.env` file with the following variables:
+
+```
+KONTENT_ENVIRONMENT_ID=your_environment_id
+KONTENT_API_KEY=your_api_key
+PORT=3001  # Optional, defaults to 3001
+```
+
+### Using with npx
+
+You can run the server directly with npx:
+
+```bash
+# Run with SSE transport
+npx @kontent-ai/mcp-server sse
+
+# Run with STDIO transport
+npx @kontent-ai/mcp-server stdio
+```
+
+### Local Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/kontent-ai/mcp-server.git
+cd mcp-server
+
+# Install dependencies
+npm ci
+
+# Build the project
+npm run build
+
+# Start the server
+npm run start:sse  # For SSE transport
+npm run start:stdio  # For STDIO transport
+```
+
+## Development
+
+### Available Scripts
+
+- `npm run build` - Compile TypeScript to JavaScript
+- `npm run start:sse` - Start the server with Server-Sent Events transport
+- `npm run start:stdio` - Start the server with Standard IO transport
+
+### Project Structure
+
+- `src/` - Source code
+  - `tools/` - MCP tool implementations
+  - `clients/` - Kontent.ai API client setup
+  - `schemas/` - Data validation schemas
+  - `server.ts` - Main server setup and tool registration
+  - `sseTransport.ts` - SSE transport implementation
+  - `stdioTransport.ts` - STDIO transport implementation
+
+## License
+
+MIT 

package/build/clients/kontentClients.js

@@ -0,0 +1,16 @@
+import { createManagementClient } from '@kontent-ai/management-sdk';
+/**
+ * Creates a Kontent.ai Management API client
+ * @param environmentId Optional environment ID (defaults to process.env.KONTENT_ENVIRONMENT_ID)
+ * @param apiKey Optional API key (defaults to process.env.KONTENT_API_KEY)
+ * @returns Management API client instance
+ */
+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"),
+    });
+};
+const throwError = (message) => {
+    throw new Error(message);
+};

package/build/schemas/contentTypeSchemas.js

@@ -0,0 +1,283 @@
+import { z } from "zod";
+// Define a reusable reference object schema
+const referenceObjectSchema = z.object({
+    id: z.string().optional(),
+    codename: z.string().optional(),
+});
+// Common property schemas
+const baseElementSchema = {
+    codename: z.string().optional(),
+    external_id: z.string().optional(),
+    content_group: referenceObjectSchema.optional(),
+};
+const namedElementSchema = {
+    ...baseElementSchema,
+    name: z.string(),
+    guidelines: z.string().optional(),
+    is_required: z.boolean().optional(),
+    is_non_localizable: z.boolean().optional(),
+};
+// Limit schemas
+const conditionEnum = z.enum(['at_most', 'exactly', 'at_least']);
+const countLimitSchema = z.object({
+    value: z.number(),
+    condition: conditionEnum
+}).optional();
+const imageLimitSchema = {
+    image_width_limit: z.object({
+        value: z.number(),
+        condition: conditionEnum
+    }).optional(),
+    image_height_limit: z.object({
+        value: z.number(),
+        condition: conditionEnum
+    }).optional(),
+};
+// Default value schemas
+const arrayDefaultSchema = (schema = referenceObjectSchema) => z.object({
+    global: z.object({
+        value: z.array(schema)
+    })
+}).optional();
+const stringDefaultSchema = z.object({
+    global: z.object({
+        value: z.string()
+    })
+}).optional();
+const numberDefaultSchema = z.object({
+    global: z.object({
+        value: z.number()
+    })
+}).optional();
+// Regex validation schema
+const regexValidationSchema = z.object({
+    is_active: z.boolean(),
+    regex: z.string(),
+    flags: z.string().optional(),
+    validation_message: z.string().optional()
+}).optional();
+// Text length limit schema
+const textLengthLimitSchema = z.object({
+    value: z.number(),
+    applies_to: z.enum(['words', 'characters'])
+}).optional();
+// 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,
+    }),
+]);
+// Define schema for content groups
+export const contentGroupSchema = z.object({
+    name: z.string(),
+    external_id: z.string().optional(),
+    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,
+    }),
+]);

package/build/server.js

@@ -0,0 +1,34 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTool as registerGetItemMapi } from "./tools/get-item-mapi.js";
+import { registerTool as registerGetItemDapi } from "./tools/get-item-dapi.js";
+import { registerTool as registerGetVariantMapi } from "./tools/get-variant-mapi.js";
+import { registerTool as registerGetTypeMapi } from "./tools/get-type-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 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";
+// Create server instance
+export const createServer = () => {
+    const server = new McpServer({
+        name: "kontent-ai",
+        version: "1.0.0",
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+    });
+    // Register all tools
+    registerGetItemMapi(server);
+    registerGetItemDapi(server);
+    registerGetVariantMapi(server);
+    registerGetTypeMapi(server);
+    registerListContentTypesMapi(server);
+    registerListLanguagesMapi(server);
+    registerGetAssetMapi(server);
+    registerListAssetsMapi(server);
+    registerAddContentTypeMapi(server);
+    registerAddContentTypeSnippetMapi(server);
+    return { server };
+};

package/build/sseTransport.js

@@ -0,0 +1,23 @@
+import 'dotenv/config';
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from "express";
+import { createServer } from "./server.js";
+const app = express();
+const { server } = createServer();
+let transport;
+app.get("/sse", async (req, res) => {
+    transport = new SSEServerTransport("/message", res);
+    await server.connect(transport);
+    /*server.onclose = async () => {
+      //await cleanup();
+      await server.close();
+      process.exit(0);
+    };*/
+});
+app.post("/message", async (req, res) => {
+    await transport.handlePostMessage(req, res);
+});
+const PORT = process.env.PORT || 3001;
+app.listen(PORT, () => {
+    console.log(`Kontent.ai MCP Server (SSE) running on port ${PORT}`);
+});

package/build/stdioTransport.js

@@ -0,0 +1,13 @@
+import 'dotenv/config';
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+// Create server instance
+const { server } = createServer();
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { createMapiClient } from '../clients/kontentClients.js';
+import { elementSchema, contentGroupSchema } from '../schemas/contentTypeSchemas.js';
+export const registerTool = (server) => {
+    server.tool("add-content-type-mapi", "Add a new content type via Management API", {
+        name: z.string().describe("Display name of the content type"),
+        codename: z.string().optional().describe("Codename of the content type (optional, will be generated if not provided)"),
+        external_id: z.string().optional().describe("External ID of the content type (optional)"),
+        elements: z.array(elementSchema).describe("Array of elements that define the structure of the content type"),
+        content_groups: z.array(contentGroupSchema).optional().describe("Array of content groups (optional)"),
+    }, async ({ name, codename, external_id, elements, content_groups }) => {
+        const client = createMapiClient();
+        const response = await client
+            .addContentType()
+            .withData(() => ({
+            name,
+            codename,
+            external_id,
+            elements,
+            content_groups: content_groups?.map(group => ({
+                name: group.name,
+                external_id: group.external_id,
+                codename: group.codename
+            })),
+        }))
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.rawData),
+                },
+            ],
+        };
+    });
+};

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { createMapiClient } from '../clients/kontentClients.js';
+import { snippetElementSchema, contentGroupSchema } from '../schemas/contentTypeSchemas.js';
+export const registerTool = (server) => {
+    server.tool("add-content-type-snippet-mapi", "Add a new content type snippet via Management API", {
+        name: z.string().describe("Display name of the content type snippet"),
+        codename: z.string().optional().describe("Codename of the content type snippet (optional, will be generated if not provided)"),
+        external_id: z.string().optional().describe("External ID of the content type snippet (optional)"),
+        elements: z.array(snippetElementSchema).describe("Array of elements that define the structure of the content type snippet"),
+        content_groups: z.array(contentGroupSchema).optional().describe("Array of content groups (optional)"),
+    }, async ({ name, codename, external_id, elements, content_groups }) => {
+        const client = createMapiClient();
+        const response = await client
+            .addContentTypeSnippet()
+            .withData(() => ({
+            name,
+            codename,
+            external_id,
+            elements,
+            content_groups: content_groups?.map(group => ({
+                name: group.name,
+                external_id: group.external_id,
+                codename: group.codename
+            })),
+        }))
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.rawData),
+                },
+            ],
+        };
+    });
+};

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

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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { createDeliveryClient } from '@kontent-ai/delivery-sdk';
+export const registerTool = (server) => {
+    server.tool("get-item-dapi", "Get Kontent.ai item by codename from Delivery API", {
+        codename: z.string().describe("Codename of the item to get"),
+        environmentId: z.string().describe("Environment ID of the item's environment"),
+    }, async ({ codename, environmentId }) => {
+        const client = createDeliveryClient({
+            environmentId,
+        });
+        const response = await client
+            .item(codename)
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data.item),
+                },
+            ],
+        };
+    });
+};

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { createMapiClient } from '../clients/kontentClients.js';
+export const registerTool = (server) => {
+    server.tool("get-variant-mapi", "Get language variant of a content item from Management API", {
+        itemCodename: z.string().describe("Codename of the content item"),
+        languageCodename: z.string().describe("Codename of the language variant to get")
+    }, async ({ itemCodename, languageCodename }) => {
+        const client = createMapiClient();
+        const response = await client
+            .viewLanguageVariant()
+            .byItemCodename(itemCodename)
+            .byLanguageCodename(languageCodename)
+            .toPromise();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response.data),
+                },
+            ],
+        };
+    });
+};

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

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

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

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

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

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

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@kontent-ai/mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start:stdio": "node build/stdioTransport.js",
+    "start:sse": "node build/sseTransport.js"
+  },
+  "bin": {
+    "stdio": "./build/stdioTransport.js",
+    "sse": "./build/sseTransport.js"
+  },
+  "files": [
+    "build"
+  ],
+  "keywords": [],
+  "author": "Jiri Lojda",
+  "license": "MIT",
+  "dependencies": {
+    "@kontent-ai/delivery-sdk": "^16.1.0",
+    "@kontent-ai/management-sdk": "^7.9.0",
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/node": "^22.14.1",
+    "typescript": "^5.8.3"
+  }
+}