@wiscale/velesdb-sdk 0.8.4 → 0.8.8

package/README.md

@@ -144,6 +144,50 @@ Delete a vector by ID. Returns `true` if deleted.
 
 Get a vector by ID. Returns `null` if not found.
 
+### `db.textSearch(collection, query, options)` (v0.8.5+)
+
+Full-text search using BM25 algorithm.
+
+```typescript
+const results = await db.textSearch('docs', 'machine learning', { k: 10 });
+```
+
+### `db.hybridSearch(collection, vector, textQuery, options)` (v0.8.5+)
+
+Combined vector + text search with RRF fusion.
+
+```typescript
+const results = await db.hybridSearch(
+  'docs',
+  queryVector,
+  'machine learning',
+  { k: 10, vectorWeight: 0.7 }  // 0.7 = 70% vector, 30% text
+);
+```
+
+### `db.query(queryString, params)` (v0.8.5+)
+
+Execute a VelesQL query.
+
+```typescript
+// Simple query
+const results = await db.query(
+  "SELECT * FROM documents WHERE category = 'tech' LIMIT 10"
+);
+
+// With vector parameter
+const results = await db.query(
+  "SELECT * FROM documents WHERE VECTOR NEAR $query LIMIT 5",
+  { query: [0.1, 0.2, ...] }
+);
+
+// Hybrid query
+const results = await db.query(
+  "SELECT * FROM docs WHERE VECTOR NEAR $v AND content MATCH 'rust' LIMIT 10",
+  { v: queryVector }
+);
+```
+
 ### `db.close()`
 
 Close the client and release resources.

package/dist/index.d.mts

