rhombus-node-mcp 0.1.15 → 0.1.16

package/dist/disabled-tools/endpoint-to-keys-tool.js

@@ -0,0 +1,84 @@
+import { createToolTextContent } from "../util.js";
+import { TOOL_ARGS } from "../types/endpoint-to-keys-tool-types.js";
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TOOL_NAME = "endpoint-to-keys-tool";
+const TOOL_DESCRIPTION = `
+Returns the output keys for a given API endpoint.
+This tool helps you understand what fields are available in the response of any API endpoint.
+Use this to determine which fields to include when using other tools that accept includeFields parameters.
+
+Example usage:
+- Input: "POST /api/camera/getMinimalCameraStateList"
+- Output: ["wifiSignalStrength", "uuid", "name", "locationUuid", ...]
+
+Always use this tool first when you need to know what fields are available for any API endpoint.
+`;
+// Load the routes-to-output-keys.json data
+let routesData = {};
+function loadRoutesData() {
+    try {
+        // Try multiple possible locations for the routes data
+        const possiblePaths = [
+            path.join(process.cwd(), 'assets', 'routes-to-output-keys.json'),
+            path.join(process.cwd(), 'routes-to-output-keys.json'),
+            path.join(__dirname, '..', '..', 'assets', 'routes-to-output-keys.json'),
+        ];
+        let fileContent = '';
+        let usedPath = '';
+        for (const routesPath of possiblePaths) {
+            try {
+                fileContent = fs.readFileSync(routesPath, 'utf8');
+                usedPath = routesPath;
+                break;
+            }
+            catch (e) {
+                // Continue to next path
+            }
+        }
+        if (!fileContent) {
+            throw new Error(`Could not find routes-to-output-keys.json in any of: ${possiblePaths.join(', ')}`);
+        }
+        const data = JSON.parse(fileContent);
+        routesData = data.routes || {};
+        console.log(`Loaded ${Object.keys(routesData).length} route endpoints from ${usedPath}`);
+    }
+    catch (error) {
+        console.error('Failed to load routes-to-output-keys.json:', error);
+        routesData = {};
+    }
+}
+// Load data on module initialization
+loadRoutesData();
+const TOOL_HANDLER = async (args, extra) => {
+    const { endpoint } = args;
+    // Normalize the endpoint format
+    const normalizedEndpoint = endpoint.trim();
+    // Find the matching endpoint
+    const outputKeys = routesData[normalizedEndpoint];
+    if (!outputKeys) {
+        // Try to find a partial match or suggest similar endpoints
+        const availableEndpoints = Object.keys(routesData);
+        const similarEndpoints = availableEndpoints.filter(ep => ep.toLowerCase().includes(endpoint.toLowerCase()) ||
+            endpoint.toLowerCase().includes(ep.toLowerCase()));
+        return createToolTextContent(JSON.stringify({
+            error: "Endpoint not found",
+            message: `No output keys found for endpoint: ${endpoint}`,
+            suggestion: similarEndpoints.length > 0
+                ? `Similar endpoints found: ${similarEndpoints.slice(0, 5).join(', ')}`
+                : "Check the endpoint format. It should be like 'POST /api/camera/getMinimalCameraStateList'",
+            availableEndpointsCount: availableEndpoints.length
+        }, null, 2));
+    }
+    return createToolTextContent(JSON.stringify({
+        endpoint: normalizedEndpoint,
+        outputKeys: outputKeys,
+        totalKeys: outputKeys.length
+    }, null, 2));
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+}

package/dist/disabled-tools/semantic-search-tool.js

