mcp-meilisearch 1.0.3 → 1.0.6

package/dist/config.js

@@ -11,7 +11,7 @@ export const loadConfig = () => {
     return {
         host: process.env.MEILISEARCH_HOST || "http://localhost:7700",
         apiKey: process.env.MEILISEARCH_API_KEY || "",
-        timeout: parseInt(process.env.MEILISEARCH_TIMEOUT || "5000", 10),
+        timeout: parseInt("5000", 10),
     };
 };
 // Export the config instance

package/dist/index.d.ts

@@ -1,13 +1,54 @@
-export { MCPClient } from "./client.js";
-export * from "./server.js";
-export * from "./config.js";
-export * from "./tools/document-tools.js";
-export * from "./tools/index-tools.js";
-export * from "./tools/search-tools.js";
-export * from "./tools/settings-tools.js";
-export * from "./tools/system-tools.js";
-export * from "./tools/task-tools.js";
-export * from "./tools/vector-tools.js";
-export * from "./utils/api-handler.js";
-export * from "./utils/error-handler.js";
+import { Plugin } from "vite";
+import { MCPClient } from "./client.js";
+/**
+ * Options for the MCP Vite plugin
+ */
+export interface MCPPluginOptions {
+    /**
+     * Transport type for MCP server ("http" | "stdio")
+     * @default "http"
+     */
+    transport?: "http" | "stdio";
+    /**
+     * HTTP port for MCP server
+     * @default 8080
+     */
+    httpPort?: number;
+    /**
+     * MCP endpoint path
+     * @default "/mcp"
+     */
+    mcpEndpoint?: string;
+    /**
+     * Server name
+     * @default "meilisearch"
+     */
+    serverName?: string;
+    /**
+     * Server version
+     * @default "1.0.0"
+     */
+    serverVersion?: string;
+    /**
+     * Session timeout in milliseconds
+     * @default 3600000 (1 hour)
+     */
+    sessionTimeout?: number;
+    /**
+     * Session cleanup interval in milliseconds
+     * @default 60000 (1 minute)
+     */
+    sessionCleanupInterval?: number;
+}
+/**
+ * Creates a Vite plugin that integrates with the MCP server
+ * @param options Configuration options for the MCP server
+ * @returns A Vite plugin
+ */
+export declare function mcpPlugin(options?: MCPPluginOptions): Plugin;
+export { MCPClient };
+/**
+ * Default export for convenience
+ */
+export default mcpPlugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAG5B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,CA0IhE;AAGD,OAAO,EAAE,SAAS,EAAE,CAAC;AAErB;;GAEG;AACH,eAAe,SAAS,CAAC"}

package/dist/index.js

