mcp-meilisearch 1.0.8 → 1.0.9

package/README.md

@@ -7,22 +7,7 @@ A Model Context Protocol (MCP) server implementation that provides a bridge betw
 This project provides a MCP server that enables AI models to interact directly with Meilisearch functionalities. The architecture includes:
 
 - **MCP Server**: Exposes Meilisearch APIs as tools using the Model Context Protocol.
-- **Web Client**: A demo interface showcasing search functionalities.
-
-## Architecture
-
-```
-┌───────────────┐      ┌───────────────┐      ┌───────────────┐
-│  Meilisearch  │      │   MCP Server  │      │   Web Client  │
-│   Instance    │ <--> │   (Node.js)   │ <--> │   (Browser)   │
-└───────────────┘      └───────────────┘      └───────────────┘
-        ^
-        │
-┌───────────────┐
-│ Document Data │
-│    Sources    │
-└───────────────┘
-```
+- **Web Client Demo**: A demo interface showcasing search functionalities.
 
 ## Key Features
 
@@ -79,8 +64,8 @@ MEILISEARCH_API_KEY=your_master_key_here
 To start the server:
 
 ```bash
-npm run start:server  # Start the MCP server
-npm run start:client  # Start the web client
+npm run server  # Start the MCP server
+npm run demo  # Start the Web client demo
 ```
 
 ### Accessing the Web Interface
@@ -99,14 +84,6 @@ This project uses:
 - **Express**: Powers the web server.
 - **Model Context Protocol SDK**: Facilitates AI integration.
 
-## Project Structure
-
-- `src/`: Core MCP server implementation.
-  - `tools/`: Meilisearch API tools.
-  - `utils/`: Utility functions for API communication and error handling.
-  - `server.ts`: Main MCP server implementation.
-- `client/`: Web client for testing and demonstration.
-
 ## Vite Plugin Integration
 
 This package provides a Vite plugin for easy integration with your Vite-based applications.
@@ -164,8 +141,7 @@ const client = new MCPClient("meilisearch");
 await client.connectToServer("http://localhost:3000/mcp");
 
 // Call a tool
