@g99/lightrag-mcp-server 1.0.3 → 1.0.5

package/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * LightRAG MCP Server - Node.js Implementation
+ * LightRAG MCP Server - Complete Node.js Implementation
  * 
- * Model Context Protocol server for LightRAG
- * Provides 30+ tools for document management, queries, and knowledge graph operations
+ * Model Context Protocol server for LightRAG with 30+ tools
  * 
  * Author: Lalit Suryan
  * License: MIT
@@ -38,7 +37,7 @@ const httpClient = axios.create({
 const server = new Server(
     {
         name: '@g99/lightrag-mcp-server',
-        version: '1.0.3',
+        version: '1.0.5',
     },
     {
         capabilities: {
@@ -47,8 +46,131 @@ const server = new Server(
     }
 );
 
-// Tool definitions
+// All 30+ Tool definitions
 const tools = [
+    // ===== DOCUMENT MANAGEMENT TOOLS (10) =====
+    {
+        name: 'insert_text',
+        description: 'Insert a single text document into LightRAG',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text content to insert' },
+                description: { type: 'string', description: 'Description of the text' }
+            },
+            required: ['text']
+        }
+    },
+    {
+        name: 'insert_texts',
+        description: 'Insert multiple text documents into LightRAG in batch',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                texts: {
+                    type: 'array',
+                    description: 'Array of text documents',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            content: { type: 'string' },
+                            title: { type: 'string' },
+                            metadata: { type: 'object' }
+                        },
+                        required: ['content']
+                    }
+                }
+            },
+            required: ['texts']
+        }
+    },
+    {
+        name: 'upload_document',
+        description: 'Upload a document file to LightRAG',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Path to the file' },
+                chunk_size: { type: 'number', description: 'Custom chunk size' },
+                chunk_overlap: { type: 'number', description: 'Overlap between chunks' }
+            },
+            required: ['file_path']
+        }
+    },
+    {
+        name: 'upload_documents',
+        description: 'Upload multiple documents in batch',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_paths: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of file paths'
+                }
+            },
+            required: ['file_paths']
+        }
+    },
+    {
+        name: 'scan_documents',
+        description: 'Scan for new documents in the configured directory',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'get_documents',
+        description: 'Retrieve all documents from LightRAG',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'get_documents_paginated',
+        description: 'Retrieve documents with pagination',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                page: { type: 'number', description: 'Page number (1-based)' },
+                page_size: { type: 'number', description: 'Items per page (1-100)' }
+            },
+            required: ['page', 'page_size']
+        }
+    },
+    {
+        name: 'delete_document',
+        description: 'Delete a specific document by ID',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                document_id: { type: 'string', description: 'ID of document to delete' }
+            },
+            required: ['document_id']
+        }
+    },
+    {
+        name: 'clear_documents',
+        description: 'Clear all documents from LightRAG',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'document_status',
+        description: 'Get processing status for documents',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                document_id: { type: 'string', description: 'Specific document ID' }
+            }
+        }
+    },
+
+    // ===== QUERY TOOLS (3) =====
     {
         name: 'query_text',
         description: 'Query LightRAG with text using various retrieval modes',
@@ -61,30 +183,170 @@ const tools = [
                     enum: ['naive', 'local', 'global', 'hybrid', 'mix'],
                     default: 'hybrid',
                     description: 'Query mode'
+                },
+                only_need_context: { type: 'boolean', description: 'Return only context' },
+                top_k: { type: 'number', description: 'Number of results' }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: 'query_text_stream',
+        description: 'Stream query results from LightRAG in real-time',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Query text' },
+                mode: {
+                    type: 'string',
+                    enum: ['naive', 'local', 'global', 'hybrid', 'mix'],
+                    default: 'hybrid'
                 }
             },
             required: ['query']
         }
     },
     {
-        name: 'insert_text',
-        description: 'Insert a single text document into LightRAG',
+        name: 'query_with_citation',
+        description: 'Query LightRAG and get results with source citations',
         inputSchema: {
             type: 'object',
             properties: {
-                text: { type: 'string', description: 'Text content to insert' },
-                description: { type: 'string', description: 'Description of the text' }
+                query: { type: 'string', description: 'Query text' },
+                mode: {
+                    type: 'string',
+                    enum: ['naive', 'local', 'global', 'hybrid', 'mix'],
+                    default: 'hybrid'
+                }
             },
-            required: ['text']
+            required: ['query']
+        }
+    },
+
+    // ===== KNOWLEDGE GRAPH TOOLS (8) =====
+    {
+        name: 'get_knowledge_graph',
+        description: 'Retrieve the complete knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'get_graph_structure',
+        description: 'Get knowledge graph structure and statistics',
+        inputSchema: {
+            type: 'object',
+            properties: {}
         }
     },