@@ -1,14 +1,130 @@
-export { MCPClient } from "./client.js";
-export * from "./server.js";
-export * from "./config.js";
-// Re-export tools
-export * from "./tools/document-tools.js";
-export * from "./tools/index-tools.js";
-export * from "./tools/search-tools.js";
-export * from "./tools/settings-tools.js";
-export * from "./tools/system-tools.js";
-export * from "./tools/task-tools.js";
-export * from "./tools/vector-tools.js";
-// Re-export utils
-export * from "./utils/api-handler.js";
-export * from "./utils/error-handler.js";
+import { MCPClient } from "./client.js";
+import { initServer } from "./server.js";
+import { randomUUID } from "node:crypto";
+import { createErrorResponse } from "./utils/error-handler.js";
+/**
+ * Creates a Vite plugin that integrates with the MCP server
+ * @param options Configuration options for the MCP server
+ * @returns A Vite plugin
+ */
+export function mcpPlugin(options = {}) {
+    const pluginId = `mcp-plugin-${randomUUID().slice(0, 8)}`;
+    let mcpServerInstance = null;
+    // Set default options
+    const transport = options.transport || "http";
+    return {
+        name: "vite:mcp-plugin",
+        apply: "serve", // Only apply this plugin during development
+        configureServer(server) {
+            // Store the custom config in Vite's server context for sharing
+            server.config.env.VITE_MCP_PLUGIN_ID = pluginId;
+            // Configure process.env variables with MCP server options
+            if (options.httpPort)
+                process.env.MCP_HTTP_PORT = String(options.httpPort);
+            if (options.mcpEndpoint)
+                process.env.MCP_ENDPOINT = options.mcpEndpoint;
+            if (options.serverName)
+                process.env.MCP_SERVER_NAME = options.serverName;
+            if (options.serverVersion)
+                process.env.MCP_SERVER_VERSION = options.serverVersion;
+            if (options.sessionTimeout)
+                process.env.MCP_SESSION_TIMEOUT = String(options.sessionTimeout);
+            if (options.sessionCleanupInterval)
+                process.env.MCP_SESSION_CLEANUP_INTERVAL = String(options.sessionCleanupInterval);
+            // Add CORS middleware
+            server.middlewares.use((req, res, next) => {
+                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;
+                }
+                next();
+            });
+            // Handle MCP endpoint requests
+            server.middlewares.use(async (req, res, next) => {
+                const mcpEndpoint = options.mcpEndpoint || "/mcp";
+                const url = req.url || "/";
+                if (url.startsWith(mcpEndpoint)) {
+                    // Only proceed if MCP server is initialized
+                    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 {
+                        next();
+                    }
+                }
+                else {
+                    next();
+                }
+            });
+            // Start the MCP server when Vite server is ready
+            server.httpServer?.on("listening", async () => {
+                console.log(`Vite server is ready, initializing MCP server with ${transport} transport`);
+                try {
+                    // Initialize the MCP server
+                    const serverInstances = await initServer(transport);
+                    mcpServerInstance = serverInstances.mcpServer;
+                    const hostConfig = server.config.server;
+                    const protocol = hostConfig.https ? "https" : "http";
+                    const host = hostConfig.host === true
+                        ? "localhost"
+                        : hostConfig.host || "localhost";
+                    const port = hostConfig.port || 3000;
+                    const mcpEndpoint = options.mcpEndpoint || "/mcp";
+                    console.log(`MCP server initialized with ${transport} transport`);
+                    console.log(`MCP endpoint available at: ${protocol}://${host}:${port}${mcpEndpoint}`);
+                }
+                catch (error) {
+                    console.error("Failed to initialize MCP server:", error);
+                }
+            });
+        },
+        closeBundle() {
+            // Clean up resources when Vite is shutting down
+            if (mcpServerInstance) {
+                try {
+                    console.log("Shutting down MCP server...");
+                    if (typeof mcpServerInstance.shutdown === "function") {
+                        mcpServerInstance.shutdown();
+                    }
+                }
+                catch (error) {
+                    console.error("Error shutting down MCP server:", error);
+                }
+            }
+        },
+    };
+}
+// Export the MCPClient class for external use
+export { MCPClient };
+/**
+ * Default export for convenience
+ */
+export default mcpPlugin;

package/dist/server.d.ts