@@ -102,6 +102,25 @@ interface IVelesDBBackend {
     delete(collection: string, id: string | number): Promise<boolean>;
     /** Get a vector by ID */
     get(collection: string, id: string | number): Promise<VectorDocument | null>;
+    /** Search for multiple vectors in batch */
+    searchBatch(collection: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
+    /** Full-text search using BM25 */
+    textSearch(collection: string, query: string, options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /** Hybrid search combining vector and text */
+    hybridSearch(collection: string, vector: number[] | Float32Array, textQuery: string, options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /** Execute VelesQL query */
+    query(queryString: string, params?: Record<string, unknown>): Promise<SearchResult[]>;
     /** Close/cleanup the backend */
     close(): Promise<void>;
 }
@@ -215,6 +234,18 @@ declare class VelesDB {
      * @returns Search results sorted by relevance
      */
     search(collection: string, query: number[] | Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Search for multiple vectors in parallel
+     *
+     * @param collection - Collection name
+     * @param searches - List of search queries
+     * @returns List of search results for each query
+     */
+    searchBatch(collection: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
     /**
      * Delete a vector by ID
      *
@@ -231,6 +262,40 @@ declare class VelesDB {
      * @returns Document or null if not found
      */
     get(collection: string, id: string | number): Promise<VectorDocument | null>;
+    /**
+     * Perform full-text search using BM25
+     *
+     * @param collection - Collection name
+     * @param query - Text query
+     * @param options - Search options (k, filter)
+     * @returns Search results sorted by BM25 score
+     */
+    textSearch(collection: string, query: string, options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /**
+     * Perform hybrid search combining vector similarity and BM25 text search
+     *
+     * @param collection - Collection name
+     * @param vector - Query vector
+     * @param textQuery - Text query for BM25
+     * @param options - Search options (k, vectorWeight, filter)
+     * @returns Search results sorted by fused score
+     */
+    hybridSearch(collection: string, vector: number[] | Float32Array, textQuery: string, options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /**
+     * Execute a VelesQL query
+     *
+     * @param queryString - VelesQL query string
+     * @param params - Optional query parameters
+     * @returns Query results
+     */
+    query(queryString: string, params?: Record<string, unknown>): Promise<SearchResult[]>;
     /**
      * Close the client and release resources
      */
@@ -267,8 +332,23 @@ declare class WasmBackend implements IVelesDBBackend {
     insert(collectionName: string, doc: VectorDocument): Promise<void>;
     insertBatch(collectionName: string, docs: VectorDocument[]): Promise<void>;
     search(collectionName: string, query: number[] | Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    searchBatch(collectionName: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
     delete(collectionName: string, id: string | number): Promise<boolean>;
     get(collectionName: string, id: string | number): Promise<VectorDocument | null>;
+    textSearch(_collection: string, _query: string, _options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    hybridSearch(_collection: string, _vector: number[] | Float32Array, _textQuery: string, _options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    query(_queryString: string, _params?: Record<string, unknown>): Promise<SearchResult[]>;
     close(): Promise<void>;
     private toNumericId;
 }
@@ -301,8 +381,23 @@ declare class RestBackend implements IVelesDBBackend {
     insert(collection: string, doc: VectorDocument): Promise<void>;
     insertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
     search(collection: string, query: number[] | Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    searchBatch(collection: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
     delete(collection: string, id: string | number): Promise<boolean>;
     get(collection: string, id: string | number): Promise<VectorDocument | null>;
+    textSearch(collection: string, query: string, options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    hybridSearch(collection: string, vector: number[] | Float32Array, textQuery: string, options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    query(queryString: string, params?: Record<string, unknown>): Promise<SearchResult[]>;
     close(): Promise<void>;
 }
 

package/dist/index.d.ts

@@ -102,6 +102,25 @@ interface IVelesDBBackend {
     delete(collection: string, id: string | number): Promise<boolean>;
     /** Get a vector by ID */
     get(collection: string, id: string | number): Promise<VectorDocument | null>;
+    /** Search for multiple vectors in batch */
+    searchBatch(collection: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
+    /** Full-text search using BM25 */
+    textSearch(collection: string, query: string, options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /** Hybrid search combining vector and text */
+    hybridSearch(collection: string, vector: number[] | Float32Array, textQuery: string, options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /** Execute VelesQL query */
+    query(queryString: string, params?: Record<string, unknown>): Promise<SearchResult[]>;
     /** Close/cleanup the backend */
     close(): Promise<void>;
 }
@@ -215,6 +234,18 @@ declare class VelesDB {
      * @returns Search results sorted by relevance
      */
     search(collection: string, query: number[] | Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Search for multiple vectors in parallel
+     *
+     * @param collection - Collection name
+     * @param searches - List of search queries
+     * @returns List of search results for each query
+     */
+    searchBatch(collection: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
     /**
      * Delete a vector by ID
      *
@@ -231,6 +262,40 @@ declare class VelesDB {
      * @returns Document or null if not found
      */
     get(collection: string, id: string | number): Promise<VectorDocument | null>;
+    /**
+     * Perform full-text search using BM25
+     *
+     * @param collection - Collection name
+     * @param query - Text query
+     * @param options - Search options (k, filter)
+     * @returns Search results sorted by BM25 score
+     */
+    textSearch(collection: string, query: string, options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /**
+     * Perform hybrid search combining vector similarity and BM25 text search
+     *
+     * @param collection - Collection name
+     * @param vector - Query vector
+     * @param textQuery - Text query for BM25
+     * @param options - Search options (k, vectorWeight, filter)
+     * @returns Search results sorted by fused score
+     */
+    hybridSearch(collection: string, vector: number[] | Float32Array, textQuery: string, options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    /**
+     * Execute a VelesQL query
+     *
+     * @param queryString - VelesQL query string
+     * @param params - Optional query parameters
+     * @returns Query results
+     */
+    query(queryString: string, params?: Record<string, unknown>): Promise<SearchResult[]>;
     /**
      * Close the client and release resources
      */
@@ -267,8 +332,23 @@ declare class WasmBackend implements IVelesDBBackend {
     insert(collectionName: string, doc: VectorDocument): Promise<void>;
     insertBatch(collectionName: string, docs: VectorDocument[]): Promise<void>;
     search(collectionName: string, query: number[] | Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    searchBatch(collectionName: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
     delete(collectionName: string, id: string | number): Promise<boolean>;
     get(collectionName: string, id: string | number): Promise<VectorDocument | null>;
+    textSearch(_collection: string, _query: string, _options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    hybridSearch(_collection: string, _vector: number[] | Float32Array, _textQuery: string, _options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    query(_queryString: string, _params?: Record<string, unknown>): Promise<SearchResult[]>;
     close(): Promise<void>;
     private toNumericId;
 }
@@ -301,8 +381,23 @@ declare class RestBackend implements IVelesDBBackend {
     insert(collection: string, doc: VectorDocument): Promise<void>;
     insertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
     search(collection: string, query: number[] | Float32Array, options?: SearchOptions): Promise<SearchResult[]>;
+    searchBatch(collection: string, searches: Array<{
+        vector: number[] | Float32Array;
+        k?: number;
+        filter?: Record<string, unknown>;
+    }>): Promise<SearchResult[][]>;
     delete(collection: string, id: string | number): Promise<boolean>;
     get(collection: string, id: string | number): Promise<VectorDocument | null>;
+    textSearch(collection: string, query: string, options?: {
+        k?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    hybridSearch(collection: string, vector: number[] | Float32Array, textQuery: string, options?: {
+        k?: number;
+        vectorWeight?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<SearchResult[]>;
+    query(queryString: string, params?: Record<string, unknown>): Promise<SearchResult[]>;
     close(): Promise<void>;
 }
 

package/dist/index.js

@@ -209,6 +209,14 @@ var WasmBackend = class {
       );
     }
     const k = options?.k ?? 10;
+    if (options?.filter) {
+      const results = collection.store.search_with_filter(queryVector, k, options.filter);
+      return results.map((r) => ({
+        id: String(r.id),
+        score: r.score,
+        payload: r.payload || collection.payloads.get(String(r.id))
+      }));
+    }
     const rawResults = collection.store.search(queryVector, k);
     return rawResults.map(([id, score]) => {
       const stringId = String(id);
@@ -223,6 +231,14 @@ var WasmBackend = class {
       return result;
     });
   }
+  async searchBatch(collectionName, searches) {
+    this.ensureInitialized();
+    const results = [];
+    for (const s of searches) {
+      results.push(await this.search(collectionName, s.vector, { k: s.k, filter: s.filter }));
+    }
+    return results;
+  }
   async delete(collectionName, id) {
     this.ensureInitialized();
     const collection = this.collections.get(collectionName);
@@ -253,6 +269,24 @@ var WasmBackend = class {
       payload
     };
   }
+  async textSearch(_collection, _query, _options) {
+    throw new VelesDBError(
+      "Text search is not supported in WASM backend. Use REST backend for BM25 search.",
+      "NOT_SUPPORTED"
+    );
+  }
+  async hybridSearch(_collection, _vector, _textQuery, _options) {
+    throw new VelesDBError(
+      "Hybrid search is not supported in WASM backend. Use REST backend for hybrid search.",
+      "NOT_SUPPORTED"
+    );
+  }
+  async query(_queryString, _params) {
+    throw new VelesDBError(
+      "VelesQL queries are not supported in WASM backend. Use REST backend for query support.",
+      "NOT_SUPPORTED"
+    );
+  }
   async close() {
     for (const [, data] of this.collections) {
       data.store.free();
@@ -453,6 +487,26 @@ var RestBackend = class {
     }
     return response.data ?? [];
   }
+  async searchBatch(collection, searches) {
+    this.ensureInitialized();
+    const formattedSearches = searches.map((s) => ({
+      vector: s.vector instanceof Float32Array ? Array.from(s.vector) : s.vector,
+      top_k: s.k ?? 10,
+      filter: s.filter
+    }));
+    const response = await this.request(
+      "POST",
+      `/collections/${encodeURIComponent(collection)}/search/batch`,
+      { searches: formattedSearches }
+    );
+    if (response.error) {
+      if (response.error.code === "NOT_FOUND") {
+        throw new NotFoundError(`Collection '${collection}'`);
+      }
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results.map((r) => r.results) ?? [];
+  }
   async delete(collection, id) {
     this.ensureInitialized();
     const response = await this.request(
@@ -481,6 +535,62 @@ var RestBackend = class {
     }
     return response.data ?? null;
   }
+  async textSearch(collection, query, options) {
+    this.ensureInitialized();
+    const response = await this.request(
+      "POST",
+      `/collections/${encodeURIComponent(collection)}/search/text`,
+      {
+        query,
+        top_k: options?.k ?? 10,
+        filter: options?.filter
+      }
+    );
+    if (response.error) {
+      if (response.error.code === "NOT_FOUND") {
+        throw new NotFoundError(`Collection '${collection}'`);
+      }
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results ?? [];
+  }
+  async hybridSearch(collection, vector, textQuery, options) {
+    this.ensureInitialized();
+    const queryVector = vector instanceof Float32Array ? Array.from(vector) : vector;
+    const response = await this.request(
+      "POST",
+      `/collections/${encodeURIComponent(collection)}/search/hybrid`,
+      {
+        vector: queryVector,
+        query: textQuery,
+        top_k: options?.k ?? 10,
+        vector_weight: options?.vectorWeight ?? 0.5,
+        filter: options?.filter
+      }
+    );
+    if (response.error) {
+      if (response.error.code === "NOT_FOUND") {
+        throw new NotFoundError(`Collection '${collection}'`);
+      }
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results ?? [];
+  }
+  async query(queryString, params) {
+    this.ensureInitialized();
+    const response = await this.request(
+      "POST",
+      "/query",
+      {
+        query: queryString,
+        params: params ?? {}
+      }
+    );
+    if (response.error) {
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results ?? [];
+  }
   async close() {
     this._initialized = false;
   }
@@ -640,6 +750,25 @@ var VelesDB = class {
     }
     return this.backend.search(collection, query, options);
   }
+  /**
+   * Search for multiple vectors in parallel
+   * 
+   * @param collection - Collection name
+   * @param searches - List of search queries
+   * @returns List of search results for each query
+   */
+  async searchBatch(collection, searches) {
+    this.ensureInitialized();
+    if (!Array.isArray(searches)) {
+      throw new ValidationError("Searches must be an array");
+    }
+    for (const s of searches) {
+      if (!s.vector || !Array.isArray(s.vector) && !(s.vector instanceof Float32Array)) {
+        throw new ValidationError("Each search must have a vector (array or Float32Array)");
+      }
+    }
+    return this.backend.searchBatch(collection, searches);
+  }
   /**
    * Delete a vector by ID
    * 
@@ -662,6 +791,54 @@ var VelesDB = class {
     this.ensureInitialized();
     return this.backend.get(collection, id);
   }
+  /**
+   * Perform full-text search using BM25
+   * 
+   * @param collection - Collection name
+   * @param query - Text query
+   * @param options - Search options (k, filter)
+   * @returns Search results sorted by BM25 score
+   */
+  async textSearch(collection, query, options) {
+    this.ensureInitialized();
+    if (!query || typeof query !== "string") {
+      throw new ValidationError("Query must be a non-empty string");
+    }
+    return this.backend.textSearch(collection, query, options);
+  }
+  /**
+   * Perform hybrid search combining vector similarity and BM25 text search
+   * 
+   * @param collection - Collection name
+   * @param vector - Query vector
+   * @param textQuery - Text query for BM25
+   * @param options - Search options (k, vectorWeight, filter)
+   * @returns Search results sorted by fused score
+   */
+  async hybridSearch(collection, vector, textQuery, options) {
+    this.ensureInitialized();
+    if (!vector || !Array.isArray(vector) && !(vector instanceof Float32Array)) {
+      throw new ValidationError("Vector must be an array or Float32Array");
+    }
+    if (!textQuery || typeof textQuery !== "string") {
+      throw new ValidationError("Text query must be a non-empty string");
+    }
+    return this.backend.hybridSearch(collection, vector, textQuery, options);
+  }
+  /**
+   * Execute a VelesQL query
+   * 
+   * @param queryString - VelesQL query string
+   * @param params - Optional query parameters
+   * @returns Query results
+   */
+  async query(queryString, params) {
+    this.ensureInitialized();
+    if (!queryString || typeof queryString !== "string") {
+      throw new ValidationError("Query string must be a non-empty string");
+    }
+    return this.backend.query(queryString, params);
+  }
   /**
    * Close the client and release resources
    */

package/dist/index.mjs

@@ -167,6 +167,14 @@ var WasmBackend = class {
       );
     }
     const k = options?.k ?? 10;
+    if (options?.filter) {
+      const results = collection.store.search_with_filter(queryVector, k, options.filter);
+      return results.map((r) => ({
+        id: String(r.id),
+        score: r.score,
+        payload: r.payload || collection.payloads.get(String(r.id))
+      }));
+    }
     const rawResults = collection.store.search(queryVector, k);
     return rawResults.map(([id, score]) => {
       const stringId = String(id);
@@ -181,6 +189,14 @@ var WasmBackend = class {
       return result;
     });
   }
+  async searchBatch(collectionName, searches) {
+    this.ensureInitialized();
+    const results = [];
+    for (const s of searches) {
+      results.push(await this.search(collectionName, s.vector, { k: s.k, filter: s.filter }));
+    }
+    return results;
+  }
   async delete(collectionName, id) {
     this.ensureInitialized();
     const collection = this.collections.get(collectionName);
@@ -211,6 +227,24 @@ var WasmBackend = class {
       payload
     };
   }
+  async textSearch(_collection, _query, _options) {
+    throw new VelesDBError(
+      "Text search is not supported in WASM backend. Use REST backend for BM25 search.",
+      "NOT_SUPPORTED"
+    );
+  }
+  async hybridSearch(_collection, _vector, _textQuery, _options) {
+    throw new VelesDBError(
+      "Hybrid search is not supported in WASM backend. Use REST backend for hybrid search.",
+      "NOT_SUPPORTED"
+    );
+  }
+  async query(_queryString, _params) {
+    throw new VelesDBError(
+      "VelesQL queries are not supported in WASM backend. Use REST backend for query support.",
+      "NOT_SUPPORTED"
+    );
+  }
   async close() {
     for (const [, data] of this.collections) {
       data.store.free();
@@ -411,6 +445,26 @@ var RestBackend = class {
     }
     return response.data ?? [];
   }
+  async searchBatch(collection, searches) {
+    this.ensureInitialized();
+    const formattedSearches = searches.map((s) => ({
+      vector: s.vector instanceof Float32Array ? Array.from(s.vector) : s.vector,
+      top_k: s.k ?? 10,
+      filter: s.filter
+    }));
+    const response = await this.request(
+      "POST",
+      `/collections/${encodeURIComponent(collection)}/search/batch`,
+      { searches: formattedSearches }
+    );
+    if (response.error) {
+      if (response.error.code === "NOT_FOUND") {
+        throw new NotFoundError(`Collection '${collection}'`);
+      }
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results.map((r) => r.results) ?? [];
+  }
   async delete(collection, id) {
     this.ensureInitialized();
     const response = await this.request(
@@ -439,6 +493,62 @@ var RestBackend = class {
     }
     return response.data ?? null;
   }
+  async textSearch(collection, query, options) {
+    this.ensureInitialized();
+    const response = await this.request(
+      "POST",
+      `/collections/${encodeURIComponent(collection)}/search/text`,
+      {
+        query,
+        top_k: options?.k ?? 10,
+        filter: options?.filter
+      }
+    );
+    if (response.error) {
+      if (response.error.code === "NOT_FOUND") {
+        throw new NotFoundError(`Collection '${collection}'`);
+      }
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results ?? [];
+  }
+  async hybridSearch(collection, vector, textQuery, options) {
+    this.ensureInitialized();
+    const queryVector = vector instanceof Float32Array ? Array.from(vector) : vector;
+    const response = await this.request(
+      "POST",
+      `/collections/${encodeURIComponent(collection)}/search/hybrid`,
+      {
+        vector: queryVector,
+        query: textQuery,
+        top_k: options?.k ?? 10,
+        vector_weight: options?.vectorWeight ?? 0.5,
+        filter: options?.filter
+      }
+    );
+    if (response.error) {
+      if (response.error.code === "NOT_FOUND") {
+        throw new NotFoundError(`Collection '${collection}'`);
+      }
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results ?? [];
+  }
+  async query(queryString, params) {
+    this.ensureInitialized();
+    const response = await this.request(
+      "POST",
+      "/query",
+      {
+        query: queryString,
+        params: params ?? {}
+      }
+    );
+    if (response.error) {
+      throw new VelesDBError(response.error.message, response.error.code);
+    }
+    return response.data?.results ?? [];
+  }
   async close() {
     this._initialized = false;
   }
@@ -598,6 +708,25 @@ var VelesDB = class {
     }
     return this.backend.search(collection, query, options);
   }
+  /**
+   * Search for multiple vectors in parallel
+   * 
+   * @param collection - Collection name
+   * @param searches - List of search queries
+   * @returns List of search results for each query
+   */
+  async searchBatch(collection, searches) {
+    this.ensureInitialized();
+    if (!Array.isArray(searches)) {
+      throw new ValidationError("Searches must be an array");
+    }
+    for (const s of searches) {
+      if (!s.vector || !Array.isArray(s.vector) && !(s.vector instanceof Float32Array)) {
+        throw new ValidationError("Each search must have a vector (array or Float32Array)");
+      }
+    }
+    return this.backend.searchBatch(collection, searches);
+  }
   /**
    * Delete a vector by ID
    * 
@@ -620,6 +749,54 @@ var VelesDB = class {
     this.ensureInitialized();
     return this.backend.get(collection, id);
   }
+  /**
+   * Perform full-text search using BM25
+   * 
+   * @param collection - Collection name
+   * @param query - Text query
+   * @param options - Search options (k, filter)
+   * @returns Search results sorted by BM25 score
+   */
+  async textSearch(collection, query, options) {
+    this.ensureInitialized();
+    if (!query || typeof query !== "string") {
+      throw new ValidationError("Query must be a non-empty string");
+    }
+    return this.backend.textSearch(collection, query, options);
+  }
+  /**
+   * Perform hybrid search combining vector similarity and BM25 text search
+   * 
+   * @param collection - Collection name
+   * @param vector - Query vector
+   * @param textQuery - Text query for BM25
+   * @param options - Search options (k, vectorWeight, filter)
+   * @returns Search results sorted by fused score
+   */
+  async hybridSearch(collection, vector, textQuery, options) {
+    this.ensureInitialized();
+    if (!vector || !Array.isArray(vector) && !(vector instanceof Float32Array)) {
+      throw new ValidationError("Vector must be an array or Float32Array");
+    }
+    if (!textQuery || typeof textQuery !== "string") {
+      throw new ValidationError("Text query must be a non-empty string");
+    }
+    return this.backend.hybridSearch(collection, vector, textQuery, options);
+  }
+  /**
+   * Execute a VelesQL query
+   * 
+   * @param queryString - VelesQL query string
+   * @param params - Optional query parameters
+   * @returns Query results
+   */
+  async query(queryString, params) {
+    this.ensureInitialized();
+    if (!queryString || typeof queryString !== "string") {
+      throw new ValidationError("Query string must be a non-empty string");
+    }
+    return this.backend.query(queryString, params);
+  }
   /**
    * Close the client and release resources
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wiscale/velesdb-sdk",
-  "version": "0.8.4",
+  "version": "0.8.8",
   "description": "Official TypeScript SDK for VelesDB - Vector Search in Microseconds",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -63,7 +63,7 @@
     "vitest": "^4.0.16"
   },
   "dependencies": {
-    "@wiscale/velesdb-wasm": "^0.6.0"
+    "@wiscale/velesdb-wasm": "^0.8.8"
   },
   "engines": {
     "node": ">=18.0.0"