@@ -0,0 +1,90 @@
+import { FaissSearchService } from '../services/faiss-search-service.js';
+import { createToolTextContent } from '../util.js';
+import { logger } from '../logger.js';
+import { TOOL_ARGS } from '../types/semantic-search-tool-types.js';
+// Constants following coding style guidelines
+const DEFAULT_SEARCH_LIMIT = 3;
+const DEFAULT_MIN_SIMILARITY = 0.3;
+const TOOL_NAME = "semantic-search";
+const TOOL_DESCRIPTION = `
+This tool performs semantic search across the Rhombus knowledge base using AI embeddings and vector similarity.
+
+It searches through documentation, blog posts, support articles, and other content to find the most relevant 
+information based on the meaning of your query, not just keyword matching.
+
+The tool returns an array of search results, each containing:
+- sourceTitle: The title of the source document
+- sourceUrl: The URL where the content can be found
+- chunkText: The relevant text snippet that matches your query
+
+Use this tool when you need to find information about:
+- Camera features, specifications, or comparisons
+- Installation and setup procedures  
+- Technical troubleshooting
+- Product capabilities and benefits
+- Access control and security features
+- Cloud storage and management
+- Any other Rhombus-related topics
+`;
+// Singleton instance for reuse across searches
+let globalSearchService = null;
+let isGlobalServiceInitialized = false;
+async function getSearchService() {
+    if (!globalSearchService) {
+        globalSearchService = new FaissSearchService();
+    }
+    if (!isGlobalServiceInitialized) {
+        await globalSearchService.loadEmbeddings();
+        await globalSearchService.loadIndex();
+        isGlobalServiceInitialized = true;
+    }
+    return globalSearchService;
+}
+const TOOL_HANDLER = async (args, extra) => {
+    const { query } = args;
+    try {
+        if (!query || query.trim().length === 0) {
+            return createToolTextContent(JSON.stringify({ error: "Query cannot be empty" }));
+        }
+        const searchService = await getSearchService();
+        const searchOptions = {
+            query: query.trim(),
+            limit: DEFAULT_SEARCH_LIMIT,
+            minSimilarity: DEFAULT_MIN_SIMILARITY,
+            urlPattern: undefined,
+        };
+        const { results, stats } = await searchService.search(searchOptions);
+        const searchResults = results.map(result => ({
+            sourceTitle: result.sourceTitle,
+            sourceUrl: result.sourceUrl,
+            chunkText: result.chunkText,
+        }));
+        logger.info('Semantic search results:', results);
+        // Log search statistics for debugging
+        logger.info('Semantic search stats:', {
+            searchTime: stats.searchTime,
+            totalVectors: stats.totalVectors,
+            resultsReturned: stats.resultsReturned,
+            resultsFiltered: stats.resultsFiltered,
+            query: query.trim()
+        });
+        return createToolTextContent(JSON.stringify(searchResults));
+    }
+    catch (error) {
+        return createToolTextContent(JSON.stringify({
+            error: `Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+        }));
+    }
+};
+export async function createTool(server) {
+    try {
+        // Verify search service can be initialized and also save it into the cached variable
+        await getSearchService();
+        server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+    }
+    catch (error) {
+        logger.error('Failed to initialize semantic search tool:', error);
+        logger.error('Make sure you have the index and embeddings files in rhombus-node-mcp/data/embeddings/');
+        throw error;
+    }
+}

package/dist/index.js

@@ -8,12 +8,10 @@ import streamableHttpTransport from "./transports/streamable-http.js";
 const RHOMBUS_API_KEY = process.env.RHOMBUS_API_KEY;
 const TRANSPORT_TYPE = process.env.TRANSPORT_TYPE || "stdio";
 async function main() {
-    if (!RHOMBUS_API_KEY) {
-        logger.info("Missing RHOMBUS_API_KEY");
-    }
     const serverUrl = process.env.RHOMBUS_API_SERVER || "api2.rhombussystems.com";
-    logger.info(`Using API_KEY: ${RHOMBUS_API_KEY}`);
-    logger.info(`To hit API server: ${serverUrl}`);
+    if (RHOMBUS_API_KEY) {
+        logger.info(`🔑 Using API_KEY: ${RHOMBUS_API_KEY}`);
+    }
     logger.info("🌐 Using server url", serverUrl);
     await serverInit();
     const server = new McpServer({

package/dist/logger.js

@@ -4,21 +4,22 @@ log4js.configure({
     appenders: {
         mcp: {
             type: "file",
-            filename: path.resolve(process.env.LOG_FOLDER ?? process.cwd(), "rhombus-node-mcp.log"),
+            filename: path.resolve(process.env.LOG_FOLDER ?? process.cwd(), "./logs/rhombus-node-mcp.log"),
             maxLogSize: "1M",
             layout: {
                 type: "basic",
             },
         },
         stderr: { type: "stderr" },
+        stdout: { type: "stdout" },
     },
     categories: {
         default: {
-            appenders: ["mcp", "stderr"],
+            appenders: ["mcp", "stdout"],
             level: "trace",
         },
         mcp: {
-            appenders: ["mcp", "stderr"],
+            appenders: ["mcp", "stdout"],
             level: "trace",
         },
     },

package/dist/network.js

@@ -1,8 +1,6 @@
 import { logger } from "./logger.js";
+import { authStore } from "./transports/streamable-http.js";
 export const RHOMBUS_API_KEY = process.env.RHOMBUS_API_KEY;
-if (!RHOMBUS_API_KEY) {
-    console.error("Missing RHOMBUS_API_KEY");
-}
 export const serverUrl = process.env.RHOMBUS_API_SERVER || "api2.rhombussystems.com";
 export const BASE_URL = `https://${serverUrl}/api`;
 export const STATIC_HEADERS = {
@@ -14,12 +12,6 @@ export const AUTH_HEADERS = {
     "x-auth-apikey": RHOMBUS_API_KEY,
     "x-auth-scheme": "api-token",
 };
-const enableLogs = process.env.ENABLE_LOGS;
-const log = (msg) => {
-    if (!enableLogs)
-        return;
-    console.error(msg);
-};
 export const appendQueryParams = (url, params) => {
     if (!params || typeof params !== "object")
         return url;
@@ -34,15 +26,48 @@ export const appendQueryParams = (url, params) => {
     const queryString = existingSearchParams.toString();
     return queryString ? `${baseUrl}?${queryString}` : baseUrl;
 };
-export async function postApi(route, body, modifiers) {
+export async function postApi({ route, body, modifiers, sessionId, }) {
+    let url = BASE_URL + route;
+    // construct auth headers
+    let authHeaders = {};
+    if (!sessionId) {
+        // if no sessionId, we fall back to the api key in our environment variables
+        authHeaders = AUTH_HEADERS;
+    }
+    else {
+        // use sessionId to get auth
+        const auth = authStore.get(sessionId);
+        if (!auth) {
+            logger.error(`No auth found for sessionId: ${sessionId}`);
+            throw new Error(`No auth found for sessionId: ${sessionId}`);
+        }
+        if ("apiKey" in auth) {
+            authHeaders = {
+                "x-auth-apikey": auth.apiKey,
+                "x-auth-scheme": "api-token",
+            };
+        }
+        else if ("sessionId" in auth) {
+            authHeaders = {
+                "x-auth-session": auth.sessionId,
+                "x-auth-chat": auth.latestRecordUuid,
+                "x-auth-scheme": "chatbot",
+            };
+            url = appendQueryParams(url, { _rs: auth.sessionId });
+        }
+        else if ("cookie" in auth) {
+            authHeaders = {
+                "x-auth-scheme": "web2",
+                cookie: auth.cookie,
+            };
+        }
+    }
     // merge headers
-    let requestHeaders = {
+    const requestHeaders = {
         ...STATIC_HEADERS,
-        ...AUTH_HEADERS,
+        ...authHeaders,
         ...(modifiers?.headers ?? {}),
     };
-    let url = BASE_URL + route;
-    // attach query params if provided
     if (modifiers?.query) {
         url = appendQueryParams(url, modifiers.query);
     }
@@ -72,7 +97,9 @@ export async function postApi(route, body, modifiers) {
             // throw new Error(`HTTP error! status: ${response.status}`);
         }
         const ret = await response.json();
-        logger.debug(`✅ RESPONSE - ${response.ok} - ${JSON.stringify(ret)}`);
+        const jsonStr = JSON.stringify(ret);
+        const truncatedJson = jsonStr.length > 150 ? jsonStr.substring(0, 150) + "..." : jsonStr;
+        logger.debug(`✅ RESPONSE - ${response.ok} - ${truncatedJson}`);
         return ret;
     }
     catch (error) {

package/dist/resources/routes.json.js

@@ -13,7 +13,7 @@ The paths are categorized into "common_paths", "parameterized_paths", and "exter
 
 It is in the form of a JSON file.
 
-Use these paths to help the user navigate to the correct that they may want to go to. However, try not directly reference the path itself, rather describe it, and make sure to show the user a button to help navigate with.
+Use these paths to help the user navigate to the correct page that they may want to go to. However, try not directly reference the path itself, rather describe it, and make sure to show the user a button to help navigate with.
 When providing a path, make sure to be very exact. You're only allowed to substitute in path segments that begin with : or are surrounded by brackets []. For example, /locations/:locationUuid, you need to get a location's UUID and replace :locationUuid with the actual UUID`,
     }, async (uri) => {
         const currentDir = path.dirname(fileURLToPath(import.meta.url));

package/dist/services/embedding-service.js

@@ -0,0 +1,153 @@
+import OpenAI from "openai";
+// Constants following coding style guidelines
+const EMBEDDING_MODEL = "text-embedding-3-small";
+const EMBEDDING_BATCH_SIZE = 100;
+const MAX_TOKENS_PER_REQUEST = 8000;
+const DELAY_BETWEEN_BATCHES_MS = 1000;
+const MAX_RETRY_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 2000;
+export class EmbeddingService {
+    openai;
+    model;
+    batchSize;
+    constructor(apiKey, model = EMBEDDING_MODEL) {
+        this.openai = new OpenAI({
+            apiKey: apiKey || process.env.OPENAI_API_KEY,
+        });
+        this.model = model;
+        this.batchSize = EMBEDDING_BATCH_SIZE;
+    }
+    /**
+     * Generate embeddings for a batch of text chunks
+     * @param requests - Array of embedding requests
+     * @returns Batch result with embeddings and cost information
+     */
+    async generateEmbeddings(requests) {
+        if (!requests || requests.length === 0) {
+            return {
+                results: [],
+                totalTokens: 0,
+                totalCost: 0,
+                batchCount: 0,
+            };
+        }
+        const results = [];
+        let totalTokens = 0;
+        let totalCost = 0;
+        const batches = this.createBatches(requests);
+        console.log(`Processing ${requests.length} embeddings in ${batches.length} batches`);
+        for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+            const batch = batches[batchIndex];
+            console.log(`Processing batch ${batchIndex + 1}/${batches.length} (${batch.length} items)`);
+            try {
+                const batchResult = await this.processBatch(batch);
+                results.push(...batchResult.results);
+                totalTokens += batchResult.totalTokens;
+                totalCost += batchResult.totalCost;
+                // Add delay between batches to respect rate limits
+                if (batchIndex < batches.length - 1) {
+                    await this.delay(DELAY_BETWEEN_BATCHES_MS);
+                }
+            }
+            catch (error) {
+                console.error(`Error processing batch ${batchIndex + 1}:`, error);
+                throw error;
+            }
+        }
+        return {
+            results,
+            totalTokens,
+            totalCost,
+            batchCount: batches.length,
+        };
+    }
+    /**
+     * Generate embedding for a single text chunk
+     * @param text - Text to embed
+     * @param chunkId - Unique identifier for the chunk
+     * @returns Single embedding result
+     */
+    async generateSingleEmbedding(text, chunkId) {
+        const result = await this.generateEmbeddings([{ text, chunkId }]);
+        if (result.results.length === 0) {
+            throw new Error(`Failed to generate embedding for chunk ${chunkId}`);
+        }
+        return result.results[0];
+    }
+    /**
+     * Estimate cost for embedding generation
+     * @param tokenCount - Total number of tokens to embed
+     * @returns Estimated cost in USD
+     */
+    estimateCost(tokenCount) {
+        // text-embedding-3-small costs $0.02 per 1M tokens
+        const costPerMilTokens = 0.02;
+        return (tokenCount / 1_000_000) * costPerMilTokens;
+    }
+    async processBatch(batch) {
+        const texts = batch.map(req => req.text);
+        let attempt = 0;
+        while (attempt < MAX_RETRY_ATTEMPTS) {
+            try {
+                const response = await this.openai.embeddings.create({
+                    model: this.model,
+                    input: texts,
+                });
+                const results = batch.map((request, index) => {
+                    const embeddingData = response.data[index];
+                    const tokenCount = response.usage?.total_tokens
+                        ? Math.round(response.usage.total_tokens / batch.length)
+                        : 0;
+                    return {
+                        chunkId: request.chunkId,
+                        embedding: embeddingData.embedding,
+                        tokenCount,
+                        cost: this.estimateCost(tokenCount),
+                        model: this.model,
+                    };
+                });
+                return {
+                    results,
+                    totalTokens: response.usage?.total_tokens || 0,
+                    totalCost: this.estimateCost(response.usage?.total_tokens || 0),
+                    batchCount: 1,
+                };
+            }
+            catch (error) {
+                attempt++;
+                console.error(`Attempt ${attempt} failed for batch:`, error);
+                if (attempt >= MAX_RETRY_ATTEMPTS) {
+                    throw new Error(`Failed to process batch after ${MAX_RETRY_ATTEMPTS} attempts: ${error instanceof Error ? error.message : "Unknown error"}`);
+                }
+                // Exponential backoff delay
+                const delayMs = RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+                console.log(`Retrying in ${delayMs}ms...`);
+                await this.delay(delayMs);
+            }
+        }
+        throw new Error("Unexpected end of retry attempts");
+    }
+    createBatches(requests) {
+        const batches = [];
+        for (let i = 0; i < requests.length; i += this.batchSize) {
+            const batch = requests.slice(i, i + this.batchSize);
+            // Check if batch exceeds token limit (rough estimate)
+            const estimatedTokens = batch.reduce((sum, req) => sum + req.text.length / 4, 0);
+            if (estimatedTokens > MAX_TOKENS_PER_REQUEST) {
+                // Split large batch into smaller ones
+                const halfSize = Math.floor(batch.length / 2);
+                batches.push(batch.slice(0, halfSize));
+                if (halfSize < batch.length) {
+                    batches.push(batch.slice(halfSize));
+                }
+            }
+            else {
+                batches.push(batch);
+            }
+        }
+        return batches;
+    }
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}