@@ -1,7 +1,102 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Configuration for the MCP server
+ */
+interface ServerConfig {
+    httpPort: number;
+    mcpEndpoint: string;
+    serverName: string;
+    serverVersion: string;
+    sessionTimeout: number;
+    sessionCleanupInterval: number;
+}
+/**
+ * Implementation of an MCP server for Meilisearch
+ */
+declare class MCPServer {
+    private readonly JSON_RPC;
+    private readonly SESSION_ID_HEADER_NAME;
+    private server;
+    private cleanupInterval;
+    private sessions;
+    private config;
+    /**
+     * Creates a new MCP server instance
+     * @param server The underlying MCP server implementation
+     * @param config Configuration options
+     */
+    constructor(server: McpServer, config?: Partial<ServerConfig>);
+    /**
+     * Handles an HTTP GET request
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleGetRequest(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    /**
+     * Handles an HTTP POST request (executes MCP commands)
+     * @param req The HTTP request
+     * @param res The HTTP response
+     * @param body The request body
+     */
+    handlePostRequest(req: IncomingMessage, res: ServerResponse, body: any): Promise<void>;
+    /**
+     * Clean up and release server resources
+     */
+    shutdown(): void;
+    /**
+     * Handles the initial connection request
+     * @param req The HTTP request
+     * @param res The HTTP response
+     * @param body The request body
+     */
+    private handleInitializeRequest;
+    /**
+     * Sends a notification about tool list changes
+     */
+    private sendToolListChangedNotification;
+    /**
+     * Sends a notification through the transport
+     */
+    private sendNotification;
+    /**
+     * Checks if the request body represents an initialize request
+     */
+    private isInitializeRequest;
+    /**
+     * Extracts session ID from request headers
+     */
+    private extractSessionId;
+    /**
+     * Updates the activity timestamp for a session
+     */
+    private updateSessionActivity;
+    /**
+     * Sends an error response with the specified status code and message
+     */
+    private sendErrorResponse;
+    /**
+     * Starts the session cleanup process
+     */
+    private startSessionCleanup;
+    /**
+     * Removes expired sessions
+     */
+    private cleanupExpiredSessions;
+}
+/**
+ * Return type for the initServer function
+ */
+export interface ServerInstances {
+    mcpServer?: MCPServer;
+    viteServer?: any;
+}
 /**
  * Initialize the MCP server with the specified transport
  * @param transport The transport type to use ("stdio" or "http")
+ * @returns A promise that resolves to the server instances
  * @throws Error if the transport type is unsupported
  */
-export declare const initServer: (transport: "stdio" | "http") => void;
+export declare const initServer: (transport: "stdio" | "http") => Promise<ServerInstances>;
+export {};
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAieA;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,WAAW,OAAO,GAAG,MAAM,KAAG,IAcxD,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAgBvD,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE;;GAEG;AACH,UAAU,YAAY;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAmBD;;GAEG;AACH,cAAM,SAAS;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAoB;IAE3D,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,MAAM,CAAe;IAE7B;;;;OAIG;gBACS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAQjE;;;;OAIG;IACG,gBAAgB,CACpB,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;OAKG;IACG,iBAAiB,CACrB,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,GAAG,GACR,OAAO,CAAC,IAAI,CAAC;IAkChB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAsBhB;;;;;OAKG;YACW,uBAAuB;IA6CrC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAWvC;;OAEG;YACW,gBAAgB;IAmB9B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;CA4B/B;AAyKD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,UAAU,CAAC,EAAE,GAAG,CAAC;CAClB;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GACrB,WAAW,OAAO,GAAG,MAAM,KAC1B,OAAO,CAAC,eAAe,CAezB,CAAC"}

