@toolsdk.ai/registry 1.0.102 → 1.0.104

package/README.md

@@ -106,9 +106,9 @@ For more detail please see [the guide](./docs/guide.md).
 
 # MCP Servers
 
-✅: Validated and runnable tools (720)
+✅: Validated and runnable tools (721)
 
-❌: Cannot be run by the MCP client (with mock environments variables (3384))
+❌: Cannot be run by the MCP client (with mock environments variables (3383))
 
 
 
@@ -522,7 +522,7 @@ Tools for browsing, scraping, and automating web content in AI-compatible format
 - [❌ puppeteer-browser-automation](https://github.com/twolven/mcp-server-puppeteer-py): Integrates with Puppeteer to provide browser automation capabilities for web navigation, interaction, and data extraction.  (python) 
 - [❌ awesome-cursor](https://github.com/kleneway/awesome-cursor-mpc-server): Built for Cursor, integrates screenshot capture, web page structure analysis, and code review capabilities for automated UI testing, web scraping, and code quality checks.  (node) 
 - [❌ screenshotone-mcp-server](https://github.com/mrgoonie/screenshotone-mcp-server): Enables AI to capture and process screenshots of webpages with customizable parameters through the ScreenshotOne API with Cloudflare CDN integration for image storage and retrieval.  (node) 
-- [❌ tavily-mcp](https://github.com/tavily-ai/tavily-mcp): Integrates with Tavily API to provide real-time web search and content extraction capabilities for research, aggregation, and fact-checking tasks.  (node) 
+- [✅ tavily-mcp](https://github.com/tavily-ai/tavily-mcp): Integrates with Tavily API to provide real-time web search and content extraction capabilities for research, aggregation, and fact-checking tasks.  (4 tools) (node) 
 - [✅ mcp-jinaai-grounding](https://github.com/spences10/mcp-jinaai-grounding): Integrates JinaAI's content extraction and analysis capabilities for web scraping, documentation parsing, and text analysis tasks.  (1 tools) (node) 
 - [❌ website-to-markdown-converter](https://github.com/tolik-unicornrider/mcp_scraper): Converts web content to high-quality Markdown using Mozilla's Readability and TurndownService, enabling clean extraction of meaningful content from URLs or HTML files for analysis and document conversion.  (node) 
 - [❌ web-browser-(playwright)](https://github.com/random-robbie/mcp-web-browser): Integrates with Playwright to enable cross-browser web automation for tasks like scraping, testing, and content extraction.  (python) 
@@ -3110,7 +3110,7 @@ Find and extract data from various sources quickly and efficiently.
 - [❌ geeknews](https://github.com/the0807/geeknews-mcp-server): Retrieves and extracts tech news, articles, and discussions from GeekNews using BeautifulSoup for more informed conversations about current technology developments.  (python) 
 - [✅ @toolsdk.ai/tavily-mcp](https://github.com/tavily-ai/tavily-mcp): An MCP server that implements web search, extract, mapping, and crawling through the Tavily API.  (4 tools) (node) 
 - [❌ goodnews](https://github.com/vectorinstitute/mcp-goodnews): Filters and ranks news articles from NewsAPI based on positive sentiment, delivering uplifting headlines amid potentially negative media cycles.  (python) 
-- [❌ tavily-mcp](https://github.com/tavily-ai/tavily-mcp): Integrates with Tavily API to provide real-time web search and content extraction capabilities for research, aggregation, and fact-checking tasks.  (node) 
+- [✅ tavily-mcp](https://github.com/tavily-ai/tavily-mcp): Integrates with Tavily API to provide real-time web search and content extraction capabilities for research, aggregation, and fact-checking tasks.  (4 tools) (node) 
 - [✅ anilist-mcp](https://github.com/yuna0x0/anilist-mcp): MCP server that interfaces with the AniList API, allowing LLM clients to access and interact with anime, manga, character, staff, and user data from AniList  (44 tools) (node) 
 - [❌ exa-web-search](https://github.com/mshojaei77/reactmcp): Integrates with Exa API to enable web search capabilities with filtering options for domains, text requirements, and date ranges, returning markdown-formatted results with titles, URLs, publication dates, and content summaries for real-time internet information access.  (python) 
 - [❌ web-browser-mcp-server](https://github.com/blazickjp/web-browser-mcp-server): Integrates web browsing capabilities for realtime data retrieval, content extraction, and task automation using popular Python libraries.  (python) 

package/dist/api/index.js

@@ -1,20 +1,54 @@
+import fs from "node:fs/promises";
 import path from "node:path";
 import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import dotenv from "dotenv";
+import { searchRoutes } from "../search/search-route";
+import searchService from "../search/search-service";
+import { getDirname } from "../utils";
 import { packageRoutes } from "./package-route";
+const __dirname = getDirname(import.meta.url);
 dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
 dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+const initializeSearchService = async () => {
+    try {
+        await searchService.initialize();
+        console.log("🔍 Search service initialized");
+    }
+    catch (error) {
+        console.warn("⚠️  Search service initialization failed:", error.message);
+        console.log("💡 Install and start MeiliSearch to enable enhanced search features");
+    }
+};
 const app = new OpenAPIHono();
 app.route("/api/v1", packageRoutes);
-app.get("/", (c) => {
-    return c.text("MCP Registry API Server is running!");
+if (process.env.ENABLE_SEARCH === "true") {
+    initializeSearchService().catch(console.error);
+    app.route("/api/v1", searchRoutes);
+}
+app.get("/", async (c) => {
+    try {
+        const htmlPath = path.join(__dirname, "..", "search", "search.html");
+        const html = await fs.readFile(htmlPath, "utf8");
+        return c.html(html);
+    }
+    catch (error) {
+        console.error("Failed to load home page:", error);
+        return c.text("MCP Registry API Server is running!");
+    }
 });
-app.get("/api/meta", (c) => {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const packageJson = require("../../package.json");
-    return c.json({ version: packageJson.version });
+app.get("/api/meta", async (c) => {
+    try {
+        const packageJson = await import("../../package.json", {
+            assert: { type: "json" },
+        });
+        return c.json({ version: packageJson.default.version });
+    }
+    catch (error) {
+        console.error("Failed to load package.json:", error);
+        return c.json({ version: "unknown" });
+    }
 });
 app.doc("/api/v1/doc", {
     openapi: "3.0.0",
@@ -31,7 +65,7 @@ app.onError((err, c) => {
     console.error("Server Error:", err);
     return c.json({ success: false, code: 500, message: "Internal server error" }, 500);
 });
-const port = process.env.MCP_SERVER_PORT ? parseInt(process.env.MCP_SERVER_PORT, 10) : 3000;
+const port = process.env.MCP_SERVER_PORT ? parseInt(process.env.MCP_SERVER_PORT, 10) : 3003;
 console.log(`Server is running on: http://localhost:${port}`);
 serve({
     fetch: app.fetch,

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

@@ -9,11 +9,11 @@ export declare const packageHandler: {
         success: boolean;
         code: number;
         message: string;
-    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;
-    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;
@@ -77,11 +77,11 @@ export declare const packageHandler: {
         success: boolean;
         code: number;
         message: string;
-    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;
-    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;

package/dist/api/package-route.js

@@ -1,17 +1,20 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
+import path from "node:path";
 import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
 import { getPythonDependencies } from "../helper";
 import { CategoriesResponseSchema, ExecuteToolResponseSchema, FeaturedResponseSchema, PackageDetailResponseSchema, PackagesListResponseSchema, packageNameQuerySchema, ToolExecuteSchema, ToolsResponseSchema, } from "../schema";
-import { createResponse, createRouteResponses } from "../utils";
+import { createResponse, createRouteResponses, getDirname } from "../utils";
 import { packageHandler } from "./package-handler";
+const __dirname = getDirname(import.meta.url);
 export const packageRoutes = new OpenAPIHono();
 const featuredRoute = createRoute({
     method: "get",
     path: "/config/featured",
     responses: createRouteResponses(FeaturedResponseSchema),
 });
-packageRoutes.openapi(featuredRoute, (c) => {
-    const featured = require("../../config/featured.mjs").default;
+packageRoutes.openapi(featuredRoute, async (c) => {
+    const featuredPath = path.join(__dirname, "../../config/featured.mjs");
+    const featuredModule = await import(`file://${featuredPath}`);
+    const featured = featuredModule.default;
     const response = createResponse(featured);
     return c.json(response, 200);
 });
@@ -20,8 +23,10 @@ const categoriesRoute = createRoute({
     path: "/config/categories",
     responses: createRouteResponses(CategoriesResponseSchema),
 });
-packageRoutes.openapi(categoriesRoute, (c) => {
-    const categories = require("../../config/categories.mjs").default;
+packageRoutes.openapi(categoriesRoute, async (c) => {
+    const categoriesPath = path.join(__dirname, "../../config/categories.mjs");
+    const categoriesModule = await import(`file://${categoriesPath}`);
+    const categories = categoriesModule.default;
     const response = createResponse(categories);
     return c.json(response, 200);
 });

package/dist/api/package-so.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getMcpClient, getPackageConfigByKey, typedAllPackagesList } from "../helper.js";
+import { getDirname } from "../utils";
+const __dirname = getDirname(import.meta.url);
 export class PackageSO {
     async executeTool(request) {
         const mcpServerConfig = getPackageConfigByKey(request.packageName);

package/dist/helper.d.ts

@@ -11,6 +11,7 @@ export declare const typedAllPackagesList: Record<string, {
     }> | undefined;
 }>;
 export declare function getPackageConfigByKey(packageKey: string): MCPServerPackageConfig;
+export declare function getPackageJSON(packageName: string): any;
 export declare function getMcpClient(mcpServerConfig: MCPServerPackageConfig, env?: Record<string, string>): Promise<{
     client: Client<{
         method: string;

package/dist/helper.js

@@ -7,7 +7,9 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import axios from "axios";
 import semver from "semver";
 import allPackagesList from "../indexes/packages-list.json";
+import { getDirname } from "../src/utils";
 import { MCPServerPackageConfigSchema, PackagesListSchema } from "./schema";
+const __dirname = getDirname(import.meta.url);
 export const typedAllPackagesList = PackagesListSchema.parse(allPackagesList);
 export function getPackageConfigByKey(packageKey) {
     const value = typedAllPackagesList[packageKey];
@@ -20,8 +22,12 @@ export function getPackageConfigByKey(packageKey) {
     const mcpServerConfig = MCPServerPackageConfigSchema.parse(JSON.parse(jsonStr));
     return mcpServerConfig;
 }
-function getPackageJSON(packageName) {
+export function getPackageJSON(packageName) {
     const packageJSONFilePath = `${__dirname}/../node_modules/${packageName}/package.json`;
+    // Check if the package exists in node_modules
+    if (!fs.existsSync(packageJSONFilePath)) {
+        throw new Error(`Package '${packageName}' not found in node_modules. Install it first with: pnpm add ${packageName}`);
+    }
     const packageJSONStr = fs.readFileSync(packageJSONFilePath, "utf8");
     const packageJSON = JSON.parse(packageJSONStr);
     return packageJSON;
@@ -100,6 +106,7 @@ export function updatePackageJsonDependencies({ packageDeps, enableValidation =
         "@hono/swagger-ui": "^0.5.2",
         "@hono/zod-openapi": "^0.16.4",
         "@iarna/toml": "^2.2.5",
+        meilisearch: "^0.33.0",
         lodash: "^4.17.21",
         zod: "^3.23.30",
         axios: "^1.9.0",

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

@@ -0,0 +1,3 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+declare const searchRoutes: OpenAPIHono<import("hono").Env, {}, "/">;
+export { searchRoutes };

package/dist/search/search-route.js

@@ -0,0 +1,305 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { BaseResponseSchema } from "../schema";
+import { createErrorResponse, createResponse, createRouteResponses } from "../utils";
+import searchService from "./search-service";
+const searchRoutes = new OpenAPIHono();
+// Define search query parameter schema
+const searchQuerySchema = z.object({
+    q: z.string().openapi({
+        description: "Search query",
+        example: "database",
+    }),
+    limit: z.coerce.number().min(1).max(100).optional().openapi({
+        description: "Limit the number of results",
+        example: 20,
+    }),
+    offset: z.coerce.number().min(0).optional().openapi({
+        description: "Offset for pagination",
+        example: 0,
+    }),
+    category: z.string().optional().openapi({
+        description: "Filter by category",
+        example: "databases",
+    }),
+});
+// Define search result response schema
+const searchResultSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    packageName: z.string(),
+    description: z.string(),
+    category: z.string(),
+    validated: z.boolean(),
+    author: z.string(),
+    toolCount: z.number(),
+    hasTools: z.boolean(),
+    popularity: z.number(),
+})
+    .openapi("SearchResult");
+const searchResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        hits: z.array(searchResultSchema),
+        query: z.string(),
+        processingTimeMs: z.number(),
+        limit: z.number(),
+        offset: z.number(),
+        estimatedTotalHits: z.number(),
+    })
+        .optional(),
+}).openapi("SearchResponse");
+// Search route definition
+const searchRoute = createRoute({
+    method: "get",
+    path: "/search",
+    request: {
+        query: searchQuerySchema,
+    },
+    responses: createRouteResponses(searchResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(searchRoute, async (c) => {
+    try {
+        const { q, limit, offset, category } = c.req.valid("query");
+        // Build filter condition
+        const filter = category ? `category = '${category}'` : undefined;
+        // Execute search
+        const results = await searchService.search(q, {
+            limit,
+            offset,
+            filter,
+        });
+        const response = createResponse(results);
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Search failed:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Search failed", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+// Define suggest query parameter schema
+const suggestQuerySchema = z.object({
+    q: z.string().openapi({
+        description: "Suggestion query",
+        example: "data",
+    }),
+    limit: z.coerce.number().min(1).max(20).optional().openapi({
+        description: "Limit the number of results",
+        example: 10,
+    }),
+});
+// Define suggest result response schema
+const suggestResultSchema = z
+    .object({
+    name: z.string(),
+    packageName: z.string(),
+    category: z.string(),
+    highlighted: z.string(),
+})
+    .openapi("SuggestResult");
+const suggestResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        suggestions: z.array(suggestResultSchema),
+    })
+        .optional(),
+}).openapi("SuggestResponse");
+// Search suggest route definition
+const suggestRoute = createRoute({
+    method: "get",
+    path: "/search/suggest",
+    request: {
+        query: suggestQuerySchema,
+    },
+    responses: createRouteResponses(suggestResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(suggestRoute, async (c) => {
+    try {
+        const { q, limit } = c.req.valid("query");
+        const suggestions = await searchService.suggest(q, limit);
+        const response = createResponse({ suggestions });
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Failed to get suggestions:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Failed to get suggestions");
+        return c.json(errorResponse, 400);
+    }
+});
+// Define facets response schema
+const facetsResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        categories: z.record(z.string(), z.number()).optional(),
+        authors: z.record(z.string(), z.number()).optional(),
+        validated: z.record(z.string(), z.number()).optional(),
+    })
+        .optional(),
+}).openapi("FacetsResponse");
+// Facets route definition
+const facetsRoute = createRoute({
+    method: "get",
+    path: "/search/facets",
+    responses: createRouteResponses(facetsResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(facetsRoute, async (c) => {
+    try {
+        // Get facets information
+        const facets = await searchService.getFacets();
+        const response = createResponse({
+            categories: facets === null || facets === void 0 ? void 0 : facets.category,
+            authors: facets === null || facets === void 0 ? void 0 : facets.author,
+            validated: facets === null || facets === void 0 ? void 0 : facets.validated,
+        });
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Failed to get facets:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Failed to get facets", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+// Define health check response schema
+const healthResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        status: z.string(),
+        host: z.string(),
+        initialized: z.boolean(),
+        indexName: z.string(),
+        documentCount: z.number(),
+    })
+        .optional(),
+}).openapi("HealthResponse");
+// Health check route definition
+const healthRoute = createRoute({
+    method: "get",
+    path: "/search/health",
+    responses: createRouteResponses(healthResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(healthRoute, async (c) => {
+    try {
+        // Perform health check
+        const health = await searchService.healthCheck();
+        const response = createResponse(health);
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Health check failed:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Health check failed", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+// Define management response schema
+const managementResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        message: z.string(),
+        details: z.any().optional(),
+    })
+        .optional(),
+}).openapi("ManagementResponse");
+// Initialize search service route definition
+const initRoute = createRoute({
+    method: "post",
+    path: "/search/manage/init",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(initRoute, async (c) => {
+    try {
+        // Initialize search service
+        await searchService.initialize();
+        const response = createResponse({
+            message: "Search service initialized successfully",
+        });
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Failed to initialize search service:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Failed to initialize search service", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+// Index packages route definition
+const indexRoute = createRoute({
+    method: "post",
+    path: "/search/manage/index",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(indexRoute, async (c) => {
+    try {
+        // Index all packages
+        const stats = await searchService.indexPackages();
+        const response = createResponse({
+            message: `Indexed ${stats.numberOfDocuments} documents`,
+            details: stats,
+        });
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Failed to index packages:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Failed to index packages", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+// Clear index route definition
+const clearRoute = createRoute({
+    method: "post",
+    path: "/search/manage/clear",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(clearRoute, async (c) => {
+    try {
+        // Clear the index
+        await searchService.clearIndex();
+        const response = createResponse({
+            message: "Index cleared successfully",
+        });
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Failed to clear index:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Failed to clear index", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+// Get index stats route definition
+const statsRoute = createRoute({
+    method: "get",
+    path: "/search/manage/stats",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(statsRoute, async (c) => {
+    try {
+        // Get index statistics
+        const stats = await searchService.getStats();
+        const response = createResponse({
+            message: "Index statistics retrieved successfully",
+            details: stats,
+        });
+        return c.json(response, 200);
+    }
+    catch (error) {
+        console.error("Failed to get index statistics:", error.stack);
+        const errorResponse = createErrorResponse(error.message || "Failed to get index statistics", 500);
+        return c.json(errorResponse, 500);
+    }
+});
+export { searchRoutes };

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

@@ -0,0 +1,120 @@
+/**
+ * MeiliSearch Service for Awesome MCP Registry
+ * Handles search indexing and querying for MCP packages
+ */
+import { type Index, MeiliSearch } from "meilisearch";
+interface PackageData {
+    name?: string;
+    description?: string;
+    category?: string;
+    validated?: boolean;
+    tools?: Record<string, {
+        description?: string;
+    }>;
+    path?: string;
+}
+interface SearchOptions {
+    limit?: number;
+    offset?: number;
+    filter?: string | string[];
+    sort?: string[];
+    matchingStrategy?: string;
+}
+interface SearchResults {
+    hits: unknown[];
+    query: string;
+    processingTimeMs: number;
+    limit: number;
+    offset: number;
+    estimatedTotalHits: number;
+}
+interface IndexStats {
+    numberOfDocuments: number;
+    isIndexing: boolean;
+    fieldDistribution: Record<string, number>;
+}
+declare class SearchService {
+    private host;
+    private apiKey;
+    private indexName;
+    protected client: MeiliSearch;
+    protected _index: Index | null;
+    protected isInitialized: boolean;
+    constructor(indexName?: string);
+    /**
+     * Get the initialization status
+     */
+    getIsInitialized(): boolean;
+    /**
+     * Get the MeiliSearch client
+     */
+    getClient(): MeiliSearch;
+    get index(): Index | null;
+    set index(value: Index | null);
+    initialize(): Promise<void>;
+    /**
+     * Configure search index settings for optimal MCP package search
+     */
+    configureIndex(): Promise<void>;
+    /**
+     * Transform package data for search indexing
+     */
+    transformPackageForIndex(packageName: string, packageData: PackageData): Record<string, unknown>;
+    /**
+     * Create a safe ID for MeiliSearch (alphanumeric, hyphens, underscores only)
+     */
+    createSafeId(packageName: string): string;
+    /**
+     * Calculate a popularity score for ranking
+     */
+    calculatePopularityScore(packageData: PackageData): number;
+    /**
+     * Extract author from package name
+     */
+    extractAuthor(packageName: string): string;
+    /**
+     * Extract relevant keywords from package data
+     */
+    extractKeywords(packageData: PackageData, packageName: string): string;
+    /**
+     * Index all packages from the packages-list.json file
+     */
+    indexPackages(): Promise<IndexStats>;
+    /**
+     * Search packages with advanced options
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResults>;
+    /**
+     * Get search suggestions/autocomplete
+     */
+    suggest(query: string, limit?: number): Promise<{
+        name: string;
+        packageName: string;
+        category: string;
+        highlighted: string;
+    }[]>;
+    /**
+     * Get faceted search results (for filters)
+     */
+    getFacets(): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Get index statistics
+     */
+    getStats(): Promise<IndexStats>;
+    /**
+     * Clear the index
+     */
+    clearIndex(): Promise<void>;
+    /**
+     * Health check for the search service
+     */
+    healthCheck(): Promise<{
+        status: string;
+        host: string;
+        initialized: boolean;
+        indexName: string;
+        documentCount: number;
+    }>;
+}
+declare const searchService: SearchService;
+export default searchService;