@answerai/answeragent-mcp 1.0.1

package/README.md

@@ -0,0 +1,254 @@
+# @answerai/answeragent-mcp
+
+[![npm version](https://badge.fury.io/js/@answerai%2Fansweragent-mcp.svg)](https://badge.fury.io/js/@answerai%2Fansweragent-mcp)
+
+A lightweight Model Context Protocol (MCP) server for Answer AI chatflow and document store management. This server exposes Answer AI's powerful features through standardized MCP tools and prompts, allowing you to manage chatflows, document stores, assistants, and more directly from your MCP-compatible AI clients.
+
+## Installation
+
+Install globally via npm:
+
+```bash
+npm install -g @answerai/answeragent-mcp
+```
+
+Or use with npx (no installation required):
+
+```bash
+npx @answerai/answeragent-mcp
+```
+
+## Quick Start
+
+1. **Get Your Answer AI Credentials**:
+   - API Base URL (e.g., `https://your-instance.studio.theanswer.ai`)
+   - API Token (JWT token from your Answer AI instance)
+
+2. **Test the Server**:
+   ```bash
+   npx @modelcontextprotocol/inspector @answerai/answeragent-mcp
+   ```
+
+## Client Configuration
+
+### Cursor IDE
+
+Add this configuration to your `~/.cursor/mcp.json` file:
+
+```json
+{
+  "mcpServers": {
+    "answerai-mcp": {
+      "command": "node",
+      "args": [
+        "/path/to/your/project/dist/index.js"
+      ],
+      "env": {
+        "ANSWERAGENT_AI_API_BASE_URL": "https://your-instance.studio.theanswer.ai",
+        "ANSWERAGENT_AI_API_TOKEN": "your-jwt-token-here"
+      }
+    }
+  }
+}
+```
+
+**For NPM installed version:**
+```json
+{
+  "mcpServers": {
+    "answerai-mcp": {
+      "command": "npx",
+      "args": ["@answerai/answeragent-mcp"],
+      "env": {
+        "ANSWERAGENT_AI_API_BASE_URL": "https://your-instance.studio.theanswer.ai",
+        "ANSWERAGENT_AI_API_TOKEN": "your-jwt-token-here"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add this to your Claude Desktop MCP settings file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "answerai": {
+      "command": "npx",
+      "args": ["@answerai/answeragent-mcp"],
+      "env": {
+        "ANSWERAGENT_AI_API_BASE_URL": "https://your-instance.studio.theanswer.ai",
+        "ANSWERAGENT_AI_API_TOKEN": "your-jwt-token-here"
+      }
+    }
+  }
+}
+```
+
+### Other MCP Clients (Cline, etc.)
+
+Most MCP clients follow the same pattern:
+
+```json
+{
+  "command": "npx",
+  "args": ["@answerai/answeragent-mcp"],
+  "env": {
+    "ANSWERAGENT_AI_API_BASE_URL": "https://your-instance.studio.theanswer.ai",
+    "ANSWERAGENT_AI_API_TOKEN": "your-jwt-token-here"
+  }
+}
+```
+
+## Configuration
+
+The server requires two environment variables:
+
+- `ANSWERAGENT_AI_API_BASE_URL`: Your Answer AI instance base URL (without `/api/v1`)
+- `ANSWERAGENT_AI_API_TOKEN`: Your Answer AI JWT authentication token
+
+**Important**: 
+- Don't include `/api/v1` in the base URL - the server adds this automatically
+- Make sure you're using a JWT token, not an API key
+- The token must have appropriate permissions for the operations you want to perform
+
+## Available Tools
+
+### Chatflow Management
+- `create_chatflow` - Create new chatflows
+- `get_chatflow` - Retrieve chatflow details
+- `update_chatflow` - Update existing chatflows
+- `delete_chatflow` - Remove chatflows
+- `list_chatflows` - List all chatflows
+
+### Document Store Management
+- `create_document_store` - Create document stores
+- `get_document_store` - Get store details
+- `delete_document_store` - Remove document stores
+- `list_document_stores` - List all stores
+- `query_vector_store` - Query document stores
+- `upsert_document` - Add/update documents
+- `refresh_document_store` - Refresh store contents
+
+### Assistant Management
+- `create_assistant` - Create AI assistants
+- `get_assistant` - Get assistant details
+- `update_assistant` - Update assistants
+- `delete_assistant` - Remove assistants
+- `list_assistants` - List all assistants
+
+### Tool Management
+- `create_tool` - Create custom tools
+- `get_tool` - Get tool details
+- `update_tool` - Update tools
+- `delete_tool` - Remove tools
+- `list_tools` - List all tools
+
+### Document Loader Management
+- `get_loader_chunks` - Get document chunks
+- `update_loader_chunk` - Update chunks
+- `delete_loader_chunk` - Remove chunks
+- `delete_loader` - Remove loaders
+
+## Intelligent Prompts
+
+The server provides AI-powered prompts for advanced analysis and management:
+
+### `analyze_chatflow`
+Analyzes chatflow configuration and provides optimization recommendations.
+
+**Arguments:**
+- `chatflowId` (required): The chatflow ID to analyze
+- `focusAreas` (optional): Array of specific areas to focus on
+
+### `analyze_document_store`
+Analyzes document store configuration, loaders, and usage patterns.
+
+**Arguments:**
+- `documentStoreId` (required): The document store ID to analyze
+- `focusAreas` (optional): Array of specific areas to focus on
+
+### `manage_document_store`
+Provides step-by-step guidance for document store operations.
+
+**Arguments:**
+- `action` (required): One of "setup", "optimize", "troubleshoot", "migrate"
+- `documentStoreId` (optional): Target document store ID
+- `context` (optional): Additional context for the operation
+
+## Usage Examples
+
+### With Cursor IDE
+
+After configuring in Cursor, you can use natural language commands:
+
+1. **List your chatflows**:
+   > "Show me all my Answer AI chatflows"
+
+2. **Analyze a specific chatflow**:
+   > "Analyze the 'RDS Call Analysis' chatflow and suggest optimizations"
+
+3. **Create a document store**:
+   > "Create a new document store called 'Customer Support KB' for storing help articles"
+
+4. **Query documents**:
+   > "Search my 'Contracts' document store for information about payment terms"
+
+### With Claude Desktop
+
+After adding to your Claude Desktop configuration:
+
+1. **Analyze a chatflow**:
+   > "Please analyze my chatflow with ID 'df23d39c-a25b-4842-8997-dce3afed88f4' and focus on performance optimization"
+
+2. **Document store management**:
+   > "Help me troubleshoot my document store that's not syncing properly"
+
+3. **Assistant management**:
+   > "Show me details about my 'Document Reader' assistant and suggest improvements"
+
+### With MCP Inspector
+
+Test and explore the server capabilities:
+
+```bash
+npx @modelcontextprotocol/inspector @answerai/answeragent-mcp
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **401 Unauthorized Error**:
+   - Check that your JWT token is valid and not expired
+   - Ensure you're using a JWT token, not an API key
+   - Verify the token has the necessary permissions
+
+2. **Connection Issues**:
+   - Confirm your base URL is correct (without `/api/v1`)
+   - Check that your Answer AI instance is accessible
+   - Verify environment variables are set correctly
+
+3. **Tool Not Found**:
+   - Restart your MCP client after configuration changes
+   - Check the server logs for any startup errors
+   - Verify the package is properly installed
+
+## Requirements
+
+- Node.js 18+
+- Valid Answer AI JWT token with appropriate permissions
+- MCP-compatible client (Claude Desktop, Cursor, Cline, etc.)
+
+## Support
+
+For issues and feature requests, visit our [GitHub repository](https://github.com/bradtaylor/answerai-mcp).
+
+## License
+
+ISC

package/dist/index.js

@@ -0,0 +1,100 @@
+#!/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);
+});

package/dist/prompts/chatflow-analysis.js

@@ -0,0 +1,205 @@
+import { z } from "zod";
+import { ChatflowsService } from "../services/chatflows.js";
+const chatflowsService = ChatflowsService.getInstance();
+/**
+ * Chatflow Analysis Prompt
+ *
+ * This prompt analyzes a chatflow and provides structured insights
+ * about its configuration, nodes, and potential improvements.
+ */
+export const analyzeChatflowPrompt = {
+    name: "analyze_chatflow",
+    description: "Analyzes a chatflow and provides structured insights about its configuration and nodes",
+    schema: {
+        chatflowId: z.string().describe("The ID of the chatflow to analyze"),
+        focusAreas: z
+            .array(z.string())
+            .optional()
+            .default([])
+            .describe("Specific areas to focus on in the analysis (e.g., 'prompts', 'nodes', 'credentials')"),
+    },
+    handler: async ({ chatflowId, focusAreas = [], }) => {
+        // Fetch the chatflow data
+        const chatflow = await chatflowsService.getChatflow(chatflowId, true);
+        if (!chatflow) {
+            throw new Error(`Chatflow with ID ${chatflowId} not found`);
+        }
+        // Extract key information from the chatflow
+        const { name, description, deployed, isPublic, category, type, parsedFlowData, createdDate, updatedDate, } = chatflow;
+        // Analyze the flow data
+        const nodeAnalysis = [];
+        const credentialAnalysis = [];
+        const promptAnalysis = [];
+        if (parsedFlowData) {
+            // Analyze nodes
+            for (const node of parsedFlowData.nodes) {
+                nodeAnalysis.push({
+                    id: node.id,
+                    type: node.type,
+                    label: node.label,
+                    description: node.description,
+                    category: node.category,
+                    hasPrompts: !!node.prompts,
+                    hasCredentials: !!node.credential,
+                });
+                // Analyze prompts within nodes
+                if (node.prompts && (focusAreas.length === 0 || focusAreas.includes("prompts"))) {
+                    const { systemMessagePrompt, humanMessagePrompt, agentInstructions } = node.prompts;
+                    if (systemMessagePrompt) {
+                        promptAnalysis.push({
+                            nodeId: node.id,
+                            nodeLabel: node.label,
+                            type: "system",
+                            content: systemMessagePrompt,
+                            length: systemMessagePrompt.length,
+                            hasVariables: systemMessagePrompt.includes("{") || systemMessagePrompt.includes("{{"),
+                        });
+                    }
+                    if (humanMessagePrompt) {
+                        promptAnalysis.push({
+                            nodeId: node.id,
+                            nodeLabel: node.label,
+                            type: "human",
+                            content: humanMessagePrompt,
+                            length: humanMessagePrompt.length,
+                            hasVariables: humanMessagePrompt.includes("{") || humanMessagePrompt.includes("{{"),
+                        });
+                    }
+                    if (agentInstructions) {
+                        promptAnalysis.push({
+                            nodeId: node.id,
+                            nodeLabel: node.label,
+                            type: "agent",
+                            content: agentInstructions,
+                            length: agentInstructions.length,
+                            hasVariables: agentInstructions.includes("{") || agentInstructions.includes("{{"),
+                        });
+                    }
+                }
+            }
+            // Analyze credentials
+            for (const credentialId of parsedFlowData.credentialIds) {
+                credentialAnalysis.push({
+                    id: credentialId,
+                    usedByNodes: parsedFlowData.nodes.filter(n => n.credential === credentialId).length,
+                });
+            }
+        }
+        // Generate insights
+        const insights = [];
+        // Node insights
+        if (nodeAnalysis.length > 0) {
+            insights.push(`Flow contains ${nodeAnalysis.length} nodes`);
+            const nodeTypes = [...new Set(nodeAnalysis.map(n => n.type))];
+            insights.push(`Node types: ${nodeTypes.join(", ")}`);
+            const nodesWithPrompts = nodeAnalysis.filter(n => n.hasPrompts).length;
+            if (nodesWithPrompts > 0) {
+                insights.push(`${nodesWithPrompts} nodes have custom prompts`);
+            }
+            const nodesWithCredentials = nodeAnalysis.filter(n => n.hasCredentials).length;
+            if (nodesWithCredentials > 0) {
+                insights.push(`${nodesWithCredentials} nodes use credentials`);
+            }
+        }
+        // Prompt insights
+        if (promptAnalysis.length > 0) {
+            const avgPromptLength = promptAnalysis.reduce((sum, p) => sum + p.length, 0) / promptAnalysis.length;
+            insights.push(`Average prompt length: ${Math.round(avgPromptLength)} characters`);
+            const promptsWithVariables = promptAnalysis.filter(p => p.hasVariables).length;
+            if (promptsWithVariables > 0) {
+                insights.push(`${promptsWithVariables} prompts use variables`);
+            }
+        }
+        // Credential insights
+        if (credentialAnalysis.length > 0) {
+            insights.push(`Uses ${credentialAnalysis.length} different credentials`);
+        }
+        // Generate recommendations
+        const recommendations = [];
+        if (nodeAnalysis.length > 10) {
+            recommendations.push("Consider breaking down complex flows into smaller, more manageable components");
+        }
+        if (promptAnalysis.length > 0) {
+            const longPrompts = promptAnalysis.filter(p => p.length > 1000);
+            if (longPrompts.length > 0) {
+                recommendations.push(`${longPrompts.length} prompts are quite long (>1000 chars) - consider breaking them down`);
+            }
+        }
+        if (!deployed && isPublic) {
+            recommendations.push("Chatflow is public but not deployed - consider deploying or making it private");
+        }
+        if (!description) {
+            recommendations.push("Add a description to help users understand the chatflow's purpose");
+        }
+        // Filter analysis based on focus areas
+        let filteredNodeAnalysis = nodeAnalysis;
+        let filteredPromptAnalysis = promptAnalysis;
+        let filteredCredentialAnalysis = credentialAnalysis;
+        if (focusAreas.length > 0) {
+            if (!focusAreas.includes("nodes")) {
+                filteredNodeAnalysis = [];
+            }
+            if (!focusAreas.includes("prompts")) {
+                filteredPromptAnalysis = [];
+            }
+            if (!focusAreas.includes("credentials")) {
+                filteredCredentialAnalysis = [];
+            }
+        }
+        // Construct the analysis response
+        return {
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: `# Chatflow Analysis: ${name}
+
+## Overview
+- **Name**: ${name}
+- **Description**: ${description || "No description provided"}
+- **Status**: ${deployed ? "Deployed" : "Not deployed"}
+- **Visibility**: ${isPublic ? "Public" : "Private"}
+- **Category**: ${category || "Uncategorized"}
+- **Type**: ${type || "Unknown"}
+- **Created**: ${createdDate ? new Date(createdDate).toLocaleDateString() : "Unknown"}
+- **Updated**: ${updatedDate ? new Date(updatedDate).toLocaleDateString() : "Unknown"}
+
+## Key Insights
+${insights.map(i => `- ${i}`).join("\n")}
+
+${filteredNodeAnalysis.length > 0 ? `## Node Analysis
+${filteredNodeAnalysis.map(node => `
+### ${node.label} (${node.type})
+- **ID**: ${node.id}
+- **Description**: ${node.description || "No description"}
+- **Category**: ${node.category || "Uncategorized"}
+- **Has Prompts**: ${node.hasPrompts ? "Yes" : "No"}
+- **Uses Credentials**: ${node.hasCredentials ? "Yes" : "No"}
+`).join("\n")}` : ""}
+
+${filteredPromptAnalysis.length > 0 ? `## Prompt Analysis
+${filteredPromptAnalysis.map(prompt => `
+### ${prompt.nodeLabel} - ${prompt.type.toUpperCase()} Prompt
+- **Length**: ${prompt.length} characters
+- **Uses Variables**: ${prompt.hasVariables ? "Yes" : "No"}
+- **Content Preview**: ${prompt.content.substring(0, 100)}${prompt.content.length > 100 ? "..." : ""}
+`).join("\n")}` : ""}
+
+${filteredCredentialAnalysis.length > 0 ? `## Credential Analysis
+${filteredCredentialAnalysis.map(cred => `
+### Credential: ${cred.id}
+- **Used by**: ${cred.usedByNodes} node(s)
+`).join("\n")}` : ""}
+
+## Recommendations
+${recommendations.map(r => `- ${r}`).join("\n")}
+
+## Summary
+This chatflow ${deployed ? "is deployed and ready for use" : "is not yet deployed"}. ${recommendations.length > 0 ? `Consider implementing the ${recommendations.length} recommendations above to improve the flow.` : "The flow appears to be well-configured."}`,
+                    },
+                },
+            ],
+        };
+    },
+};