package/dist/server.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { createServer as createViteServer } from "vite";
 import { InitializeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import registerTaskTools from "./tools/task-tools.js";
 import registerIndexTools from "./tools/index-tools.js";
@@ -8,7 +9,6 @@ import registerVectorTools from "./tools/vector-tools.js";
 import registerDocumentTools from "./tools/document-tools.js";
 import registerSettingsTools from "./tools/settings-tools.js";
 import { createErrorResponse } from "./utils/error-handler.js";
-import express from "express";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -27,9 +27,8 @@ class MCPServer {
     JSON_RPC = "2.0";
     SESSION_ID_HEADER_NAME = "mcp-session-id";
     server;
-    sessions = new Map();
-    toolsRegistered = false;
     cleanupInterval = null;
+    sessions = new Map();
     config;
     /**
      * Creates a new MCP server instance
@@ -39,7 +38,6 @@ class MCPServer {
     constructor(server, config = {}) {
         this.server = server;
         this.config = { ...DEFAULT_CONFIG, ...config };
-        this.toolsRegistered = this.registerTools();
         // Start session cleanup if using HTTP transport
         this.startSessionCleanup();
     }
@@ -76,21 +74,22 @@ class MCPServer {
      * Handles an HTTP POST request (executes MCP commands)
      * @param req The HTTP request
      * @param res The HTTP response
+     * @param body The request body
      */
-    async handlePostRequest(req, res) {
+    async handlePostRequest(req, res, body) {
         const sessionId = this.extractSessionId(req);
         try {
             // Case 1: Existing session
             if (sessionId && this.sessions.has(sessionId)) {
                 console.log(`POST request for existing session ${sessionId}`);
                 const sessionInfo = this.sessions.get(sessionId);
-                await sessionInfo.transport.handleRequest(req, res, req.body);
+                await sessionInfo.transport.handleRequest(req, res, body);
                 this.updateSessionActivity(sessionId);
                 return;
             }
             // Case 2: Initialize request
-            if (!sessionId && this.isInitializeRequest(req.body)) {
-                await this.handleInitializeRequest(req, res);
+            if (!sessionId && this.isInitializeRequest(body)) {
+                await this.handleInitializeRequest(req, res, body);
                 return;
             }
             // Case 3: Invalid request
@@ -128,8 +127,9 @@ class MCPServer {
      * Handles the initial connection request
      * @param req The HTTP request
      * @param res The HTTP response
+     * @param body The request body
      */
-    async handleInitializeRequest(req, res) {
+    async handleInitializeRequest(req, res, body) {
         console.log("Handling initialize request");
         const newSessionId = randomUUID();
         const transport = new StreamableHTTPServerTransport({
@@ -143,7 +143,7 @@ class MCPServer {
             res.setHeader(this.SESSION_ID_HEADER_NAME, newSessionId);
             res.setHeader("Access-Control-Expose-Headers", this.SESSION_ID_HEADER_NAME);
             // Handle the initialize request
-            await transport.handleRequest(req, res, req.body);
+            await transport.handleRequest(req, res, body);
             // Register the session
             this.sessions.set(newSessionId, {
                 transport,
@@ -159,30 +159,6 @@ class MCPServer {
             this.sendErrorResponse(res, 500, `Failed to initialize: ${error}`);
         }
     }
-    /**
-     * Registers all available tools with the MCP server
-     */
-    registerTools() {
-        try {
-            console.log("Registering MCP tools...");
-            const tools = [
-                registerSystemTools,
-                registerIndexTools,
-                registerSearchTools,
-                registerSettingsTools,
-                registerDocumentTools,
-                registerTaskTools,
-                registerVectorTools,
-            ];
-            tools.forEach((registerFn) => registerFn(this.server));
-            console.log("Successfully registered all tools");
-            return true;
-        }
-        catch (error) {
-            console.error("Failed to register tools:", error);
-            return false;
-        }
-    }
     /**
      * Sends a notification about tool list changes
      */
@@ -226,7 +202,8 @@ class MCPServer {
      * Extracts session ID from request headers
      */
     extractSessionId(req) {
-        return req.headers[this.SESSION_ID_HEADER_NAME.toLowerCase()];
+        const headerValue = req.headers[this.SESSION_ID_HEADER_NAME.toLowerCase()];
+        return Array.isArray(headerValue) ? headerValue[0] : headerValue;
     }
     /**
      * Updates the activity timestamp for a session
@@ -241,7 +218,9 @@ class MCPServer {
      * Sends an error response with the specified status code and message
      */
     sendErrorResponse(res, status, message) {
-        res.status(status).json(createErrorResponse(message));
+        res.statusCode = status;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(createErrorResponse(message)));
     }
     /**
      * Starts the session cleanup process
@@ -282,102 +261,163 @@ class MCPServer {
     }
 }
 /**
- * Initialize the MCP server with HTTP transport
+ * Initialize the MCP server with HTTP transport using Vite
  */
-const initServerHTTPTransport = () => {
-    const config = DEFAULT_CONFIG;
+const initServerHTTPTransport = async () => {
+    const config = {
+        ...DEFAULT_CONFIG,
+        httpPort: process.env.MCP_HTTP_PORT
+            ? parseInt(process.env.MCP_HTTP_PORT, 10)
+            : DEFAULT_CONFIG.httpPort,
+        mcpEndpoint: process.env.MCP_ENDPOINT || DEFAULT_CONFIG.mcpEndpoint,
+        serverName: process.env.MCP_SERVER_NAME || DEFAULT_CONFIG.serverName,
+        serverVersion: process.env.MCP_SERVER_VERSION || DEFAULT_CONFIG.serverVersion,
+        sessionTimeout: process.env.MCP_SESSION_TIMEOUT
+            ? parseInt(process.env.MCP_SESSION_TIMEOUT, 10)
+            : DEFAULT_CONFIG.sessionTimeout,
+        sessionCleanupInterval: process.env.MCP_SESSION_CLEANUP_INTERVAL
+            ? parseInt(process.env.MCP_SESSION_CLEANUP_INTERVAL, 10)
+            : DEFAULT_CONFIG.sessionCleanupInterval,
+    };
     const serverInstance = new McpServer({
         name: config.serverName,
         version: config.serverVersion,
     });
+    // Register all tools
+    registerIndexTools(serverInstance);
+    registerDocumentTools(serverInstance);
+    registerSearchTools(serverInstance);
+    registerSettingsTools(serverInstance);
+    registerVectorTools(serverInstance);
+    registerSystemTools(serverInstance);
+    registerTaskTools(serverInstance);
     const server = new MCPServer(serverInstance, config);
-    const app = express();
-    app.use(express.json());
-    // Configure CORS and preflight handling
-    app.use((req, res, next) => {
-        res.header("Access-Control-Allow-Origin", "*");
-        res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.header("Access-Control-Allow-Headers", `Origin, X-Requested-With, Content-Type, Accept, ${server["SESSION_ID_HEADER_NAME"]}`);
-        if (req.method === "OPTIONS") {
-            res.sendStatus(200);
-            return;
-        }
-        next();
-    });
-    // Set up routes
-    const router = express.Router();
-    router.post(config.mcpEndpoint, async (req, res) => {
-        console.log(`Received POST request to ${config.mcpEndpoint}`);
-        await server.handlePostRequest(req, res);
-    });
-    router.get(config.mcpEndpoint, async (req, res) => {
-        console.log(`Received GET request to ${config.mcpEndpoint}`);
-        await server.handleGetRequest(req, res);
-    });
-    app.use("/", router);
-    // Start the server
-    const httpServer = app.listen(config.httpPort, () => {
-        console.log("Meilisearch MCP Server is running on http transport:", `http://localhost:${config.httpPort}${config.mcpEndpoint}`);
-    });
-    // Handle server shutdown
-    process.on("SIGINT", async () => {
-        console.log("Received SIGINT signal");
-        server.shutdown();
-        httpServer.close(() => {
-            console.log("HTTP server closed");
+    const isPluginMode = process.env.VITE_MCP_PLUGIN_ID !== undefined;
+    let vite;
+    if (!isPluginMode) {
+        vite = await createViteServer({
+            server: {
+                port: config.httpPort,
+                middlewareMode: true,
+            },
+        });
+        // Add CORS middleware
+        vite.middlewares.use((req, res, next) => {
+            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, ${server["SESSION_ID_HEADER_NAME"]}`);
+            if (req.method === "OPTIONS") {
+                res.statusCode = 200;
+                res.end();
+                return;
+            }
+            next();
+        });
+        vite.middlewares.use(async (req, res, next) => {
+            const url = req.url || "/";
+            if (url.startsWith(config.mcpEndpoint)) {
+                if (req.method === "GET") {
+                    await server.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 server.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 {
+                    next();
+                }
+            }
+            else {
+                next();
+            }
+        });
+        console.log("Meilisearch MCP Server is running on Vite HTTP transport (standalone mode):", `http://localhost:${config.httpPort}${config.mcpEndpoint}`);
+        // Handle server shutdown in standalone mode
+        process.on("SIGINT", async () => {
+            console.log("Received SIGINT signal");
+            server.shutdown();
+            if (vite) {
+                await vite.close();
+                console.log("Vite server closed");
+            }
             process.exit(0);
         });
-        // Force exit after timeout
-        setTimeout(() => {
-            console.log("Forcing process exit");
-            process.exit(1);
-        }, 5000);
-    });
+    }
+    else {
+        console.log("Meilisearch MCP Server is running on Vite HTTP transport (plugin mode):", `${config.mcpEndpoint}`);
+    }
+    // Return both server instances for proper cleanup
+    return { mcpServer: server, viteServer: vite };
 };
 /**
  * Initialize the MCP server with stdio transport
+ * @returns MCP server instance
  */
 const initServerStdioTransport = async () => {
-    const config = DEFAULT_CONFIG;
-    const server = new McpServer({
+    // Use environment variables if available, otherwise use defaults
+    const config = {
+        ...DEFAULT_CONFIG,
+        serverName: process.env.MCP_SERVER_NAME || DEFAULT_CONFIG.serverName,
+        serverVersion: process.env.MCP_SERVER_VERSION || DEFAULT_CONFIG.serverVersion,
+    };
+    const serverInstance = new McpServer({
         name: config.serverName,
         version: config.serverVersion,
     });
     // Register all tools
-    registerIndexTools(server);
-    registerDocumentTools(server);
-    registerSearchTools(server);
-    registerSettingsTools(server);
-    registerVectorTools(server);
-    registerSystemTools(server);
-    registerTaskTools(server);
+    registerIndexTools(serverInstance);
+    registerDocumentTools(serverInstance);
+    registerSearchTools(serverInstance);
+    registerSettingsTools(serverInstance);
+    registerVectorTools(serverInstance);
+    registerSystemTools(serverInstance);
+    registerTaskTools(serverInstance);
+    // Create MCPServer instance
+    const server = new MCPServer(serverInstance, config);
     // Connect stdio transport
     const transport = new StdioServerTransport();
-    await server.connect(transport);
+    await serverInstance.connect(transport);
     console.log("Meilisearch MCP Server is running on stdio transport");
     // Handle process termination
     process.on("SIGINT", () => {
         console.log("Shutting down stdio server...");
         process.exit(0);
     });
+    return server;
 };
 /**
  * Initialize the MCP server with the specified transport
  * @param transport The transport type to use ("stdio" or "http")
+ * @returns A promise that resolves to the server instances
  * @throws Error if the transport type is unsupported
  */
-export const initServer = (transport) => {
-    switch (transport) {
-        case "stdio":
-            initServerStdioTransport().catch((error) => {
-                console.error("Fatal error initializing stdio transport:", error);
-                process.exit(1);
-            });
-            break;
-        case "http":
-            initServerHTTPTransport();
-            break;
-        default:
-            throw new Error(`Unsupported transport type: ${transport}`);
+export const initServer = async (transport) => {
+    try {
+        switch (transport) {
+            case "stdio":
+                const stdioServer = await initServerStdioTransport();
+                return { mcpServer: stdioServer };
+            case "http":
+                return await initServerHTTPTransport();
+            default:
+                throw new Error(`Unsupported transport type: ${transport}`);
+        }
+    }
+    catch (error) {
+        console.error(`Fatal error initializing ${transport} transport:`, error);
+        throw error;
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-meilisearch",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "Model Context Protocol (MCP) implementation for Meilisearch",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,17 +24,12 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.10.1",
     "axios": "^1.9.0",
-    "express": "^5.1.0",
-    "vue": "^3.5.13",
+    "vite": "^6.3.5",
     "zod": "^3.24.4"
   },
   "devDependencies": {
-    "@types/express": "^5.0.1",
     "@types/node": "^22.14.0",
-    "@vitejs/plugin-vue": "^5.2.3",
-    "@vue/tsconfig": "^0.7.0",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5"
+    "typescript": "^5.8.3"
   },
   "engines": {
     "node": ">=20.12.2",