@pagopa/dx-mcpserver 0.0.12 → 0.1.1

package/dist/config/__tests__/constants.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { API_TIMEOUT, DEFAULT_PAGE_SIZE, MAX_RESULTS } from "../constants.js";
+describe("Server Constants", () => {
+    describe("API_TIMEOUT", () => {
+        it("should be a positive number", () => {
+            expect(API_TIMEOUT).toBeGreaterThan(0);
+        });
+        it("should be 30 seconds (30000ms)", () => {
+            expect(API_TIMEOUT).toBe(30000);
+        });
+    });
+    describe("MAX_RESULTS", () => {
+        it("should be a positive number", () => {
+            expect(MAX_RESULTS).toBeGreaterThan(0);
+        });
+        it("should be 100", () => {
+            expect(MAX_RESULTS).toBe(100);
+        });
+    });
+    describe("DEFAULT_PAGE_SIZE", () => {
+        it("should be a positive number", () => {
+            expect(DEFAULT_PAGE_SIZE).toBeGreaterThan(0);
+        });
+        it("should be 20", () => {
+            expect(DEFAULT_PAGE_SIZE).toBe(20);
+        });
+        it("should be less than MAX_RESULTS", () => {
+            expect(DEFAULT_PAGE_SIZE).toBeLessThan(MAX_RESULTS);
+        });
+    });
+});

package/dist/config/aws.js

@@ -1,12 +1,10 @@
+/**
+ * AWS configuration helpers for the MCP server.
+ *
+ * This module is intentionally side-effect free to keep initialization
+ * controlled by the entrypoint.
+ */
 import { BedrockAgentRuntimeClient } from "@aws-sdk/client-bedrock-agent-runtime";