-const result = await client.callTool("search", {
-  indexUid: "movies",
-  q: "star wars",
+const result = await client.callTool("search-across-all-indexes", {
+  q: "search kiosco antonio",
 });
 ```

package/dist/standalone.d.ts

@@ -0,0 +1,41 @@
+import http from "node:http";
+interface StandaloneServerOptions {
+    /**
+     * HTTP port for MCP server
+     * @default 8080
+     */
+    httpPort?: number;
+    /**
+     * MCP endpoint path
+     * @default "/mcp"
+     */
+    mcpEndpoint?: string;
+    /**
+     * Session timeout in milliseconds
+     * @default 3600000 (1 hour)
+     */
+    sessionTimeout?: number;
+    /**
+     * Session cleanup interval in milliseconds
+     * @default 60000 (1 minute)
+     */
+    sessionCleanupInterval?: number;
+    /**
+     * The URL of the Meilisearch instance
+     * @default "http://localhost:7700"
+     */
+    meilisearchHost: string;
+    /**
+     * The API key for authenticating with Meilisearch
+     * @default ""
+     */
+    meilisearchApiKey: string;
+}
+/**
+ * Start a standalone MCP server (without Vite)
+ * @param options Configuration options for the MCP server
+ * @returns A promise that resolves to the HTTP server instance
+ */
+export declare function initStandaloneServer(options?: StandaloneServerOptions): Promise<http.Server>;
+export default initStandaloneServer;
+//# sourceMappingURL=standalone.d.ts.map

package/dist/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../src/standalone.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAQ7B,UAAU,uBAAuB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,uBAGR,GACA,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAmGtB;AAqCD,eAAe,oBAAoB,CAAC"}

package/dist/standalone.js

@@ -0,0 +1,133 @@
+import { createServer } from "node:http";
+import { initServer } from "./server.js";
+import { parse as parseUrl } from "node:url";
+import { configHandler } from "./utils/config-handler.js";
+import { createErrorResponse } from "./utils/error-handler.js";
+/**
+ * Start a standalone MCP server (without Vite)
+ * @param options Configuration options for the MCP server
+ * @returns A promise that resolves to the HTTP server instance
+ */
+export async function initStandaloneServer(options = {
+    meilisearchApiKey: "",
+    meilisearchHost: "http://localhost:7700",
+}) {
+    configHandler.setMeilisearchHost(options.meilisearchHost);
+    configHandler.setMeilisearchApiKey(options.meilisearchApiKey);
+    let mcpServerInstance = null;
+    const httpPort = options.httpPort || 8080;
+    const mcpEndpoint = options.mcpEndpoint || "/mcp";
+    const server = createServer(async (req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", `Origin, X-Requested-With, Content-Type, Accept, mcp-session-id`);
+        if (req.method === "OPTIONS") {
+            res.statusCode = 200;
+            res.end();
+            return;
+        }
+        const parsedUrl = parseUrl(req.url || "/", true);
+        const pathname = parsedUrl.pathname || "/";
+        if (pathname.startsWith(mcpEndpoint)) {
+            if (!mcpServerInstance) {
+                console.error("MCP server not initialized yet");
+                res.statusCode = 503;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify(createErrorResponse("MCP server not initialized yet")));
+                return;
+            }
+            if (req.method === "GET") {
+                await mcpServerInstance.handleGetRequest(req, res);
+            }
+            else if (req.method === "POST") {
+                let body = "";
+                req.on("data", (chunk) => {
+                    body += chunk.toString();
+                });
+                req.on("end", async () => {
+                    try {
+                        const jsonBody = JSON.parse(body);
+                        await mcpServerInstance.handlePostRequest(req, res, jsonBody);
+                    }
+                    catch (error) {
+                        console.error("Error parsing request body:", error);
+                        res.statusCode = 400;
+                        res.end(JSON.stringify(createErrorResponse("Invalid JSON body")));
+                    }
+                });
+            }
+            else {
+                res.statusCode = 405;
+                res.end(JSON.stringify(createErrorResponse("Method not allowed")));
+            }
+        }
+        else {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: "Not found" }));
+        }
+    });
+    await new Promise((resolve) => {
+        server.listen(httpPort, () => {
+            console.log(`Standalone MCP server listening on port ${httpPort}`);
+            resolve();
+        });
+    });
+    try {
+        console.log("Initializing MCP server...");
+        const serverInstances = await initServer("http", options);
+        mcpServerInstance = serverInstances.mcpServer;
+        console.log("MCP server initialized successfully");
+    }
+    catch (error) {
+        console.error("Failed to initialize MCP server:", error);
+        server.close();
+        throw error;
+    }
+    const shutdownHandler = () => {
+        console.log("Shutting down MCP server...");
+        if (mcpServerInstance && typeof mcpServerInstance.shutdown === "function") {
+            try {
+                mcpServerInstance.shutdown();
+            }
+            catch (error) {
+                console.error("Error shutting down MCP server:", error);
+            }
+        }
+        server.close();
+    };
+    process.on("SIGINT", shutdownHandler);
+    process.on("SIGTERM", shutdownHandler);
+    return server;
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const args = process.argv.slice(2);
+    const options = {
+        meilisearchHost: "http://localhost:7700",
+        meilisearchApiKey: "",
+    };
+    for (let i = 0; i < args.length; i += 2) {
+        const key = args[i].replace("--", "");
+        const value = args[i + 1];
+        switch (key) {
+            case "port":
+                options.httpPort = parseInt(value, 10);
+                break;
+            case "endpoint":
+                options.mcpEndpoint = value;
+                break;
+            case "host":
+                options.meilisearchHost = value;
+                break;
+            case "apiKey":
+                options.meilisearchApiKey = value;
+                break;
+        }
+    }
+    initStandaloneServer(options)
+        .then(() => console.log("MCP server running"))
+        .catch((err) => {
+        console.error("Failed to start server:", err);
+        process.exit(1);
+    });
+}
+export default initStandaloneServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-meilisearch",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Model Context Protocol (MCP) implementation for Meilisearch",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,12 +10,12 @@
     "README.md"
   ],
   "workspaces": [
-    "client"
+    "demo"
   ],
   "scripts": {
     "build": "tsc && tsc --project tsconfig.types.json",
-    "server": "npm run build && node --env-file=.env dist/index.js",
-    "client": "npm run server & npm run dev --workspace=client",
+    "server": "npm run build && node --env-file=.env dist/standalone.js",
+    "demo": "npm run build && node --env-file=.env dist/index.js & npm run dev --workspace=demo",
     "prepare": "npm version patch",
     "prepublishOnly": "npm run build"
   },