@kontent-ai/mcp-server 0.19.0 → 0.21.0

package/README.md

@@ -91,7 +91,7 @@ npx @kontent-ai/mcp-server@latest shttp
 * **upsert-language-variant-mapi** – Create or update Kontent.ai language variant of a content item via Management API. This adds actual content to the content item elements. When updating an existing variant, only the provided elements will be modified
 * **create-variant-version-mapi** – Create new version of Kontent.ai language variant via Management API. This operation creates a new version of an existing language variant, useful for content versioning and creating new drafts from published content
 * **delete-language-variant-mapi** – Delete Kontent.ai language variant from Management API
-* **filter-variants-mapi** – Filter Kontent.ai language variants of content items using Management API. Use for exact keyword matching and finding specific terms in content. Supports full filtering capabilities (content types, workflow steps, taxonomies, etc.)
+* **filter-variants-mapi** – Filter Kontent.ai language variants of content items using Management API. Use for exact keyword matching and finding specific terms in content. Supports full filtering capabilities (content types, workflow steps, taxonomies, etc.) and optionally includes full content of variants
 * **search-variants-mapi** – AI-powered semantic search for finding content by meaning and concepts in a specific language variant. Use for: conceptual searches when you don't know exact keywords. Limited filtering options (variant ID only)
 
 ### Asset Management
@@ -123,6 +123,9 @@ For single-tenant mode, configure environment variables:
 | KONTENT_API_KEY | Your Kontent.ai Management API key | ✅ |
 | KONTENT_ENVIRONMENT_ID | Your environment ID | ✅ |
 | PORT | Port for HTTP transport (defaults to 3001) | ❌ |
+| appInsightsConnectionString | Application Insights connection string for telemetry | ❌ |
+| projectLocation | Project location identifier for telemetry tracking | ❌ |
+| manageApiUrl | Custom Management API base URL (for preview environments) | ❌ |
 
 ### Multi-Tenant Mode
 

package/build/bin.js

@@ -4,18 +4,17 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import "dotenv/config";
 import express from "express";
 import packageJson from "../package.json" with { type: "json" };
-import { loadAppConfiguration, } from "./config/appConfiguration.js";
 import { createServer } from "./server.js";
 import { initializeApplicationInsights, trackException, trackServerStartup, } from "./telemetry/applicationInsights.js";
 import { extractBearerToken } from "./utils/extractBearerToken.js";
 import { isValidGuid } from "./utils/isValidGuid.js";
 const version = packageJson.version;
-async function startStreamableHTTP(config) {
+async function startStreamableHTTP() {
     const app = express();
     app.use(express.json());
     app.post("/mcp", async (req, res) => {
         try {
-            const { server } = createServer(config);
+            const { server } = createServer();
             const transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: undefined,
             });
@@ -71,7 +70,7 @@ async function startStreamableHTTP(config) {
                 });
                 return;
             }
-            const { server } = createServer(config);
+            const { server } = createServer();
             const transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: undefined,
             });
