mcp-meilisearch 1.0.2 → 1.0.5

package/dist/client.d.ts

@@ -0,0 +1,27 @@
+export declare class MCPClient {
+    tools: {
+        name: string;
+        description: string;
+    }[];
+    private client;
+    private tries;
+    private transport;
+    private onToolsUpdatedCallback;
+    constructor(serverName: string);
+    setOnToolsUpdatedCallback(callback: (tools: Array<{
+        name: string;
+        description: string;
+    }>) => void): void;
+    connectToServer(serverUrl: string): Promise<void>;
+    listTools(): Promise<void>;
+    private setUpNotifications;
+    callTool(name: string, args?: Record<string, any>): Promise<{
+        success: boolean;
+        data?: any;
+        error?: string;
+    }>;
+    private setUpTransport;
+    cleanup(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAQA,qBAAa,SAAS;IACpB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,CAAM;IAEpD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,sBAAsB,CAEd;gBAEJ,UAAU,EAAE,MAAM;IAOvB,yBAAyB,CAC9B,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI;IAKnE,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBjD,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAsChC,OAAO,CAAC,kBAAkB;IAkBpB,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAuCF,OAAO,CAAC,cAAc;IAWhB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAUxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Meilisearch MCP Server Configuration
+ *
+ * This file contains the configuration settings for connecting to the Meilisearch server.
+ * Configuration is loaded from environment variables with sensible defaults.
+ */
+export interface ServerConfig {
+    /** The URL of the Meilisearch instance */
+    host: string;
+    /** The API key for authenticating with Meilisearch */
+    apiKey: string;
+    /** The timeout for API requests in milliseconds */
+    timeout: number;
+}
+/**
+ * Load and initialize configuration from environment variables
+ */
+export declare const loadConfig: () => ServerConfig;
+export declare const config: ServerConfig;
+export default config;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,MAAM,WAAW,YAAY;IAC3B,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,QAAO,YAM7B,CAAC;AAGF,eAAO,MAAM,MAAM,cAAe,CAAC;AAGnC,eAAe,MAAM,CAAC"}

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/http.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import { Plugin } from "vite";
+/**
+ * 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;
+/**
+ * Default export for convenience
+ */
+export default mcpPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAK9B;;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;AAED;;GAEG;AACH,eAAe,SAAS,CAAC"}

package/dist/index.js

@@ -1,2 +1,127 @@
-export { MCPClient } from "./client.js";
-export { initServer } from "./server.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);
+                }
+            }
+        },
+    };
+}
+/**
+ * Default export for convenience
+ */
+export default mcpPlugin;

package/dist/server.d.ts

@@ -0,0 +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") => Promise<ServerInstances>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"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/dist/stdio.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stdio.d.ts.map

package/dist/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":""}

package/dist/tools/document-tools.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register document management tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerDocumentTools: (server: McpServer) => void;
+export default registerDocumentTools;
+//# sourceMappingURL=document-tools.d.ts.map

package/dist/tools/document-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-tools.d.ts","sourceRoot":"","sources":["../../src/tools/document-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAiDpE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,SAAS,SAkQtD,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/tools/index-tools.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register index management tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerIndexTools: (server: McpServer) => void;
+export default registerIndexTools;
+//# sourceMappingURL=index-tools.d.ts.map

package/dist/tools/index-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-tools.d.ts","sourceRoot":"","sources":["../../src/tools/index-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAoCpE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,SAAS,SA6KnD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/tools/search-tools.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register search tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerSearchTools: (server: McpServer) => void;
+export default registerSearchTools;
+//# sourceMappingURL=search-tools.d.ts.map

