@answerai/answeragent-mcp/dist/index.js

A lightweight Model Context Protocol (MCP) server for Answer AI chatflow and document store management

#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
import * as prompts from "./prompts/index.js";
import { getAllTools, handleToolCall } from "./tools/registry.js";
// Create MCP server
const server = new Server({
    name: "answerai-mcp",
    version: "1.0.0",
}, {
    capabilities: {
        tools: {},
        prompts: {},
    },
});
// Register tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
    return { tools: getAllTools() };
});
// Register prompts
server.setRequestHandler(ListPromptsRequestSchema, async () => {
    return {
        prompts: [
            {
                name: prompts.analyzeChatflowPrompt.name,
                description: prompts.analyzeChatflowPrompt.description,
                schema: prompts.analyzeChatflowPrompt.schema,
            },
            {
                name: prompts.analyzeDocumentStorePrompt.name,
                description: prompts.analyzeDocumentStorePrompt.description,
                schema: prompts.analyzeDocumentStorePrompt.schema,
            },
            {
                name: prompts.manageDocumentStorePrompt.name,
                description: prompts.manageDocumentStorePrompt.description,
                schema: prompts.manageDocumentStorePrompt.schema,
            },
        ],
    };
});
// Handle prompt requests
server.setRequestHandler(GetPromptRequestSchema, async (request) => {
    const { name, arguments: args = {} } = request.params;
    try {
        switch (name) {
            case prompts.analyzeChatflowPrompt.name:
                return await prompts.analyzeChatflowPrompt.handler({
                    chatflowId: args.chatflowId,
                    focusAreas: Array.isArray(args.focusAreas)
                        ? args.focusAreas
                        : undefined,
                });
            case prompts.analyzeDocumentStorePrompt.name:
                return await prompts.analyzeDocumentStorePrompt.handler({
                    documentStoreId: args.documentStoreId,
                    focusAreas: Array.isArray(args.focusAreas)
                        ? args.focusAreas
                        : undefined,
                });
            case prompts.manageDocumentStorePrompt.name:
                return await prompts.manageDocumentStorePrompt.handler({
                    action: args.action,
                    documentStoreId: args.documentStoreId,
                    context: args.context,
                });
            default:
                throw new Error(`Unknown prompt: ${name}`);
        }
    }
    catch (error) {
        const err = error;
        throw new Error(`Prompt error: ${err.message || "An unexpected error occurred"} ${err.statusCode ? `(Status: ${err.statusCode})` : ""}`);
    }
});
// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args = {} } = request.params;
    try {
        const result = (await handleToolCall(name, args));
        return {
            _meta: {},
            content: result.content,
        };
    }
    catch (error) {
        console.error(`Error executing tool ${name}:`, error);
        throw error;
    }
});
// Start the server
async function main() {
    const transport = new StdioServerTransport();
    await server.connect(transport);
}
main().catch((error) => {
    console.error("Server error:", error);
    process.exit(1);
});