@@ -143,18 +142,15 @@ Available endpoints:
 /{environmentId}/mcp (requires Bearer authentication)`);
     });
 }
-async function startStdio(config) {
-    const { server } = createServer(config);
+async function startStdio() {
+    const { server } = createServer();
     const transport = new StdioServerTransport();
     console.log(`Kontent.ai MCP Server v${version} (stdio) starting`);
     await server.connect(transport);
 }
 async function main() {
-    const config = await loadAppConfiguration();
-    if (config) {
-        initializeApplicationInsights(config);
-        trackServerStartup(version);
-    }
+    initializeApplicationInsights();
+    trackServerStartup(version);
     const args = process.argv.slice(2);
     const transportType = args[0]?.toLowerCase();
     if (!transportType ||
@@ -163,10 +159,10 @@ async function main() {
         process.exit(1);
     }
     if (transportType === "stdio") {
-        await startStdio(config);
+        await startStdio();
     }
     else if (transportType === "shttp") {
-        await startStreamableHTTP(config);
+        await startStreamableHTTP();
     }
 }
 main().catch((error) => {

package/build/clients/kontentClients.js

@@ -6,11 +6,10 @@ const sourceTrackingHeaderName = "X-KC-SOURCE";
  * 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)
- * @param config Optional configuration object
  * @param additionalHeaders Optional additional headers to include in requests
  * @returns Management API client instance
  */
-export const createMapiClient = (environmentId, apiKey, config, additionalHeaders) => {
+export const createMapiClient = (environmentId, apiKey, additionalHeaders) => {
     const allHeaders = [
         {
             header: sourceTrackingHeaderName,
@@ -18,6 +17,7 @@ export const createMapiClient = (environmentId, apiKey, config, additionalHeader
         },
         ...(additionalHeaders || []),
     ];
+    const manageApiUrl = process.env.manageApiUrl;
     return createManagementClient({
         apiKey: apiKey ??
             process.env.KONTENT_API_KEY ??
@@ -25,7 +25,7 @@ export const createMapiClient = (environmentId, apiKey, config, additionalHeader
         environmentId: environmentId ??
             process.env.KONTENT_ENVIRONMENT_ID ??
             throwError("KONTENT_ENVIRONMENT_ID is not set"),
-        baseUrl: config ? `${config.manageApiUrl}v2` : undefined,
+        baseUrl: manageApiUrl ? `${manageApiUrl}v2` : undefined,
         headers: allHeaders,
     });
 };

package/build/schemas/filterVariantSchemas.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import { referenceObjectSchema } from "./referenceObjectSchema.js";
-const userReferenceSchema = z.object({
-    id: z.string().optional().describe("User identifier"),
-    email: z.string().email().optional().describe("User email address"),
-});
+// UserReferenceDataContract is a union type - either id or email, but not both
+const userReferenceSchema = z
+    .union([
+    z.object({
+        id: z.string().describe("User identifier"),
+        email: z.never().optional(),
+    }),
+    z.object({
+        id: z.never().optional(),
+        email: z.string().email().describe("User email address"),
+    }),
+])
+    .describe("Reference to a user by either their id or email (but not both)");
 // Search variants tool input schema
 export const filterVariantsSchema = z.object({
     search_phrase: z
@@ -19,13 +28,13 @@ export const filterVariantsSchema = z.object({
         .array(userReferenceSchema)
         .min(1)
         .optional()
-        .describe("Array of references to users by their id or email"),
+        .describe("Array of references to users by their id or email (but not both per user)"),
     has_no_contributors: z
         .boolean()
         .optional()
         .describe("Filter for content item language variants that have no contributors assigned"),
     completion_statuses: z
-        .array(z.enum(["unfinished", "completed", "not_translated", "all_done"]))
+        .array(z.enum(["unfinished", "ready", "not_translated", "all_done"]))
         .min(1)
         .optional()
         .describe("Array of completion statuses to filter by. It is not the same thing as workflow steps, it reflects e.g. not filled in required elements"),
@@ -48,24 +57,26 @@ export const filterVariantsSchema = z.object({
         taxonomy_identifier: referenceObjectSchema.describe("Reference to a taxonomy group by its id, codename, or external id"),
         term_identifiers: z
             .array(referenceObjectSchema)
+            .optional()
             .describe("Array of references to taxonomy terms by their id, codename, or external id"),
         include_uncategorized: z
             .boolean()
+            .optional()
             .describe("Whether to include content item language variants that don't have any taxonomy terms assigned in this taxonomy group"),
     }))
         .min(1)
         .optional()
         .describe("Array of taxonomy groups with taxonomy terms"),
     order_by: z
-        .enum(["name", "due", "last_modified"])
+        .enum(["name", "due_date", "last_modified"])
         .optional()
         .describe("Field to order by"),
     order_direction: z
         .enum(["asc", "desc"])
         .optional()
         .describe("Order direction"),
-    continuation_token: z
-        .string()
+    include_content: z
+        .boolean()
         .optional()
-        .describe("Continuation token for pagination"),
+        .describe("Whether to include the full content of language variants in the response"),
 });

package/build/server.js

@@ -30,7 +30,7 @@ import { registerTool as registerUnpublishVariantMapi } from "./tools/unpublish-
 import { registerTool as registerUpdateContentItemMapi } from "./tools/update-content-item-mapi.js";
 import { registerTool as registerUpsertLanguageVariantMapi } from "./tools/upsert-language-variant-mapi.js";
 // Create server instance
-export const createServer = (config) => {
+export const createServer = () => {
     const server = new McpServer({
         name: "kontent-ai",
         version: packageJson.version,
@@ -41,33 +41,33 @@ export const createServer = (config) => {
     });
     // Register all tools
     registerGetInitialContext(server);
-    registerGetItemMapi(server, config);
-    registerGetVariantMapi(server, config);
-    registerGetTypeMapi(server, config);
-    registerListContentTypesMapi(server, config);
-    registerDeleteContentTypeMapi(server, config);
-    registerListLanguagesMapi(server, config);
-    registerGetAssetMapi(server, config);
-    registerListAssetsMapi(server, config);
-    registerAddContentTypeMapi(server, config);
-    registerPatchContentTypeMapi(server, config);
-    registerAddContentTypeSnippetMapi(server, config);
-    registerGetTypeSnippetMapi(server, config);
-    registerListContentTypeSnippetsMapi(server, config);
-    registerAddTaxonomyGroupMapi(server, config);
-    registerListTaxonomyGroupsMapi(server, config);
-    registerGetTaxonomyGroupMapi(server, config);
-    registerAddContentItemMapi(server, config);
-    registerUpdateContentItemMapi(server, config);
-    registerDeleteContentItemMapi(server, config);
-    registerUpsertLanguageVariantMapi(server, config);
-    registerCreateVariantVersionMapi(server, config);
-    registerDeleteLanguageVariantMapi(server, config);
-    registerListWorkflowsMapi(server, config);
-    registerChangeVariantWorkflowStepMapi(server, config);
-    registerFilterVariantsMapi(server, config);
-    registerSearchVariantsMapi(server, config);
-    registerPublishVariantMapi(server, config);
-    registerUnpublishVariantMapi(server, config);
+    registerGetItemMapi(server);
+    registerGetVariantMapi(server);
+    registerGetTypeMapi(server);
+    registerListContentTypesMapi(server);
+    registerDeleteContentTypeMapi(server);
+    registerListLanguagesMapi(server);
+    registerGetAssetMapi(server);
+    registerListAssetsMapi(server);
+    registerAddContentTypeMapi(server);
+    registerPatchContentTypeMapi(server);
+    registerAddContentTypeSnippetMapi(server);
+    registerGetTypeSnippetMapi(server);
+    registerListContentTypeSnippetsMapi(server);
+    registerAddTaxonomyGroupMapi(server);
+    registerListTaxonomyGroupsMapi(server);
+    registerGetTaxonomyGroupMapi(server);
+    registerAddContentItemMapi(server);
+    registerUpdateContentItemMapi(server);
+    registerDeleteContentItemMapi(server);
+    registerUpsertLanguageVariantMapi(server);
+    registerCreateVariantVersionMapi(server);
+    registerDeleteLanguageVariantMapi(server);
+    registerListWorkflowsMapi(server);
+    registerChangeVariantWorkflowStepMapi(server);
+    registerFilterVariantsMapi(server);
+    registerSearchVariantsMapi(server);
+    registerPublishVariantMapi(server);
+    registerUnpublishVariantMapi(server);
     return { server };
 };

package/build/telemetry/applicationInsights.js

@@ -1,9 +1,12 @@
 import { SharedModels } from "@kontent-ai/management-sdk";
 import appInsights from "applicationinsights";
-import { AxiosError } from "axios";
 import { sanitizeTelemetry, sanitizeUrl } from "./telemetrySanitizer.js";
 let isInitialized = false;
 function trackKontentApiError(error, context) {
+    if (error.validationErrors && error.validationErrors.length > 0) {
+        // Don't log 400 responses as exceptions
+        return;
+    }
     const safeError = new Error(error.message);
     safeError.stack = error.originalError.stack || safeError.stack;
     appInsights.defaultClient.trackException({
@@ -87,7 +90,7 @@ export function trackException(error, context) {
             trackKontentApiError(error, context);
             return;
         }
-        if (error instanceof AxiosError) {
+        if (error.isAxiosError) {
             trackHttpError(error, context);
             return;
         }
@@ -118,7 +121,7 @@ export function trackServerStartup(version) {
         // Silently fail - tracking should never break the application
     }
 }
-function createTelemetryProcessor(config) {
+function createTelemetryProcessor() {
     return (envelope) => {
         sanitizeTelemetry(envelope);
         if (envelope.data?.baseData) {
@@ -126,18 +129,19 @@ function createTelemetryProcessor(config) {
                 envelope.data.baseData.properties || {};
             envelope.data.baseData.properties["component.name"] = "mcp-server";
             envelope.data.baseData.properties["component.location"] =
-                config.projectLocation || "unknown";
+                process.env.projectLocation || "unknown";
         }
         return true;
     };
 }
-export function initializeApplicationInsights(config) {
+export function initializeApplicationInsights() {
     try {
-        if (!config?.applicationInsightsConnectionString) {
+        const connectionString = process.env.appInsightsConnectionString;
+        if (!connectionString) {
             return;
         }
         appInsights
-            .setup(config.applicationInsightsConnectionString)
+            .setup(connectionString)
             .setAutoCollectExceptions(true)
             .setAutoCollectRequests(true)
             .setAutoCollectConsole(false)
@@ -149,7 +153,7 @@ export function initializeApplicationInsights(config) {
             .setAutoCollectPreAggregatedMetrics(false)
             .start();
         isInitialized = true;
-        appInsights.defaultClient.addTelemetryProcessor(createTelemetryProcessor(config));
+        appInsights.defaultClient.addTelemetryProcessor(createTelemetryProcessor());
     }
     catch (error) {
         console.log("Failed to initialize Application Insights:", error);

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

@@ -2,7 +2,7 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("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.", {
         name: z
             .string()
@@ -33,7 +33,7 @@ export const registerTool = (server, config) => {
             .optional()
             .describe("Reference to a collection by id, codename, or external_id (optional)"),
     }, async ({ name, type, codename, external_id, collection }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .addContentItem()

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

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { contentGroupSchema, elementSchema, } from "../schemas/contentTypeSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("add-content-type-mapi", "Add new Kontent.ai content type via Management API", {
         name: z.string().describe("Display name of the content type"),
         codename: z
@@ -22,7 +22,7 @@ export const registerTool = (server, config) => {
             .optional()
             .describe("Array of content groups (optional)"),
     }, async ({ name, codename, external_id, elements, content_groups }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .addContentType()

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

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { snippetElementSchema } from "../schemas/contentTypeSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("add-content-type-snippet-mapi", "Add new Kontent.ai content type snippet via Management API", {
         name: z.string().describe("Display name of the content type snippet"),
         codename: z
@@ -18,7 +18,7 @@ export const registerTool = (server, config) => {
             .array(snippetElementSchema)
             .describe("Array of elements that define the structure of the content type snippet"),
     }, async ({ name, codename, external_id, elements }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .addContentTypeSnippet()

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

@@ -2,9 +2,9 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { taxonomyGroupSchemas } from "../schemas/taxonomySchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("add-taxonomy-group-mapi", "Add new Kontent.ai taxonomy group via Management API", taxonomyGroupSchemas, async (taxonomyGroup, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .addTaxonomy()

package/build/tools/change-variant-workflow-step-mapi.js

@@ -2,7 +2,7 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("change-variant-workflow-step-mapi", "Change the workflow step of a language variant in Kontent.ai. This operation moves a language variant to a different step in the workflow, enabling content lifecycle management such as moving content from draft to review, review to published, etc.", {
         itemId: z
             .string()
@@ -21,7 +21,7 @@ export const registerTool = (server, config) => {
             .uuid()
             .describe("Internal ID (UUID) of the target workflow step. This must be a valid step ID from the specified workflow. Common steps include Draft, Review, Published, and Archived, but the actual IDs depend on your specific workflow configuration"),
     }, async ({ itemId, languageId, workflowId, workflowStepId }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .changeWorkflowOfLanguageVariant()

package/build/tools/create-variant-version-mapi.js

@@ -2,7 +2,7 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("create-variant-version-mapi", "Create new version of Kontent.ai language variant via Management API. This operation creates a new version of an existing language variant, useful for content versioning and creating new drafts from published content.", {
         itemId: z
             .string()
@@ -13,7 +13,7 @@ export const registerTool = (server, config) => {
             .uuid()
             .describe("Internal ID (UUID) of the language variant to create a new version of. Use '00000000-0000-0000-0000-000000000000' for the default language"),
     }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .createNewVersionOfLanguageVariant()

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

@@ -2,11 +2,11 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("delete-content-item-mapi", "Delete Kontent.ai content item by internal ID from Management API", {
         id: z.string().describe("Internal ID of the content item to delete"),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .deleteContentItem()

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

@@ -2,11 +2,11 @@ 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, config) => {
+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 }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .deleteContentType()

package/build/tools/delete-language-variant-mapi.js

@@ -2,14 +2,14 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("delete-language-variant-mapi", "Delete Kontent.ai language variant from Management API", {
         itemId: z.string().describe("Internal ID of the content item"),
         languageId: z
             .string()
             .describe("Internal ID of the language variant to delete"),
     }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .deleteLanguageVariant()

package/build/tools/filter-variants-mapi.js

@@ -3,24 +3,24 @@ import { filterVariantsSchema } from "../schemas/filterVariantSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 import { throwError } from "../utils/throwError.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("filter-variants-mapi", `Filter Kontent.ai language variants of content items using Management API.
-    
+
     USE FOR:
     - EXACT keyword matching: finding specific words, phrases, names, codes, or IDs in content. Example: 'find items containing rabbit' → search 'rabbit'
     - Advanced filtering by content type, contributors, workflow steps, taxonomies etc
     - CAN expand concepts to keywords when using filter (e.g., "neurology-related" → "neurology neurological brain nervous system")