package/dist/tools/search-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-tools.d.ts","sourceRoot":"","sources":["../../src/tools/search-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAkCpE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,SAAS,SA2QpD,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/tools/settings-tools.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Meilisearch Settings Management Tools
+ *
+ * This module implements MCP tools for managing index settings in Meilisearch.
+ */
+/**
+ * Register settings management tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerSettingsTools: (server: McpServer) => void;
+export default registerSettingsTools;
+//# sourceMappingURL=settings-tools.d.ts.map

package/dist/tools/settings-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-tools.d.ts","sourceRoot":"","sources":["../../src/tools/settings-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE;;;;GAIG;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,SAAS,SA0VtD,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/tools/system-tools.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Meilisearch System Tools
+ *
+ * This module implements MCP tools for system operations in Meilisearch.
+ */
+/**
+ * Register system tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerSystemTools: (server: McpServer) => void;
+export default registerSystemTools;
+//# sourceMappingURL=system-tools.d.ts.map

package/dist/tools/system-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-tools.d.ts","sourceRoot":"","sources":["../../src/tools/system-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE;;;;GAIG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,SAAS,SAyOpD,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/tools/task-tools.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register task management tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerTaskTools: (server: McpServer) => void;
+export default registerTaskTools;
+//# sourceMappingURL=task-tools.d.ts.map

package/dist/tools/task-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmCpE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,SAAS,SAyNlD,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/dist/tools/task-tools.js

@@ -160,7 +160,7 @@ export const registerTaskTools = (server) => {
                 const response = await apiClient.get(`/tasks/${taskUid}`);
                 taskData = response.data;
                 // Check if the task has completed
-                if (["succeeded", "failed", "canceled"].includes(taskData.status)) {
+                if (["succeeded", "failed", "canceled"].includes(response.statusText)) {
                     taskCompleted = true;
                 }
                 else {

package/dist/tools/vector-tools.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Meilisearch Vector Search Tools
+ *
+ * This module implements MCP tools for vector search capabilities in Meilisearch.
+ * Note: Vector search is an experimental feature in Meilisearch.
+ */
+/**
+ * Register vector search tools with the MCP server
+ *
+ * @param server - The MCP server instance
+ */
+export declare const registerVectorTools: (server: McpServer) => void;
+export default registerVectorTools;
+//# sourceMappingURL=vector-tools.d.ts.map

package/dist/tools/vector-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-tools.d.ts","sourceRoot":"","sources":["../../src/tools/vector-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE;;;;;GAKG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,SAAS,SAmQpD,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/utils/api-handler.d.ts

@@ -0,0 +1,27 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+/**
+ * Meilisearch API client
+ *
+ * This module provides a configured Axios instance for making requests to the Meilisearch API.
+ */
+/**
+ * Creates a configured Axios instance for Meilisearch API requests
+ *
+ * @returns An Axios instance with base configuration
+ */
+export declare const createApiClient: () => {
+    get: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    post: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    put: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    patch: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    delete: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+};
+export declare const apiClient: {
+    get: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    post: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    put: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    patch: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+    delete: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
+};
+export default apiClient;
+//# sourceMappingURL=api-handler.d.ts.map

package/dist/utils/api-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-handler.d.ts","sourceRoot":"","sources":["../../src/utils/api-handler.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAIjE;;;;GAIG;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe;UAWlB,CAAC,aAAa,MAAM,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;WAE5E,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;UAE1F,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YAEvF,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;aAExF,CAAC,aAAa,MAAM,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;CAGzF,CAAC;AAGF,eAAO,MAAM,SAAS;UAdZ,CAAC,aAAa,MAAM,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;WAE5E,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;UAE1F,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YAEvF,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;aAExF,CAAC,aAAa,MAAM,WAAW,kBAAkB,KAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;CAMhD,CAAC;AAG3C,eAAe,SAAS,CAAC"}

package/dist/utils/error-handler.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Error handling utilities for Meilisearch API responses
+ */
+/**
+ * Formats Meilisearch API errors for consistent error messaging
+ *
+ * @param error - The error from the API request
+ * @returns A formatted error message
+ */
+export declare const handleApiError: (error: any) => string;
+/**
+ * Creates a standardized error response object for MCP tools
+ *
+ * @param error - The error from the API request
+ * @returns An MCP tool response object with error flag
+ */
+export declare const createErrorResponse: (error: any) => {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+};
+declare const _default: {
+    handleApiError: (error: any) => string;
+    createErrorResponse: (error: any) => {
+        isError: boolean;
+        content: {
+            type: string;
+            text: string;
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/utils/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../src/utils/error-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,GAAG,KAAG,MAU3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,GAAG;;;;;;CAK7C,CAAC;;4BAvBoC,GAAG,KAAG,MAAM;iCAkBP,GAAG;;;;;;;;AAO9C,wBAGE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-meilisearch",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "Model Context Protocol (MCP) implementation for Meilisearch",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,27 +13,23 @@
     "client"
   ],
   "scripts": {
-    "serve:http": "tsc && chmod 755 dist/http.js",
-    "serve:stdio": "tsc && chmod 755 dist/stdio.js",
+    "build": "tsc && tsc --project tsconfig.types.json",
+    "serve:http": "npm run build && chmod 755 dist/http.js",
+    "serve:stdio": "npm run build && chmod 755 dist/stdio.js",
     "server": "npm run serve:stdio && node --env-file=.env dist/stdio.js",
     "client": "npm run serve:http && node --env-file=.env dist/http.js & npm run preview --workspace=client",
     "prepare": "npm version patch",
-    "prepublishOnly": "tsc"
+    "prepublishOnly": "npm run build"
   },
   "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",