-import { getLogger } from "@logtape/logtape";
-const logger = getLogger(["mcpserver", "aws-config"]);
-// When true, enables reranking for the Bedrock knowledge base queries.
-export const kbRerankingEnabled = (process.env.BEDROCK_KB_RERANKING_ENABLED || "true").trim().toLowerCase() ===
-    "true";
-export const knowledgeBaseId = process.env.BEDROCK_KNOWLEDGE_BASE_ID || "";
-logger.debug(`Default reranking enabled: ${kbRerankingEnabled} (from BEDROCK_KB_RERANKING_ENABLED)`);
-export const region = process.env.AWS_REGION || "eu-central-1";
 // List of AWS regions that support reranking
 export const rerankingSupportedRegions = [
     "ap-northeast-1",
@@ -15,13 +13,12 @@ export const rerankingSupportedRegions = [
     "us-east-1",
     "us-west-2",
 ];
-let kbRuntimeClient;
-try {
-    // Initializes the Bedrock Agent Runtime client with the specified region.
-    kbRuntimeClient = new BedrockAgentRuntimeClient({ region });
+export function createBedrockRuntimeClient(region, logger) {
+    try {
+        return new BedrockAgentRuntimeClient({ region });
+    }
+    catch (error) {
+        logger.error("Error getting bedrock agent client", { error });
+        throw error;
+    }
 }
-catch (e) {
-    logger.error("Error getting bedrock agent client", { error: e });
-    process.exit(1);
-}
-export { kbRuntimeClient };

package/dist/config/constants.js

@@ -0,0 +1,9 @@
+/**
+ * Server constants and configuration values
+ */
+/** Timeout for API requests in milliseconds */
+export const API_TIMEOUT = 30000;
+/** Maximum number of results to return */
+export const MAX_RESULTS = 100;
+/** Default page size for paginated results */
+export const DEFAULT_PAGE_SIZE = 20;

package/dist/config/logging.js

@@ -16,31 +16,27 @@
  * logger.info("Message");
  */
 import { configure, getConsoleSink } from "@logtape/logtape";
-import { z } from "zod";
+import * as z from "zod";
 /**
  * Zod schema for validating log levels.
  * Based on LogTape's LogLevel type.
  */
 const DEFAULT_LOG_LEVEL = "info";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const logLevelSchema = z
-    .enum(["debug", "info", "warning", "error"])
+    .enum(["error", "trace", "debug", "info", "warning", "fatal"])
     .catch(DEFAULT_LOG_LEVEL);
-export async function configureLogging() {
-    const logLevel = logLevelSchema.parse(process.env.LOG_LEVEL);
-    if (logLevel !== process.env.LOG_LEVEL) {
-        // Use console.warn for this early logging before LogTape is configured
-        console.warn(`Invalid log level: ${process.env.LOG_LEVEL}. Using ${DEFAULT_LOG_LEVEL}`);
-    }
+export async function configureLogging(logLevelEnv) {
     await configure({
         loggers: [
             {
                 category: ["mcpserver"],
-                lowestLevel: logLevel,
+                lowestLevel: logLevelEnv,
                 sinks: ["console"],
             },
             {
                 category: ["mcp-prompts"],
-                lowestLevel: logLevel,
+                lowestLevel: logLevelEnv,
                 sinks: ["console"],
             },
             {

package/dist/config/monitoring.js

@@ -12,12 +12,20 @@
  */
 import { getLogger } from "@logtape/logtape";
 import { initAzureMonitor } from "@pagopa/azure-tracing/azure-monitor";
-const logger = getLogger(["mcpserver", "monitoring"]);
-export function configureAzureMonitoring() {
+export function configureAzureMonitoring(config) {
+    const logger = getLogger(["mcpserver", "monitoring"]);
     try {
-        // Initialize Azure Monitor using environment variables
-        // This will read APPLICATIONINSIGHTS_CONNECTION_STRING and APPINSIGHTS_SAMPLING_PERCENTAGE
-        initAzureMonitor();
+        if (!config.connectionString) {
+            logger.info("Azure Application Insights connection string not provided. Monitoring disabled.");
+            return;
+        }
+        initAzureMonitor([], {
+            azureMonitorExporterOptions: {
+                connectionString: config.connectionString,
+            },
+            enableLiveMetrics: true,
+            samplingRatio: config.samplingRatio,
+        });
         logger.info("Azure Application Insights monitoring configured successfully");
     }
     catch (error) {

package/dist/config.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { formatZodIssues } from "./utils/errors.js";
+import { normalizeBoolean } from "./utils/normalize-boolean.js";
+export const DEFAULT_PORT = 8080;
+const logLevelSchema = z
+    .enum(["debug", "info", "warning", "error"])
+    .default("info");
+export const envSchema = z.object({
+    APPINSIGHTS_SAMPLING_PERCENTAGE: z.coerce.number().min(0).max(100).optional(),
+    APPLICATIONINSIGHTS_CONNECTION_STRING: z.string().optional(),
+    AWS_REGION: z.string().optional(),
+    BEDROCK_KB_RERANKING_ENABLED: z.string().optional(),
+    BEDROCK_KNOWLEDGE_BASE_ID: z.string().optional(),
+    BEDROCK_MODEL_ARN: z.string().optional(),
+    GITHUB_SEARCH_ORG: z.string().optional(),
+    LOG_LEVEL: logLevelSchema,
+    PORT: z.coerce.number().int().positive().optional(),
+    REQUIRED_ORGANIZATIONS: z.string().optional(),
+});
+/**
+ * Loads and validates the application configuration from environment variables.
+ *
+ * @param env - The environment variables object (usually process.env)
+ * @returns The validated application configuration
+ * @throws Error if environment variables fail validation
+ */
+export function loadConfig(env) {
+    const parsedEnv = envSchema.safeParse(env);
+    if (!parsedEnv.success) {
+        throw new Error(`Invalid environment variables: ${formatZodIssues(parsedEnv.error.issues)}`);
+    }
+    const rawEnv = parsedEnv.data;
+    const port = rawEnv.PORT ?? DEFAULT_PORT;
+    const rerankingEnabled = normalizeBoolean(rawEnv.BEDROCK_KB_RERANKING_ENABLED, true);
+    return {
+        aws: {
+            knowledgeBaseId: rawEnv.BEDROCK_KNOWLEDGE_BASE_ID ?? "",
+            modelArn: rawEnv.BEDROCK_MODEL_ARN ?? "",
+            region: rawEnv.AWS_REGION ?? "eu-central-1",
+            rerankingEnabled,
+        },
+        github: {
+            requiredOrganizations: parseRequiredOrganizations(rawEnv.REQUIRED_ORGANIZATIONS),
+            searchOrg: rawEnv.GITHUB_SEARCH_ORG ?? "pagopa",
+        },
+        logLevel: rawEnv.LOG_LEVEL,
+        monitoring: {
+            connectionString: rawEnv.APPLICATIONINSIGHTS_CONNECTION_STRING,
+            samplingRatio: (rawEnv.APPINSIGHTS_SAMPLING_PERCENTAGE ?? 5) / 100,
+        },
+        port,
+    };
+}
+/**
+ * Parses a comma-separated list of organization names from a string.
+ * Defaults to ["pagopa"] if the list is empty or undefined.
+ *
+ * @param value - Comma-separated organization names
+ * @returns Array of organization names
+ */
+export function parseRequiredOrganizations(value) {
+    const organizations = (value ?? "")
+        .split(",")
+        .map((org) => org.trim())
+        .filter(Boolean);
+    return organizations.length > 0 ? organizations : ["pagopa"];
+}

package/dist/decorators/{promptUsageMonitoring.js → prompt-usage-monitoring.js}

@@ -1,29 +1,26 @@
 import { getLogger } from "@logtape/logtape";
 import { emitCustomEvent } from "@pagopa/azure-tracing/logger";
+import { filterUndefined } from "../utils/filter-undefined.js";
 const logger = getLogger(["mcpserver", "prompt-logging"]);
 /**
  * Decorator that adds logging to prompt load functions.
  * Logs when a prompt is requested to both console and Azure Application Insights.
  */
-export function withPromptLogging(prompt, catalogId) {
+export function withPromptLogging(prompt, catalogId, requestId) {
     const originalLoad = prompt.load;
     return {
         ...prompt,
         load: async (args) => {
-            const eventData = {
-                arguments: JSON.stringify(args),
-                promptId: catalogId,
-                promptName: prompt.name,
-                timestamp: new Date().toISOString(),
-            };
             // Log to console (goes to CloudWatch in Lambda)
-            logger.debug(`Prompt requested: ${prompt.name} - ${JSON.stringify(eventData)}`);
+            logger.debug(`Prompt requested: ${prompt.name} (ID: ${catalogId})`);
             // Emit custom event to Azure Application Insights
-            emitCustomEvent("PromptRequested", {
-                arguments: JSON.stringify(args),
+            // Note: Arguments are not logged to avoid exposing sensitive data
+            emitCustomEvent("PromptRequested", filterUndefined({
                 promptId: catalogId,
                 promptName: prompt.name,
-            })("mcpserver");
+                requestId,
+                timestamp: new Date().toISOString(),
+            }))("mcpserver");
             // Call the original load function and return the result
             return await originalLoad(args);
         },

package/dist/decorators/{toolUsageMonitoring.js → tool-usage-monitoring.js}

@@ -1,5 +1,6 @@
 import { getLogger } from "@logtape/logtape";
 import { emitCustomEvent } from "@pagopa/azure-tracing/logger";
+import { filterUndefined } from "../utils/filter-undefined.js";
 const logger = getLogger(["mcpserver", "tool-logging"]);
 /**
  * Decorator that adds logging to tool execute functions.
@@ -7,36 +8,34 @@ const logger = getLogger(["mcpserver", "tool-logging"]);
  * Preserves the exact original function signature and type.
  */
 export function withToolLogging(tool) {
-    if (typeof tool !== "object" || !tool.execute || !tool.name) {
-        return tool;
-    }
     const originalExecute = tool.execute;
     const toolName = tool.name;
     return {
         ...tool,
-        execute: async (...args) => {
+        execute: async (args, context) => {
+            // Cast args to the expected type for tool execution
             const startTime = Date.now();
-            const [toolArgs] = args;
-            const eventData = {
-                arguments: JSON.stringify(toolArgs),
-                timestamp: new Date().toISOString(),
-                toolName,
-            };
             // Log to console (goes to CloudWatch in Lambda)
-            logger.debug(`Tool executed: ${toolName} - ${JSON.stringify(eventData)}`);
+            logger.debug(`Tool executed: ${toolName}`);
             // Emit custom event to Azure Application Insights
+            const eventData = filterUndefined({
+                requestId: context?.requestId,
+                timestamp: new Date().toISOString(),
+                toolName,
+            });
             emitCustomEvent("ToolExecuted", eventData)("mcpserver");
             try {
                 // Call the original execute function and return the result
-                const result = await originalExecute(...args);
+                const result = await originalExecute(args, context);
                 const executionTime = Date.now() - startTime;
                 // Log successful completion
                 logger.debug(`Tool completed: ${toolName} - execution time: ${executionTime}ms`);
                 // Emit completion event to Azure Application Insights
-                emitCustomEvent("ToolCompleted", {
+                emitCustomEvent("ToolCompleted", filterUndefined({
                     executionTimeMs: executionTime.toString(),
+                    requestId: context?.requestId,
                     toolName,
-                })("mcpserver");
+                }))("mcpserver");
                 return result;
             }
             catch (error) {
@@ -44,11 +43,12 @@ export function withToolLogging(tool) {
                 // Log error
                 logger.error(`Tool failed: ${toolName} - ${error instanceof Error ? error.message : String(error)} - execution time: ${executionTime}ms`);
                 // Emit error event to Azure Application Insights
-                emitCustomEvent("ToolFailed", {
+                emitCustomEvent("ToolFailed", filterUndefined({
                     error: error instanceof Error ? error.message : String(error),
                     executionTimeMs: executionTime.toString(),
+                    requestId: context?.requestId,
                     toolName,
-                })("mcpserver");
+                }))("mcpserver");
                 throw error;
             }
         },

package/dist/handlers/ask.js

@@ -0,0 +1,54 @@
+import { getLogger } from "@logtape/logtape";
+import { z } from "zod";
+import { retrieveAndGenerate } from "../services/bedrock-retrieve-and-generate.js";
+import { resolveToWebsiteUrl } from "../services/bedrock.js";
+import { parseJsonBody, sendErrorResponse, sendJsonResponse, } from "../utils/http.js";
+const AskBodySchema = z.object({
+    query: z
+        .string({
+        invalid_type_error: "Missing required field: query",
+        required_error: "Missing required field: query",
+    })
+        .trim()
+        .min(1, "Missing required field: query"),
+});
+export async function handleAskEndpoint(req, res, config, kbRuntimeClient) {
+    const logger = getLogger(["mcpserver", "handler", "ask"]);
+    logger.debug("Handling /ask endpoint");
+    try {
+        let jsonBody;
+        try {
+            jsonBody = await parseJsonBody(req);
+        }
+        catch {
+            return sendErrorResponse(res, 400, "Invalid JSON in request body");
+        }
+        const result = AskBodySchema.safeParse(jsonBody);
+        if (!result.success) {
+            return sendErrorResponse(res, 400, result.error.errors[0].message);
+        }
+        const { query } = result.data;
+        const response = await retrieveAndGenerate(config.aws.knowledgeBaseId, config.aws.modelArn, query, kbRuntimeClient);
+        // Extract unique source URLs from citations
+        const sourceUrls = new Set();
+        response.citations?.forEach((citation) => {
+            citation.retrievedReferences?.forEach((ref) => {
+                const webLocation = resolveToWebsiteUrl(ref.location);
+                if (webLocation?.webLocation?.url) {
+                    sourceUrls.add(webLocation.webLocation.url);
+                }
+            });
+        });
+        sendJsonResponse(res, 200, {
+            answer: response.output?.text || "",
+            sources: Array.from(sourceUrls),
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Error handling /ask request: ${errorMessage}`);
+        sendErrorResponse(res, 500, "Internal server error", {
+            message: errorMessage,
+        });
+    }
+}

package/dist/handlers/search.js

@@ -0,0 +1,60 @@
+import { getLogger } from "@logtape/logtape";
+import { z } from "zod";
+import { queryKnowledgeBaseStructured } from "../services/bedrock.js";
+import { parseJsonBody, sendErrorResponse, sendJsonResponse, } from "../utils/http.js";
+const SearchBodySchema = z.object({
+    number_of_results: z
+        .number({
+        invalid_type_error: "number_of_results must be between 1 and 20",
+    })
+        .int()
+        .min(1, "number_of_results must be between 1 and 20")
+        .max(20, "number_of_results must be between 1 and 20")
+        .optional()
+        .default(5),
+    query: z
+        .string({
+        invalid_type_error: "Missing required field: query",
+        required_error: "Missing required field: query",
+    })
+        .trim()
+        .min(1, "Missing required field: query"),
+});
+export async function handleSearchEndpoint(req, res, config, kbRuntimeClient) {
+    const logger = getLogger(["mcpserver", "handler", "search"]);
+    logger.debug("Handling /search endpoint");
+    try {
+        let jsonBody;
+        try {
+            jsonBody = await parseJsonBody(req);
+        }
+        catch {
+            return sendErrorResponse(res, 400, "Invalid JSON in request body");
+        }
+        const result = SearchBodySchema.safeParse(jsonBody);
+        if (!result.success) {
+            return sendErrorResponse(res, 400, result.error.errors[0].message);
+        }
+        const { number_of_results: numberOfResults, query } = result.data;
+        const results = await queryKnowledgeBaseStructured(config.aws.knowledgeBaseId, query, kbRuntimeClient, numberOfResults, config.aws.rerankingEnabled);
+        // Format results with content, score, and source URL
+        const formattedResults = results.map((result) => ({
+            content: result.content,
+            score: result.score,
+            source: result.location?.type === "WEB"
+                ? result.location.webLocation?.url
+                : undefined,
+        }));
+        sendJsonResponse(res, 200, {
+            query,
+            results: formattedResults,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Error handling /search request: ${errorMessage}`);
+        sendErrorResponse(res, 500, "Internal server error", {
+            message: errorMessage,
+        });
+    }
+}

package/dist/index.js

@@ -1,62 +1,20 @@
-import { getLogger } from "@logtape/logtape";
+/**
+ * PagoPA DX Knowledge Retrieval MCP Server
+ *
+ * This module exposes the main server startup logic without triggering side effects
+ * at import time. All runtime setup flows from the main entrypoint.
+ */
 import { getEnabledPrompts } from "@pagopa/dx-mcpprompts";
-import { FastMCP } from "fastmcp";
-import { verifyGithubUser } from "./auth/github.js";
+import { loadConfig } from "./config.js";
 import { configureLogging } from "./config/logging.js";
 import { configureAzureMonitoring } from "./config/monitoring.js";
-import { serverInstructions } from "./config/server.js";
-import { withPromptLogging } from "./decorators/promptUsageMonitoring.js";
-import { withToolLogging } from "./decorators/toolUsageMonitoring.js";
-import { QueryPagoPADXDocumentationTool } from "./tools/QueryPagoPADXDocumentation.js";
-import { SearchGitHubCodeTool } from "./tools/SearchGitHubCode.js";
-// Configure logging
-await configureLogging();
-await configureAzureMonitoring();
-const logger = getLogger(["mcpserver"]);
-logger.info("MCP Server starting...");
-// Authentication is enabled based on the AUTH_REQUIRED environment variable.
-const server = new FastMCP({
-    authenticate: async (request) => {
-        const authHeader = request.headers["x-gh-pat"];
-        const apiKey = typeof authHeader === "string"
-            ? authHeader
-            : Array.isArray(authHeader)
-                ? authHeader[0]
-                : undefined;
-        if (!apiKey || !(await verifyGithubUser(apiKey))) {
-            throw new Response(null, {
-                status: 401,
-                statusText: "Unauthorized",
-            });
-        }
-        // The returned object is accessible in the `context.session`.
-        return {
-            id: 1,
-            token: apiKey,
-        };
-    },
-    instructions: serverInstructions,
-    name: "PagoPA DX Knowledge Retrieval MCP Server",
-    version: "0.0.0",
-});
-logger.debug(`Server instructions: \n\n${serverInstructions}`);
-logger.debug(`Loading enabled prompts...`);
-getEnabledPrompts().then((prompts) => {
-    prompts.forEach((catalogEntry) => {
-        logger.debug(`Adding prompt: ${catalogEntry.prompt.name}`);
-        // Apply logging decorator to the prompt
-        const decoratedPrompt = withPromptLogging(catalogEntry.prompt, catalogEntry.id);
-        server.addPrompt(decoratedPrompt);
-        logger.debug(`Added prompt: ${catalogEntry.prompt.name}`);
-    });
-});
-server.addTool(withToolLogging(QueryPagoPADXDocumentationTool));
-server.addTool(withToolLogging(SearchGitHubCodeTool));
-// Starts the server in HTTP Stream mode.
-server.start({
-    httpStream: {
-        port: 8080,
-        stateless: true,
-    },
-    transportType: "httpStream",
-});
+import { startHttpServer } from "./server.js";
+export async function main(env) {
+    const config = loadConfig(env);
+    await configureLogging(config.logLevel);
+    configureAzureMonitoring(config.monitoring);
+    const enabledPrompts = await getEnabledPrompts();
+    const httpServer = await startHttpServer(config, enabledPrompts);
+    return httpServer;
+}
+export { startHttpServer };

package/dist/mcp/server.js

@@ -0,0 +1,88 @@
+import { getLogger } from "@logtape/logtape";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import packageJson from "../../package.json" with { type: "json" };
+import { withPromptLogging } from "../decorators/prompt-usage-monitoring.js";
+import { withToolLogging } from "../decorators/tool-usage-monitoring.js";
+import { sessionStorage } from "../session.js";
+export function createServer({ enabledPrompts, requestId, toolDefinitions, }) {
+    const logger = getLogger(["mcpserver"]);
+    const mcpServer = new McpServer({
+        name: "pagopa-dx-mcp-server",
+        version: packageJson.version,
+    });
+    /**
+     * Register tools dynamically from the tool registry.
+     * This pattern allows tools to be added/removed by simply updating the registry,
+     * without needing to modify this registration code.
+     */
+    toolDefinitions.forEach(({ id, requiresSession, tool: toolDef }) => {
+        const decoratedTool = withToolLogging(toolDef);
+        const { annotations } = decoratedTool;
+        // Ensure parameters is a ZodObject (all tools must use z.object())
+        if (!(decoratedTool.parameters instanceof z.ZodObject)) {
+            throw new Error(`Tool "${id}" must use z.object() for parameters schema`);
+        }
+        const zodObject = decoratedTool.parameters;
+        mcpServer.registerTool(id, {
+            annotations: {
+                destructiveHint: annotations.destructiveHint ?? false,
+                idempotentHint: annotations.idempotentHint ?? true,
+                openWorldHint: annotations.openWorldHint ?? true,
+                readOnlyHint: annotations.readOnlyHint ?? true,
+            },
+            description: decoratedTool.description,
+            inputSchema: zodObject.shape,
+            title: annotations.title,
+        }, async (args) => {
+            const store = sessionStorage.getStore();
+            const context = requiresSession
+                ? {
+                    requestId: store?.requestId,
+                    session: store,
+                }
+                : undefined;
+            const result = await decoratedTool.execute(args, context);
+            return {
+                content: [
+                    {
+                        text: typeof result === "string" ? result : JSON.stringify(result),
+                        type: "text",
+                    },
+                ],
+            };
+        });
+    });
+    // Register prompts using the modern registerPrompt pattern
+    enabledPrompts.forEach((catalogEntry) => {
+        const decoratedPrompt = withPromptLogging(catalogEntry.prompt, catalogEntry.id, requestId);
+        // Build Zod schema from prompt arguments
+        const argsSchemaShape = {};
+        for (const arg of catalogEntry.prompt.arguments) {
+            const fieldSchema = z.string().describe(arg.description);
+            argsSchemaShape[arg.name] = arg.required
+                ? fieldSchema
+                : fieldSchema.optional();
+        }
+        const zodObject = z.object(argsSchemaShape);
+        mcpServer.registerPrompt(catalogEntry.prompt.name, {
+            argsSchema: zodObject.shape,
+            description: catalogEntry.prompt.description,
+        }, async (args) => {
+            const content = await decoratedPrompt.load(args || {});
+            return {
+                messages: [
+                    {
+                        content: {
+                            text: content,
+                            type: "text",
+                        },
+                        role: "user",
+                    },
+                ],
+            };
+        });
+    });
+    logger.debug(`Server initialized with ${toolDefinitions.length} tools and ${enabledPrompts.length} prompts`);
+    return mcpServer;
+}