-    - Also use as fallback when AI search is unavailable`, filterVariantsSchema.shape, async ({ search_phrase, content_types, contributors, has_no_contributors, completion_statuses, language, workflow_steps, taxonomy_groups, order_by, order_direction, continuation_token, }, { authInfo: { token, clientId } = {} }) => {
+    - Also use as fallback when AI search is unavailable
+    - Optionally includes full content of variants with include_content parameter`, filterVariantsSchema.shape, async ({ search_phrase, content_types, contributors, has_no_contributors, completion_statuses, language, workflow_steps, taxonomy_groups, order_by, order_direction, include_content, }, { authInfo: { token, clientId } = {} }) => {
         try {
             const environmentId = clientId ?? process.env.KONTENT_ENVIRONMENT_ID;
             if (!environmentId) {
                 throwError("Missing required environment ID");
             }
-            const additionalHeaders = continuation_token
-                ? [{ header: "X-Continuation", value: continuation_token }]
-                : undefined;
-            const client = createMapiClient(environmentId, token, config, additionalHeaders);
-            const requestPayload = {
+            const client = createMapiClient(environmentId, token);
+            const response = await client.earlyAccess
+                .filterLanguageVariants()
+                .withData({
                 filters: {
                     search_phrase,
                     content_types,
@@ -34,19 +34,16 @@ export const registerTool = (server, config) => {
                 order: order_by
                     ? {
                         by: order_by,
-                        direction: order_direction === "desc" ? "Descending" : "Ascending",
+                        direction: order_direction || "asc",
                     }
-                    : null,
-            };
-            const response = await client
-                .post()
-                .withAction(`projects/${environmentId}/early-access/variants/filter`)
-                .withData(requestPayload)
-                .toPromise();
-            return createMcpToolSuccessResponse(response.data);
+                    : undefined,
+                include_content: include_content ?? false,
+            })
+                .toAllPromise();
+            return createMcpToolSuccessResponse(response.responses.flatMap((r) => r.rawData.data));
         }
         catch (error) {
-            return handleMcpToolError(error, "Variant Search");
+            return handleMcpToolError(error, "Variant Filter");
         }
     });
 };

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