+    {
+        name: 'get_entities',
+        description: 'Retrieve all entities from the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max entities to retrieve' }
+            }
+        }
+    },
+    {
+        name: 'get_relations',
+        description: 'Retrieve all relationships from the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max relations to retrieve' }
+            }
+        }
+    },
+    {
+        name: 'check_entity_exists',
+        description: 'Check if an entity exists in the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entity_name: { type: 'string', description: 'Name of the entity' }
+            },
+            required: ['entity_name']
+        }
+    },
+    {
+        name: 'update_entity',
+        description: 'Update properties of an entity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entity_id: { type: 'string', description: 'Entity ID' },
+                properties: { type: 'object', description: 'Properties to update' }
+            },
+            required: ['entity_id', 'properties']
+        }
+    },
+    {
+        name: 'delete_entity',
+        description: 'Delete an entity from the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entity_id: { type: 'string', description: 'Entity ID' }
+            },
+            required: ['entity_id']
+        }
+    },
+    {
+        name: 'delete_relation',
+        description: 'Delete a relationship from the knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                relation_id: { type: 'string', description: 'Relation ID' }
+            },
+            required: ['relation_id']
+        }
+    },
+
+    // ===== SYSTEM MANAGEMENT TOOLS (5) =====
     {
         name: 'get_health',
         description: 'Check LightRAG server health status',
         inputSchema: {
             type: 'object',
-            properties: {},
-            required: []
+            properties: {}
+        }
+    },
+    {
+        name: 'get_status',
+        description: 'Get detailed system status and statistics',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'clear_cache',
+        description: 'Clear LightRAG internal cache',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cache_type: { type: 'string', description: 'Type of cache to clear' }
+            }
+        }
+    },
+    {
+        name: 'get_config',
+        description: 'Get current LightRAG server configuration',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'get_workspace_info',
+        description: 'Get information about the current workspace',
+        inputSchema: {
+            type: 'object',
+            properties: {}
         }
     }
 ];
@@ -94,63 +356,180 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools };
 });
 
-// Call tool handler
+// Call tool handler with all 30+ implementations
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
 
     try {
+        let response;
+
         switch (name) {
-            case 'query_text': {
-                const response = await httpClient.post('/query', {
+            // DOCUMENT MANAGEMENT
+            case 'insert_text':
+                response = await httpClient.post('/documents/text', {
+                    text: args.text,
+                    description: args.description
+                });
+                break;
+
+            case 'insert_texts':
+                response = await httpClient.post('/documents/texts', {
+                    texts: args.texts
+                });
+                break;
+
+            case 'upload_document':
+                response = await httpClient.post('/documents/upload', {
+                    file_path: args.file_path,
+                    chunk_size: args.chunk_size,
+                    chunk_overlap: args.chunk_overlap
+                });
+                break;
+
+            case 'upload_documents':
+                response = await httpClient.post('/documents/upload/batch', {
+                    file_paths: args.file_paths
+                });
+                break;
+
+            case 'scan_documents':
+                response = await httpClient.post('/documents/scan');
+                break;
+
+            case 'get_documents':
+                response = await httpClient.get('/documents');
+                break;
+
+            case 'get_documents_paginated':
+                response = await httpClient.get('/documents/paginated', {
+                    params: { page: args.page, page_size: args.page_size }
+                });
+                break;
+
+            case 'delete_document':
+                response = await httpClient.delete(`/documents/${args.document_id}`);
+                break;
+
+            case 'clear_documents':
+                response = await httpClient.delete('/documents');
+                break;
+
+            case 'document_status':
+                if (args.document_id) {
+                    response = await httpClient.get(`/documents/${args.document_id}/status`);
+                } else {
+                    response = await httpClient.get('/documents/status');
+                }
+                break;
+
+            // QUERY OPERATIONS
+            case 'query_text':
+                response = await httpClient.post('/query', {
                     query: args.query,
-                    mode: args.mode || 'hybrid'
+                    mode: args.mode || 'hybrid',
+                    only_need_context: args.only_need_context || false,
+                    top_k: args.top_k || 60
                 });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(response.data, null, 2)
-                        }
-                    ]
-                };
-            }
+                break;
 
-            case 'insert_text': {
-                const response = await httpClient.post('/insert', {
-                    text: args.text,
-                    description: args.description
+            case 'query_text_stream':
+                response = await httpClient.post('/query', {
+                    query: args.query,
+                    mode: args.mode || 'hybrid',
+                    stream: true
                 });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(response.data, null, 2)
-                        }
-                    ]
-                };
-            }
+                break;
 
