@kontent-ai/mcp-server 0.7.0 → 0.8.1

package/build/server.js

@@ -7,6 +7,7 @@ import { registerTool as registerAddTaxonomyGroupMapi } from "./tools/add-taxono
 import { registerTool as registerDeleteContentItemMapi } from "./tools/delete-content-item-mapi.js";
 import { registerTool as registerDeleteLanguageVariantMapi } from "./tools/delete-language-variant-mapi.js";
 import { registerTool as registerGetAssetMapi } from "./tools/get-asset-mapi.js";
+import { registerTool as registerGetInitialContext } from "./tools/get-initial-context.js";
 import { registerTool as registerGetItemDapi } from "./tools/get-item-dapi.js";
 import { registerTool as registerGetItemMapi } from "./tools/get-item-mapi.js";
 import { registerTool as registerGetTaxonomyGroupMapi } from "./tools/get-taxonomy-group-mapi.js";
@@ -31,6 +32,7 @@ export const createServer = () => {
         },
     });
     // Register all tools
+    registerGetInitialContext(server);
     registerGetItemMapi(server);
     registerGetItemDapi(server);
     registerGetVariantMapi(server);

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

@@ -0,0 +1,64 @@
+export const initialContext = `
+# Kontent.ai Platform Guide
+
+Kontent.ai is a headless content management system (CMS) that provides two main APIs: the Management API for creating, updating, and deleting content and structure, and the Delivery API for retrieving content for applications.
+
+## Core Entities
+
+### Content Items
+Content items are language-neutral content containers that serve as the foundation for your content structure. Each content item has a unique identifier and codename, and references a specific content type. The key relationship to understand is that one content item can have multiple language variants.
+
+### Language Variants
+Language variants contain the actual language-specific content data including field values, workflow state, and language reference. Importantly, each variant is managed independently per language.
+
+### Content Types
+Content types define the structure and blueprint for language variants. They specify field definitions, validation rules, and element types that language variants will use. Think of them as templates that determine what fields and data types your language variants will have.
+
+### 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.
+
+## 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.
+
+## Working with Content Types Containing Snippets
+
+**CRITICAL**: When creating language variants for content types with snippets, you must:
+
+1. **Read the content type** to identify snippet elements (type: "snippet")
+2. **Retrieve each snippet definition** to understand its internal elements
+3. **Include ALL elements** from both the content type AND all snippets in the language variant
+
+Example: If a content type has direct elements (title, body) and a metadata snippet (meta_title, meta_description), your language variant must include ALL four elements.
+
+**Failure to include snippet elements will result in incomplete content creation.**
+
+## Operational Patterns
+
+### Content Creation Workflow
+1. Define content types (structure) - Create the blueprint for your content
+2. Create content items (containers) - Establish the content containers
+3. Add language variants (actual content) - Fill in the language-specific content
+4. Publish variants (make live) - Make content available through the Delivery API
+
+### Content Management Workflow
+- Update language variants with new content or changes
+- Manage workflow states as content progresses through its lifecycle
+- Create new language variants when expanding to additional languages
+- Organize with taxonomies for better content categorization
+
+## Essential Concepts
+
+**Taxonomies** provide hierarchical content categorization, allowing you to organize and tag content systematically.
+
+**Assets** are digital files including images, videos, and documents that can be referenced throughout your content.
+
+**Workflow states** manage the content lifecycle, tracking whether content is being drafted, is live, or has been archived.
+
+**Codenames** are human-readable unique identifiers that provide a consistent way to reference content programmatically.
+
+## Best Practices
+
+Use snippets for common field groups to maintain consistency and avoid duplication. Plan your content types before creating content to ensure proper structure. Use meaningful codenames consistently throughout your project for better maintainability. Leverage taxonomies for organization to create logical content hierarchies. Consider your multilingual strategy early in the planning process to avoid restructuring later.
+
+When working with snippets, always retrieve and understand the complete element structure before creating content variants.`;

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

@@ -1,15 +1,9 @@
-import { readFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { initialContext } from "./context/initial-context.js";
 export const registerTool = (server) => {
     server.tool("get-initial-context", "🚨 MANDATORY FIRST STEP: This tool MUST be called before using ANY other tools. It provides essential context, configuration, and operational guidelines for Kontent.ai. If you have not called this tool, do so immediately before proceeding with any other operation.", {}, async () => {
         try {
-            const markdownPath = join(__dirname, "./context/get-initial-context.md");
-            const kontentaiInstructions = await readFile(markdownPath, "utf-8");
-            return createMcpToolSuccessResponse(kontentaiInstructions);
+            return createMcpToolSuccessResponse(initialContext);
         }
         catch (error) {
             throw new Error(`Failed to read initial context: ${error instanceof Error ? error.message : "Unknown error"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "type": "module",
   "scripts": {
     "build": "rimraf build && tsc",