@answerai/answeragent-mcp 1.0.1

package/dist/tools/chatflows.js

@@ -0,0 +1,72 @@
+import { ChatflowsService } from "../services/chatflows.js";
+const service = ChatflowsService.getInstance();
+export const listChatflows = {
+    name: "list_chatflows",
+    description: "List all chatflows",
+    inputSchema: { type: "object", properties: {} },
+    handler: async () => {
+        const result = await service.listChatflows();
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const getChatflow = {
+    name: "get_chatflow",
+    description: "Get a chatflow by ID",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            includeFullFlowData: { type: "boolean", default: false },
+        },
+        required: ["id"],
+    },
+    handler: async ({ id, includeFullFlowData = false, }) => {
+        const result = await service.getChatflow(id, includeFullFlowData);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const createChatflow = {
+    name: "create_chatflow",
+    description: "Create a new chatflow",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            flowData: { type: "string" },
+        },
+        required: ["name"],
+    },
+    handler: async (data) => {
+        const result = await service.createChatflow(data);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const updateChatflow = {
+    name: "update_chatflow",
+    description: "Update a chatflow",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            updates: { type: "object" },
+        },
+        required: ["id", "updates"],
+    },
+    handler: async ({ id, updates }) => {
+        const result = await service.updateChatflow(id, updates);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const deleteChatflow = {
+    name: "delete_chatflow",
+    description: "Delete a chatflow",
+    inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"],
+    },
+    handler: async ({ id }) => {
+        await service.deleteChatflow(id);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+    },
+};

package/dist/tools/document-loaders.js

@@ -0,0 +1,70 @@
+import { DocumentLoaderService } from "../services/document-loader.js";
+const service = DocumentLoaderService.getInstance();
+export const deleteLoaderTool = {
+    name: "delete_loader",
+    description: "Delete a loader from a document store",
+    inputSchema: {
+        type: "object",
+        properties: {
+            storeId: { type: "string" },
+            loaderId: { type: "string" },
+        },
+        required: ["storeId", "loaderId"],
+    },
+    handler: async ({ storeId, loaderId }) => {
+        await service.deleteLoader(storeId, loaderId);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+    },
+};
+export const getLoaderChunksTool = {
+    name: "get_loader_chunks",
+    description: "Get document loader chunks",
+    inputSchema: {
+        type: "object",
+        properties: {
+            storeId: { type: "string" },
+            loaderId: { type: "string" },
+            pageNo: { type: "string" },
+        },
+        required: ["storeId", "loaderId", "pageNo"],
+    },
+    handler: async ({ storeId, loaderId, pageNo }) => {
+        const result = await service.getChunks(storeId, loaderId, pageNo);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const updateLoaderChunkTool = {
+    name: "update_loader_chunk",
+    description: "Update a loader chunk",
+    inputSchema: {
+        type: "object",
+        properties: {
+            storeId: { type: "string" },
+            loaderId: { type: "string" },
+            chunkId: { type: "string" },
+            payload: { type: "object" },
+        },
+        required: ["storeId", "loaderId", "chunkId", "payload"],
+    },
+    handler: async ({ storeId, loaderId, chunkId, payload }) => {
+        const result = await service.updateChunk(storeId, loaderId, chunkId, payload);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const deleteLoaderChunkTool = {
+    name: "delete_loader_chunk",
+    description: "Delete a loader chunk",
+    inputSchema: {
+        type: "object",
+        properties: {
+            storeId: { type: "string" },
+            loaderId: { type: "string" },
+            chunkId: { type: "string" },
+        },
+        required: ["storeId", "loaderId", "chunkId"],
+    },
+    handler: async ({ storeId, loaderId, chunkId }) => {
+        await service.deleteChunk(storeId, loaderId, chunkId);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+    },
+};

package/dist/tools/document-stores.js

@@ -0,0 +1,117 @@
+import { DocumentStoreService } from "../services/document-store.js";
+const service = DocumentStoreService.getInstance();
+export const listDocumentStores = {
+    name: "list_document_stores",
+    description: "List document stores",
+    inputSchema: { type: "object", properties: {} },
+    handler: async () => {
+        const result = await service.listDocumentStores();
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const getDocumentStore = {
+    name: "get_document_store",
+    description: "Get a document store by ID",
+    inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"],
+    },
+    handler: async ({ id }) => {
+        const result = await service.getDocumentStore(id);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const createDocumentStore = {
+    name: "create_document_store",
+    description: "Create a document store",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+        },
+        required: ["name"],
+    },
+    handler: async (data) => {
+        const result = await service.createDocumentStore(data);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const updateDocumentStore = {
+    name: "update_document_store",
+    description: "Update a document store",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            updates: { type: "object" },
+        },
+        required: ["id", "updates"],
+    },
+    handler: async ({ id, updates, }) => {
+        const result = await service.updateDocumentStore(id, updates);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const deleteDocumentStore = {
+    name: "delete_document_store",
+    description: "Delete a document store",
+    inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"],
+    },
+    handler: async ({ id }) => {
+        await service.deleteDocumentStore(id);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+    },
+};
+export const upsertDocument = {
+    name: "upsert_document",
+    description: "Upsert document to store",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            payload: { type: "object" },
+        },
+        required: ["id", "payload"],
+    },
+    handler: async ({ id, payload }) => {
+        const result = await service.upsertDocument(id, payload);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const refreshDocumentStore = {
+    name: "refresh_document_store",
+    description: "Refresh all documents in store",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            payload: { type: "object" },
+        },
+        required: ["id", "payload"],
+    },
+    handler: async ({ id, payload }) => {
+        const result = await service.refreshDocumentStore(id, payload);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const queryVectorStore = {
+    name: "query_vector_store",
+    description: "Query vector store",
+    inputSchema: {
+        type: "object",
+        properties: {
+            storeId: { type: "string" },
+            query: { type: "string" },
+        },
+        required: ["storeId", "query"],
+    },
+    handler: async ({ storeId, query }) => {
+        const result = await service.queryVectorStore({ storeId, query });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};

package/dist/tools/registry.js

@@ -0,0 +1,109 @@
+import * as chatflowTools from "./chatflows.js";
+import * as documentStoreTools from "./document-stores.js";
+import * as toolsApiTools from "./tools-api.js";
+import * as assistantTools from "./assistants.js";
+import * as documentLoaderTools from "./document-loaders.js";
+// Get all available tools for listing
+export const getAllTools = () => {
+    const tools = [];
+    // Add Chatflow Tools
+    for (const tool of Object.values(chatflowTools)) {
+        const schema = tool.inputSchema;
+        tools.push({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: "object",
+                properties: schema.properties,
+                ...(schema.required ? { required: schema.required } : {}),
+            },
+        });
+    }
+    // Add Document Store Tools
+    for (const tool of Object.values(documentStoreTools)) {
+        const schema = tool.inputSchema;
+        tools.push({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: "object",
+                properties: schema.properties,
+                ...(schema.required ? { required: schema.required } : {}),
+            },
+        });
+    }
+    // Add Tools API Tools
+    for (const tool of Object.values(toolsApiTools)) {
+        const schema = tool.inputSchema;
+        tools.push({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: "object",
+                properties: schema.properties,
+                ...(schema.required ? { required: schema.required } : {}),
+            },
+        });
+    }
+    // Add Assistant Tools
+    for (const tool of Object.values(assistantTools)) {
+        const schema = tool.inputSchema;
+        tools.push({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: "object",
+                properties: schema.properties,
+                ...(schema.required ? { required: schema.required } : {}),
+            },
+        });
+    }
+    // Add Document Loader Tools
+    for (const tool of Object.values(documentLoaderTools)) {
+        const schema = tool.inputSchema;
+        tools.push({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: "object",
+                properties: schema.properties,
+                ...(schema.required ? { required: schema.required } : {}),
+            },
+        });
+    }
+    return tools;
+};
+// Handle tool calls
+export async function handleToolCall(name, args) {
+    // Check chatflow tools
+    for (const tool of Object.values(chatflowTools)) {
+        if (tool.name === name) {
+            return await tool.handler(args);
+        }
+    }
+    // Check document store tools
+    for (const tool of Object.values(documentStoreTools)) {
+        if (tool.name === name) {
+            return await tool.handler(args);
+        }
+    }
+    // Check tools API tools
+    for (const tool of Object.values(toolsApiTools)) {
+        if (tool.name === name) {
+            return await tool.handler(args);
+        }
+    }
+    // Check assistant tools
+    for (const tool of Object.values(assistantTools)) {
+        if (tool.name === name) {
+            return await tool.handler(args);
+        }
+    }
+    // Check document loader tools
+    for (const tool of Object.values(documentLoaderTools)) {
+        if (tool.name === name) {
+            return await tool.handler(args);
+        }
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}

package/dist/tools/tools-api.js

@@ -0,0 +1,69 @@
+import { ToolsApiService } from "../services/tools-api.js";
+const service = ToolsApiService.getInstance();
+export const listToolsApi = {
+    name: "list_tools",
+    description: "List tools from AnswerAgent",
+    inputSchema: { type: "object", properties: {} },
+    handler: async () => {
+        const result = await service.listTools();
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const getToolApi = {
+    name: "get_tool",
+    description: "Get tool by ID",
+    inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"],
+    },
+    handler: async ({ id }) => {
+        const result = await service.getTool(id);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const createToolApi = {
+    name: "create_tool",
+    description: "Create a tool",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+        },
+        required: ["name"],
+    },
+    handler: async (data) => {
+        const result = await service.createTool(data);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const updateToolApi = {
+    name: "update_tool",
+    description: "Update a tool",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            updates: { type: "object" },
+        },
+        required: ["id", "updates"],
+    },
+    handler: async ({ id, updates }) => {
+        const result = await service.updateTool(id, updates);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    },
+};
+export const deleteToolApi = {
+    name: "delete_tool",
+    description: "Delete a tool",
+    inputSchema: {
+        type: "object",
+        properties: { id: { type: "string" } },
+        required: ["id"],
+    },
+    handler: async ({ id }) => {
+        await service.deleteTool(id);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+    },
+};

package/dist/types/assistant.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export const AssistantDetailsSchema = z.object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    model: z.string().optional(),
+    instructions: z.string().optional(),
+    temperature: z.number().optional(),
+    top_p: z.number().optional(),
+    tools: z.array(z.string()).optional(),
+    tool_resources: z.record(z.any()).optional(),
+});
+export const AssistantSchema = z.object({
+    id: z.string().uuid().optional(),
+    details: AssistantDetailsSchema.optional(),
+    credential: z.string().optional(),
+    iconSrc: z.string().optional(),
+    createdDate: z.string().datetime().optional(),
+    updatedDate: z.string().datetime().optional(),
+});

package/dist/types/chatflow.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+// Define schema for parsed flow data structure
+export const ParsedNodeSchema = z.object({
+    id: z.string(),
+    type: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    category: z.string().optional(),
+    credential: z.string().optional(),
+    prompts: z.object({
+        systemMessagePrompt: z.string().optional(),
+        humanMessagePrompt: z.string().optional(),
+        agentInstructions: z.string().optional(),
+    }).optional(),
+});
+export const ParsedFlowDataSchema = z.object({
+    nodes: z.array(ParsedNodeSchema),
+    credentialIds: z.array(z.string()),
+});
+export const ChatflowSchema = z.object({
+    id: z.string().uuid().optional(),
+    name: z.string(),
+    description: z.string().optional(),
+    visibility: z.string().optional(),
+    flowData: z.string().optional(),
+    deployed: z.boolean().optional(),
+    isPublic: z.boolean().optional(),
+    apikeyid: z.string().optional(),
+    chatbotConfig: z.string().optional(),
+    apiConfig: z.string().optional(),
+    analytic: z.string().optional(),
+    speechToText: z.string().optional(),
+    category: z.string().optional(),
+    type: z.string().optional(),
+    userId: z.string().optional(),
+    organizationId: z.string().optional(),
+    createdDate: z.string().datetime().optional(),
+    updatedDate: z.string().datetime().optional(),
+    deleteDate: z.string().datetime().optional(),
+    badge: z.string().optional(),
+    isOwner: z.boolean().optional(),
+    canEdit: z.boolean().optional(),
+    parsedFlowData: ParsedFlowDataSchema.optional(),
+});

package/dist/types/document-loader.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const DocumentLoaderSchema = z.object({
+    id: z.string().uuid().optional(),
+    status: z.string().optional(),
+    storeId: z.string().optional(),
+    source: z.string().optional(),
+    credential: z.string().optional(),
+    rehydrated: z.boolean().optional(),
+    preview: z.boolean().optional(),
+    previewChunkCount: z.number().optional(),
+});

package/dist/types/document-store.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const DocumentStoreSchema = z.object({
+    id: z.string().uuid().optional(),
+    name: z.string(),
+    description: z.string().optional(),
+    loaders: z.string().optional(),
+    whereUsed: z.string().optional(),
+    status: z.string().optional(),
+    vectorStoreConfig: z.string().optional(),
+    embeddingConfig: z.string().optional(),
+    recordManagerConfig: z.string().optional(),
+    createdDate: z.string().datetime().optional(),
+    updatedDate: z.string().datetime().optional(),
+});

package/dist/types/tool.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const ToolSchema = z.object({
+    id: z.string().uuid().optional(),
+    name: z.string(),
+    description: z.string().optional(),
+    color: z.string().optional(),
+    iconSrc: z.string().nullable().optional(),
+    schema: z.string().nullable().optional(),
+    func: z.string().nullable().optional(),
+    createdDate: z.string().datetime().optional(),
+    updatedDate: z.string().datetime().optional(),
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@answerai/answeragent-mcp",
+  "version": "1.0.1",
+  "description": "A lightweight Model Context Protocol (MCP) server for Answer AI chatflow and document store management",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "answerai-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "answer-ai",
+    "chatflow",
+    "document-store",
+    "api",
+    "ai-tools"
+  ],
+  "author": "Bradley Taylor",
+  "license": "ISC",
+  "homepage": "https://github.com/bradtaylor/answerai-mcp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bradtaylor/answerai-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bradtaylor/answerai-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "0.6.0",
+    "axios": "^1.8.4",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/node": "^20.11.24",
+    "nodemon": "^3.1.9",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.3.3",
+    "vite": "^6.2.3"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "start": "node dist/index.js",
+    "dev": "nodemon --exec 'node --loader ts-node/esm src/index.ts'",
+    "inspect": "node bin/run-inspector.js",
+    "inspect-watch": "nodemon --exec 'node bin/run-inspector.js'",
+    "test": "node --loader ts-node/esm --test"
+  }
+}