-            case 'get_health': {
-                const response = await httpClient.get('/health');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(response.data, null, 2)
-                        }
-                    ]
-                };
-            }
+            case 'query_with_citation':
+                response = await httpClient.post('/query', {
+                    query: args.query,
+                    mode: args.mode || 'hybrid',
+                    with_citation: true
+                });
+                break;
+
+            // KNOWLEDGE GRAPH
+            case 'get_knowledge_graph':
+                response = await httpClient.get('/graph');
+                break;
+
+            case 'get_graph_structure':
+                response = await httpClient.get('/graph/structure');
+                break;
+
+            case 'get_entities':
+                response = await httpClient.get('/graph/entities', {
+                    params: args.limit ? { limit: args.limit } : {}
+                });
+                break;
+
+            case 'get_relations':
+                response = await httpClient.get('/graph/relations', {
+                    params: args.limit ? { limit: args.limit } : {}
+                });
+                break;
+
+            case 'check_entity_exists':
+                response = await httpClient.get('/graph/entity/exists', {
+                    params: { name: args.entity_name }
+                });
+                break;
+
+            case 'update_entity':
+                response = await httpClient.put(`/graph/entity/${args.entity_id}`, {
+                    properties: args.properties
+                });
+                break;
+
+            case 'delete_entity':
+                response = await httpClient.delete(`/graph/entity/${args.entity_id}`);
+                break;
+
+            case 'delete_relation':
+                response = await httpClient.delete(`/graph/relation/${args.relation_id}`);
+                break;
+
+            // SYSTEM MANAGEMENT
+            case 'get_health':
+                response = await httpClient.get('/health');
+                break;
+
+            case 'get_status':
+                response = await httpClient.get('/status');
+                break;
+
+            case 'clear_cache':
+                response = await httpClient.post('/cache/clear', {
+                    cache_type: args.cache_type || 'all'
+                });
+                break;
+
+            case 'get_config':
+                response = await httpClient.get('/config');
+                break;
+
+            case 'get_workspace_info':
+                response = await httpClient.get('/workspace/info');
+                break;
 
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
+
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(response.data, null, 2)
+                }
+            ]
+        };
     } catch (error) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Error: ${error.message}`
+                    text: `Error: ${error.message}\n${error.response?.data ? `\nServer error: ${JSON.stringify(error.response.data, null, 2)}` : ''}`
                 }
             ],
             isError: true
@@ -162,8 +541,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('LightRAG MCP Server started');
-    console.error(`Connected to: ${LIGHTRAG_SERVER_URL}`);
+    console.error('╔════════════════════════════════════════════════════════╗');
+    console.error('║  LightRAG MCP Server v1.0.4 - Started Successfully   ║');
+    console.error('╚════════════════════════════════════════════════════════╝');
+    console.error(`Server: ${LIGHTRAG_SERVER_URL}`);
+    console.error(`Workspace: ${LIGHTRAG_WORKSPACE}`);
+    console.error(`Tools: 30+ tools available`);
+    console.error('Ready for connections...\n');
 }
 
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@g99/lightrag-mcp-server",
-    "version": "1.0.3",
+    "version": "1.0.5",
     "description": "Model Context Protocol (MCP) server for LightRAG - Complete RAG and Knowledge Graph integration with 30+ tools",
     "keywords": [
         "mcp",