@kontent-ai/mcp-server 0.17.0 → 0.18.0

package/build/bin.js

@@ -4,16 +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 { extractBearerToken } from "./utils/extractBearerToken.js";
 import { isValidGuid } from "./utils/isValidGuid.js";
 const version = packageJson.version;
-async function startStreamableHTTP() {
+async function startStreamableHTTP(config) {
     const app = express();
     app.use(express.json());
     app.post("/mcp", async (req, res) => {
         try {
-            const { server } = createServer();
+            const { server } = createServer(config);
             const transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: undefined,
             });
@@ -68,7 +69,7 @@ async function startStreamableHTTP() {
                 });
                 return;
             }
-            const { server } = createServer();
+            const { server } = createServer(config);
             const transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: undefined,
             });
@@ -135,13 +136,14 @@ Available endpoints:
 /{environmentId}/mcp (requires Bearer authentication)`);
     });
 }
-async function startStdio() {
-    const { server } = createServer();
+async function startStdio(config) {
+    const { server } = createServer(config);
     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();
     const args = process.argv.slice(2);
     const transportType = args[0]?.toLowerCase();
     if (!transportType ||
@@ -150,10 +152,10 @@ async function main() {
         process.exit(1);
     }
     if (transportType === "stdio") {
-        await startStdio();
+        await startStdio(config);
     }
     else if (transportType === "shttp") {
-        await startStreamableHTTP();
+        await startStreamableHTTP(config);
     }
 }
 main().catch((error) => {

package/build/clients/kontentClients.js

@@ -6,9 +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
  * @returns Management API client instance
  */
-export const createMapiClient = (environmentId, apiKey) => {
+export const createMapiClient = (environmentId, apiKey, config) => {
     return createManagementClient({
         apiKey: apiKey ??
             process.env.KONTENT_API_KEY ??
@@ -22,5 +23,6 @@ export const createMapiClient = (environmentId, apiKey) => {
                 value: `${packageJson.name};${packageJson.version}`,
             },
         ],
+        baseUrl: config ? `${config.manageApiUrl}v2` : undefined,
     });
 };

package/build/config/appConfiguration.js

@@ -0,0 +1,51 @@
+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 },
+            { keyFilter: "Deliver:ApiClient:Domains:*", labelFilter: label },
+        ]);
+        const credential = new DefaultAzureCredential();
+        const configMap = await load(appConfigEndpoint, credential, {
+            selectors: selectors,
+            keyVaultOptions: {
+                credential: credential,
+            },
+        });
+        return {
+            manageApiUrl: getConfigValue(configMap, "Draft:ManageApi:Url"),
+            deliveryApiUrl: getConfigValue(configMap, "Deliver:ApiClient:Domains:LiveContentDomain"),
+        };
+    }
+    catch (error) {
+        console.log("Failed to load App Configuration:", error);
+        return null;
+    }
+}

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 = () => {
+export const createServer = (config) => {
     const server = new McpServer({
         name: "kontent-ai",
         version: packageJson.version,
@@ -41,33 +41,33 @@ export const createServer = () => {
     });
     // Register all tools
     registerGetInitialContext(server);
-    registerGetItemMapi(server);
-    registerGetItemDapi(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);
-    registerPublishVariantMapi(server);
-    registerUnpublishVariantMapi(server);
+    registerGetItemMapi(server, config);
+    registerGetItemDapi(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);
+    registerPublishVariantMapi(server, config);
+    registerUnpublishVariantMapi(server, config);
     return { server };
 };

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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .optional()
             .describe("Array of content groups (optional)"),
     }, async ({ name, codename, external_id, elements, content_groups }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .deleteLanguageVariant()

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

@@ -2,7 +2,7 @@ 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) => {
+export const registerTool = (server, config) => {
     server.tool("filter-variants-mapi", "Search and filter Kontent.ai language variants of content items using Management API", 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 } = {} }) => {
         try {
             const requestPayload = {
@@ -31,7 +31,10 @@ export const registerTool = (server) => {
             if (!apiKey) {
                 throwError("Missing required API key");
             }
-            const url = `https://manage.kontent.ai/v2/projects/${environmentId}/early-access/variants/filter`;
+            const baseUrl = config
+                ? `${config.manageApiUrl}`
+                : `https://manage.kontent.ai/`;
+            const url = `${baseUrl}v2/projects/${environmentId}/early-access/variants/filter`;
             const headers = {
                 Authorization: `Bearer ${apiKey}`,
                 "Content-Type": "application/json",

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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client
                 .viewAsset()

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

@@ -2,7 +2,7 @@ import { createDeliveryClient } from "@kontent-ai/delivery-sdk";
 import { z } from "zod";
 import { handleMcpToolError } from "../utils/errorHandler.js";
 import { createMcpToolSuccessResponse } from "../utils/responseHelper.js";
-export const registerTool = (server) => {
+export const registerTool = (server, config) => {
     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
@@ -11,6 +11,9 @@ export const registerTool = (server) => {
     }, async ({ codename, environmentId }) => {
         const client = createDeliveryClient({
             environmentId,
+            proxy: {
+                baseUrl: config ? `https://${config.deliveryApiUrl}` : undefined,
+            },
         });
         try {
             const response = await client.item(codename).toPromise();

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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     server.tool("list-assets-mapi", "Get all Kontent.ai assets from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listAssets().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listContentTypeSnippets().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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) => {
+export const registerTool = (server, config) => {
     server.tool("list-content-types-mapi", "Get all Kontent.ai content types from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listContentTypes().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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) => {
+export const registerTool = (server, config) => {
     server.tool("list-languages-mapi", "Get all Kontent.ai languages from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listLanguages().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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) => {
+export const registerTool = (server, config) => {
     server.tool("list-taxonomy-groups-mapi", "Get all Kontent.ai taxonomy groups from Management API", {}, async (_, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listTaxonomies().toAllPromise();
             return createMcpToolSuccessResponse(response.data);

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) => {
+export const registerTool = (server, config) => {
     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);
+        const client = createMapiClient(clientId, token, config);
         try {
             const response = await client.listWorkflows().toPromise();
             return createMcpToolSuccessResponse(response.data);

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) => {
+export const registerTool = (server, config) => {
     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) => {
         - 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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         try {
             // Validate that displayTimezone can only be used with scheduledTo
             if (displayTimezone && !scheduledTo) {

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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .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);
+        const client = createMapiClient(clientId, token, config);
         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) => {
+export const registerTool = (server, config) => {
     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) => {
             .optional()
             .describe("Internal ID of the workflow step (optional)"),
     }, async ({ itemId, languageId, elements, workflow_step_id }, { authInfo: { token, clientId } = {} }) => {
-        const client = createMapiClient(clientId, token);
+        const client = createMapiClient(clientId, token, config);
         const data = {
             elements,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kontent-ai/mcp-server",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "scripts": {
     "build": "rimraf build && tsc",
@@ -21,9 +21,13 @@
   "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/delivery-sdk": "^16.2.0",
     "@kontent-ai/management-sdk": "^7.9.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "applicationinsights": "^2.9.8",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "zod": "^3.25.30"