@@ -2,11 +2,11 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("get-asset-mapi", "Get a specific Kontent.ai asset by internal ID from Management API", {
         assetId: z.string().describe("Internal ID of the asset to retrieve"),
     }, async ({ assetId }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .viewAsset()

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

@@ -2,11 +2,11 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("get-item-mapi", "Get Kontent.ai item by internal ID from Management API", {
         id: z.string().describe("Internal ID of the item to get"),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .viewContentItem()

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

@@ -2,11 +2,11 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("get-taxonomy-group-mapi", "Get Kontent.ai taxonomy group by internal ID from Management API", {
         id: z.string().describe("Internal ID of the taxonomy group to get"),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .getTaxonomy()

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

@@ -2,11 +2,11 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("get-type-mapi", "Get Kontent.ai content type by internal ID from Management API", {
         id: z.string().describe("Internal ID of the content type to get"),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .viewContentType()

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

@@ -2,11 +2,11 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("get-type-snippet-mapi", "Get Kontent.ai content type snippet by internal ID from Management API", {
         id: z.string().describe("Internal ID of the content type snippet to get"),
     }, async ({ id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .viewContentTypeSnippet()

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

@@ -2,14 +2,14 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("get-variant-mapi", "Get Kontent.ai language variant of content item from Management API", {
         itemId: z.string().describe("Internal ID of the content item"),
         languageId: z
             .string()
             .describe("Internal ID of the language variant to get"),
     }, async ({ itemId, languageId }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client
                 .viewLanguageVariant()

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

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("list-assets-mapi", "Get all Kontent.ai assets from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listAssets().toAllPromise();
             const rawData = response.responses.flatMap((r) => r.rawData.assets);

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

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("list-content-type-snippets-mapi", "Get all Kontent.ai content type snippets from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listContentTypeSnippets().toAllPromise();
             const rawData = response.responses.flatMap((r) => r.rawData.snippets);

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

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("list-content-types-mapi", "Get all Kontent.ai content types from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listContentTypes().toAllPromise();
             const rawData = response.responses.flatMap((r) => r.rawData.types);

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

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("list-languages-mapi", "Get all Kontent.ai languages from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listLanguages().toAllPromise();
             const rawData = response.responses.flatMap((r) => r.rawData.languages);

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

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("list-taxonomy-groups-mapi", "Get all Kontent.ai taxonomy groups from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listTaxonomies().toAllPromise();
             const rawData = response.responses.flatMap((r) => r.rawData.taxonomies);

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

@@ -1,9 +1,9 @@
 import { createMapiClient } from "../clients/kontentClients.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("list-workflows-mapi", "Get all Kontent.ai workflows from Management API. Workflows define the content lifecycle stages and transitions between them.", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             const response = await client.listWorkflows().toPromise();
             return createMcpToolSuccessResponse(response.rawData);

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

@@ -3,7 +3,7 @@ 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, config) => {
+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).
@@ -55,7 +55,7 @@ export const registerTool = (server, config) => {
         - 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 }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             // Apply patch operations using the modifyContentType method
             const response = await client

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

@@ -2,7 +2,7 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("publish-variant-mapi", "Publish or schedule a language variant of a content item in Kontent.ai. This operation can either immediately publish the variant (publishing happens right now) or schedule it for publication at a specific future date and time. For immediate publishing: the variant is published immediately and becomes available through the Delivery API. For scheduled publishing: the variant moves to a 'Scheduled' workflow state and will automatically transition to 'Published' at the specified time. The variant must be in a valid state with all required fields filled and validation rules satisfied. A variant can only be published if a transition is defined between the variant's current workflow step and the Published workflow step.", {
         itemId: z
             .string()
@@ -22,7 +22,7 @@ export const registerTool = (server, config) => {
             .optional()
             .describe("The timezone identifier for displaying the scheduled time in the Kontent.ai UI (e.g., 'America/New_York', 'Europe/London', 'UTC'). This parameter is used for scheduled publishing to specify the timezone context for the scheduled_to parameter. If not provided, the system will use the default timezone. This helps content creators understand when content will be published in their local context."),
     }, async ({ itemId, languageId, scheduledTo, displayTimezone }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

package/build/tools/search-variants-mapi.js

@@ -1,10 +1,10 @@
-import pRetry from "p-retry";
+import pRetry, { AbortError } from "p-retry";
 import { createMapiClient } from "../clients/kontentClients.js";
 import { searchOperationSchema } from "../schemas/searchOperationSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
 import { throwError } from "../utils/throwError.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("search-variants-mapi", `AI-powered semantic search for finding Kontent.ai content by meaning, concepts, themes, and content similarity in a specific language variant. This tool uses vector database and AI to enable searching by meaning and similarity rather than exact keyword matching.
     
     CRITICAL REQUIREMENTS:
@@ -25,7 +25,7 @@ export const registerTool = (server, config) => {
             if (!environmentId) {
                 throwError("Missing required environment ID");
             }
-            const client = createMapiClient(environmentId, token, config);
+            const client = createMapiClient(environmentId, token);
             // Step 1: Initiate the AI search operation
             const searchPayload = {
                 actionName: "Search",
@@ -66,27 +66,29 @@ export const registerTool = (server, config) => {
             const operationId = operationData.operationId;
             // Step 2: Poll for results with exponential backoff
             const resultData = await pRetry(async () => {
-                const pollResponse = await client
-                    .get()
-                    .withAction(`projects/${environmentId}/early-access/ai-operation/${operationId}`)
-                    .toPromise();
-                const data = pollResponse.data;
-                if (data.message.includes("still in progress")) {
-                    throw new Error("Operation still in progress");
+                try {
+                    const pollResponse = await client
+                        .get()
+                        .withAction(`projects/${environmentId}/early-access/ai-operation-result/${operationId}`)
+                        .toPromise();
+                    return pollResponse.data;
+                }
+                catch (error) {
+                    if (error?.response?.status === 404) {
+                        throw new Error("Operation result not available yet. Retrying.");
+                    }
+                    throw new AbortError(error);
                 }
-                return data;
             }, {
+                // Worst-case retry time: ~1 minute
                 retries: 10,
                 minTimeout: 1000,
                 maxTimeout: 10000,
                 factor: 1.5,
             });
-            if (resultData.message.includes("completed successfully")) {
-                return createMcpToolSuccessResponse({
-                    result: resultData.result,
-                });
-            }
-            throw new Error(`Search operation error: ${resultData.message}. Operation ID: ${operationId}`);
+            return createMcpToolSuccessResponse({
+                result: resultData,
+            });
         }
         catch (error) {
             return handleMcpToolError(error, "AI-powered Variant Search");

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

@@ -2,7 +2,7 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("unpublish-variant-mapi", "Unpublish or schedule unpublishing of a language variant of a content item in Kontent.ai. This operation can either immediately unpublish the variant (making it unavailable through the Delivery API) or schedule it for unpublishing at a specific future date and time. For immediate unpublishing: the variant is unpublished right away and moves to the 'Archived' workflow step, becoming unavailable through the Delivery API. For scheduled unpublishing: the variant remains published but is scheduled to be automatically unpublished at the specified time. The variant must currently be in the 'Published' state for this operation to succeed.", {
         itemId: z
             .string()
@@ -22,7 +22,7 @@ export const registerTool = (server, config) => {
             .optional()
             .describe("The timezone identifier for displaying the scheduled time in the Kontent.ai UI (e.g., 'America/New_York', 'Europe/London', 'UTC'). This parameter is used for scheduled unpublishing to specify the timezone context for the scheduled_to parameter. If not provided, the system will use the default timezone. This helps content creators understand when content will be unpublished in their local context."),
     }, async ({ itemId, languageId, scheduledTo, displayTimezone }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

package/build/tools/update-content-item-mapi.js

@@ -2,7 +2,7 @@ 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, config) => {
+export const registerTool = (server) => {
     server.tool("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.", {
         id: z.string().describe("Internal ID of the content item to update"),
         name: z
@@ -20,7 +20,7 @@ export const registerTool = (server, config) => {
             .optional()
             .describe("Reference to a collection by id, codename, or external_id (optional)"),
     }, async ({ id, name, collection }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         try {
             // First, verify the item exists by trying to get it
             await client.viewContentItem().byItemId(id).toPromise();

package/build/tools/upsert-language-variant-mapi.js

@@ -3,7 +3,7 @@ import { createMapiClient } from "../clients/kontentClients.js";
 import { languageVariantElementSchema } from "../schemas/contentItemSchemas.js";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server, config) => {
+export const registerTool = (server) => {
     server.tool("upsert-language-variant-mapi", "Create or update Kontent.ai language variant of a content item via Management API. This adds actual content to the content item elements. When updating an existing variant, only the provided elements will be modified.", {
         itemId: z.string().describe("Internal ID of the content item"),
         languageId: z
@@ -17,7 +17,7 @@ export const registerTool = (server, config) => {
             .optional()
             .describe("Internal ID of the workflow step (optional)"),
     }, async ({ itemId, languageId, elements, workflow_step_id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token, config);
+        const client = createMapiClient(clientId, token);
         const data = {
             elements,
         };

package/build/utils/errorHandler.js

@@ -46,12 +46,23 @@ export const handleMcpToolError = (error, context) => {
         };
     }
     // Handle network or other HTTP errors
-    if (error?.response) {
+    if (error.isAxiosError) {
+        if (error.response) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${contextPrefix}HTTP Error ${error?.response?.status}: ${error?.response?.statusText || "Unknown HTTP error"}\n\nResponse: ${JSON.stringify(error?.response?.data)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
         return {
             content: [
                 {
                     type: "text",
-                    text: `${contextPrefix}HTTP Error ${error.response.status}: ${error.response.statusText || "Unknown HTTP error"}\n\nResponse: ${JSON.stringify(error.response.data)}`,
+                    text: `${contextPrefix}HTTP Error ${error.message}`,
                 },
             ],
             isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "type": "module",
   "scripts": {
     "build": "rimraf build && tsc",
@@ -8,8 +8,8 @@
     "start:shttp": "node build/bin.js shttp",
     "dev:stdio": "tsx watch src/bin.ts stdio",
     "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"
+    "format": "cross-env node node_modules/@biomejs/biome/bin/biome ci ./",
+    "format:fix": "cross-env node node_modules/@biomejs/biome/bin/biome check ./ --fix --unsafe"
   },
   "bin": {
     "@kontent-ai/mcp-server": "./build/bin.js"
@@ -21,10 +21,7 @@
   "author": "Jiri Lojda",
   "license": "MIT",
   "dependencies": {
-    "@azure/app-configuration": "^1.9.0",
-    "@azure/app-configuration-provider": "^2.2.0",
-    "@azure/identity": "^4.11.1",
-    "@kontent-ai/management-sdk": "^7.9.0",
+    "@kontent-ai/management-sdk": "^7.11.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
     "applicationinsights": "^2.9.8",
     "dotenv": "^16.5.0",

package/build/config/appConfiguration.js

@@ -1,51 +0,0 @@
-import { load } from "@azure/app-configuration-provider";
-import { DefaultAzureCredential } from "@azure/identity";
-function loadIndexedEnvVars(prefix) {
-    const values = [];
-    let index = 0;
-    while (true) {
-        const envVar = process.env[`${prefix}__${index}`];
-        if (!envVar)
-            break;
-        const trimmed = envVar.trim();
-        if (trimmed) {
-            values.push(trimmed);
-        }
-        index++;
-    }
-    return values;
-}
-function getConfigValue(configMap, key) {
-    const value = configMap.get(key);
-    return value && typeof value === "string" ? value : undefined;
-}
-export async function loadAppConfiguration() {
-    try {
-        const appConfigEndpoint = process.env.ConfigStore__Endpoints__0;
-        const labels = loadIndexedEnvVars("ConfigStore__Labels");
-        if (!appConfigEndpoint || labels.length === 0) {
-            return null;
-        }
-        const selectors = labels.flatMap((label) => [
-            { keyFilter: "ApplicationInsights:*", labelFilter: label },
-            { keyFilter: "Global:Runtime:*", labelFilter: label },
-            { keyFilter: "Draft:ManageApi:*", labelFilter: label },
-        ]);
-        const credential = new DefaultAzureCredential();
-        const configMap = await load(appConfigEndpoint, credential, {
-            selectors: selectors,
-            keyVaultOptions: {
-                credential: credential,
-            },
-        });
-        return {
-            applicationInsightsConnectionString: getConfigValue(configMap, "ApplicationInsights:ConnectionString"),
-            projectLocation: getConfigValue(configMap, "Global:Runtime:ProjectLocation"),
-            manageApiUrl: getConfigValue(configMap, "Draft:ManageApi:Url"),
-        };
-    }
-    catch (error) {
-        console.log("Failed to load App Configuration:", error);
-        return null;
-    }
-}