simlar 1.0.0__tar.gz → 1.2.0__tar.gz

{simlar-1.0.0/src/simlar.egg-info → simlar-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simlar
-Version: 1.0.0
+Version: 1.2.0
 Summary: High-performance similarity search — open-source Python wrapper
 Author-email: TekDatum <hello@tekdatum.com>
 License: Apache-2.0
@@ -16,12 +16,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: numpy<2.5,>=1.24
+Requires-Dist: PyStemmer>=2.0
 Provides-Extra: langchain
-Requires-Dist: langchain-core>=0.2; extra == "langchain"
+Requires-Dist: langchain-core>=1.0; extra == "langchain"
 Provides-Extra: haystack
-Requires-Dist: haystack-ai>=2.0; extra == "haystack"
+Requires-Dist: haystack-ai<4,>=3.0; extra == "haystack"
 Provides-Extra: llama-index
-Requires-Dist: llama-index-core>=0.10; extra == "llama-index"
+Requires-Dist: llama-index-core>=0.14; extra == "llama-index"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: numpy<2.5,>=1.24; extra == "dev"
@@ -32,22 +33,65 @@ Dynamic: license-file
 # sim_LAR
 
 Python search library combining keyword, semantic, and hybrid search into a single ranked result list — with first-class LangChain, LlamaIndex, and Haystack support.
+
 ---
 
 ## Installation
 
-The open wrapper  and the engine is on public PyPI:
+Both the open wrapper and the engine are on public PyPI:
 
 ```bash
 pip install simlar
+pip install simlar-engine
 ```
 
+`simlar-engine` is TekDatum's proprietary binary, licensed under a [Commercial EULA](./EULA.md) — installing it means accepting those terms. See [docs/installation.md](docs/installation.md) for the compatible version matrix between `simlar` and `simlar-engine`.
 
-```bash
-pip install simlar-engine
+## Quick start
+
+### Hybrid search
+
+Combine keyword relevance and semantic similarity into one ranked list. The easiest way to get started is to give the index an embedder so Simlar can generate document and query embeddings for you.
+
+```python
+from sentence_transformers import SentenceTransformer
+from simlar import HelixIndex
+
+corpus = [
+    "cancer treatment with immunotherapy",
+    "machine learning transformers",
+    "climate change renewable energy",
+]
+ids = [f"doc_{i}" for i in range(len(corpus))]
+
+model = SentenceTransformer("WhereIsAI/UAE-Large-V1")
+
+index = HelixIndex(embedder=model.encode)
+index.add(ids=ids, texts=corpus)
+
+results = index.search("immunotherapy clinical trial", k=10)
+for r in results:
+    print(r.rank, r.id, f"{r.score:.4f}")
 ```
 
-## Quick start
+The embedder is used automatically when vectors are not supplied. You can also pass pre-computed vectors when you already have them.
+
+```python
+import numpy as np
+from simlar import HelixIndex
+
+vectors = np.load("corpus_embeddings.npy")  # shape (n, dim)
+
+index = HelixIndex(embedder=model.encode)
+index.add(ids=ids, texts=corpus, vectors=vectors)
+
+query_vec = np.load("query_embedding.npy")  # shape (1, dim)
+results = index.search(
+    query_text="immunotherapy clinical trial",
+    query_vector=query_vec,
+    k=10,
+)
+```
 
 ### Keyword search
 
@@ -92,34 +136,17 @@ for r in results:
     print(r.rank, r.id, f"{r.score:.4f}")
 ```
 
-### Hybrid search
+### Exact-term matching
 
-Combine keyword relevance and semantic similarity into one ranked list.
+Like keyword search, but scores by term overlap alone, with no relevance ranking — a lighter-weight option when you don't need BM25's IDF/length-normalization.
 
 ```python
-import numpy as np
-from simlar import HelixIndex, RelevanceIndex, SimlarEngine, ReciprocalRankFusion
+from simlar import LookupIndex
 
-corpus  = ["cancer treatment with immunotherapy", "machine learning transformers", ...]
-ids     = [f"doc_{i}" for i in range(len(corpus))]
-vectors = np.load("corpus_embeddings.npy")  # shape (n, dim)
-
-index = HelixIndex(
-    text_index=RelevanceIndex(),
-    vector_index=SimlarEngine(),
-    fusion=ReciprocalRankFusion(),
-    top_k=20,
-)
-index.add(ids=ids, texts=corpus, vectors=vectors)
+idx = LookupIndex()
+idx.add(ids=ids, texts=corpus)
 
-query_vec = np.load("query_embedding.npy")
-results = index.search(
-    query_text="immunotherapy clinical trial",
-    query_vector=query_vec,
-    k=10,
-)
-for r in results:
-    print(r.rank, r.id, f"{r.score:.4f}")
+results = idx.search("immunotherapy clinical trial", k=1)
 ```
 
 ## Framework integrations
@@ -135,27 +162,11 @@ sim_LAR works as a drop-in component in:
 | Index | Best for |
 |-------|----------|
 | `RelevanceIndex` | Keyword search over text — no embeddings required |
+| `LookupIndex` | Fast exact-term matching over text, no relevance ranking |
 | `SimlarEngine` | Semantic search over pre-computed embedding vectors |
 | `HelixIndex` | Both signals combined; corpus fits in memory |
 | `StreamingHybridIndex` | Both signals; very large corpora added in batches |
 
-## Producing embeddings
-
-sim_LAR is model-agnostic — it accepts any `(n, dim)` float32 NumPy array. Use whichever embedding library fits your project. Example with [sentence-transformers](https://sbert.net/):
-
-```bash
-pip install sentence-transformers
-```
-
-```python
-from sentence_transformers import SentenceTransformer
-
-model = SentenceTransformer("WhereIsAI/UAE-Large-V1")
-
-corpus_vectors = model.encode(corpus, normalize_embeddings=True)   # (n, dim) float32
-query_vec      = model.encode(["my search query"], normalize_embeddings=True)  # (1, dim)
-```
-
 ## Saving and loading indexes
 
 Every index type shares the same save/load interface.
@@ -196,7 +207,8 @@ We do not accept contributions to the proprietary engine.
 | Document | Description |
 |----------|-------------|
 | [Concepts](docs/concepts.md) | Architecture and design decisions |
-| [API Reference](docs/concepts.md) | Full public API |
+| [API Reference](docs/api-reference.md) | Full public API |
+| [Installation](docs/installation.md) | Setup and the simlar/simlar-engine compatibility matrix |
 | [Examples](docs/examples/) | Runnable scripts |
 
 ## License
@@ -225,7 +237,7 @@ If you only want to read or contribute to the open layer, you never need a licen
 ## What's open and what's not
 
 **Open (Apache 2.0, in this repo):**
-- The SDK and public API surface (`RelevanceIndex`, `HelixIndex`, `StreamingHybridIndex`, `ReciprocalRankFusion`)
+- The SDK and public API surface (`RelevanceIndex`, `LookupIndex`, `HelixIndex`, `StreamingHybridIndex`, `ReciprocalRankFusion`)
 - Framework adapters (LangChain / LlamaIndex / Haystack)
 - The `load_from_directory()` loader and `@register` extension API
 - Configuration schema, type stubs, examples, and docs

{simlar-1.0.0 → simlar-1.2.0}/README.md

@@ -1,22 +1,65 @@
 # sim_LAR
 
 Python search library combining keyword, semantic, and hybrid search into a single ranked result list — with first-class LangChain, LlamaIndex, and Haystack support.
+
 ---
 
 ## Installation
 
-The open wrapper  and the engine is on public PyPI:
+Both the open wrapper and the engine are on public PyPI:
 
 ```bash
 pip install simlar
+pip install simlar-engine
 ```
 
+`simlar-engine` is TekDatum's proprietary binary, licensed under a [Commercial EULA](./EULA.md) — installing it means accepting those terms. See [docs/installation.md](docs/installation.md) for the compatible version matrix between `simlar` and `simlar-engine`.
 
-```bash
-pip install simlar-engine
+## Quick start
+
+### Hybrid search
+
+Combine keyword relevance and semantic similarity into one ranked list. The easiest way to get started is to give the index an embedder so Simlar can generate document and query embeddings for you.
+
+```python
+from sentence_transformers import SentenceTransformer
+from simlar import HelixIndex
+
+corpus = [
+    "cancer treatment with immunotherapy",
+    "machine learning transformers",
+    "climate change renewable energy",
+]
+ids = [f"doc_{i}" for i in range(len(corpus))]
+
+model = SentenceTransformer("WhereIsAI/UAE-Large-V1")
+
+index = HelixIndex(embedder=model.encode)
+index.add(ids=ids, texts=corpus)
+
+results = index.search("immunotherapy clinical trial", k=10)
+for r in results:
+    print(r.rank, r.id, f"{r.score:.4f}")
 ```
 
-## Quick start
+The embedder is used automatically when vectors are not supplied. You can also pass pre-computed vectors when you already have them.
+
+```python
+import numpy as np
+from simlar import HelixIndex
+
+vectors = np.load("corpus_embeddings.npy")  # shape (n, dim)
+
+index = HelixIndex(embedder=model.encode)
+index.add(ids=ids, texts=corpus, vectors=vectors)
+
+query_vec = np.load("query_embedding.npy")  # shape (1, dim)
+results = index.search(
+    query_text="immunotherapy clinical trial",
+    query_vector=query_vec,
+    k=10,
+)
+```
 
 ### Keyword search
 
@@ -61,34 +104,17 @@ for r in results:
     print(r.rank, r.id, f"{r.score:.4f}")
 ```
 
-### Hybrid search
+### Exact-term matching
 
-Combine keyword relevance and semantic similarity into one ranked list.
+Like keyword search, but scores by term overlap alone, with no relevance ranking — a lighter-weight option when you don't need BM25's IDF/length-normalization.
 
 ```python
-import numpy as np
-from simlar import HelixIndex, RelevanceIndex, SimlarEngine, ReciprocalRankFusion
+from simlar import LookupIndex
 
-corpus  = ["cancer treatment with immunotherapy", "machine learning transformers", ...]
-ids     = [f"doc_{i}" for i in range(len(corpus))]
-vectors = np.load("corpus_embeddings.npy")  # shape (n, dim)
-
-index = HelixIndex(
-    text_index=RelevanceIndex(),
-    vector_index=SimlarEngine(),
-    fusion=ReciprocalRankFusion(),
-    top_k=20,
-)
-index.add(ids=ids, texts=corpus, vectors=vectors)
+idx = LookupIndex()
+idx.add(ids=ids, texts=corpus)
 
-query_vec = np.load("query_embedding.npy")
-results = index.search(
-    query_text="immunotherapy clinical trial",
-    query_vector=query_vec,
-    k=10,
-)
-for r in results:
-    print(r.rank, r.id, f"{r.score:.4f}")
+results = idx.search("immunotherapy clinical trial", k=1)
 ```
 
 ## Framework integrations
@@ -104,27 +130,11 @@ sim_LAR works as a drop-in component in:
 | Index | Best for |
 |-------|----------|
 | `RelevanceIndex` | Keyword search over text — no embeddings required |
+| `LookupIndex` | Fast exact-term matching over text, no relevance ranking |
 | `SimlarEngine` | Semantic search over pre-computed embedding vectors |
 | `HelixIndex` | Both signals combined; corpus fits in memory |
 | `StreamingHybridIndex` | Both signals; very large corpora added in batches |
 
-## Producing embeddings
-
-sim_LAR is model-agnostic — it accepts any `(n, dim)` float32 NumPy array. Use whichever embedding library fits your project. Example with [sentence-transformers](https://sbert.net/):
-
-```bash
-pip install sentence-transformers
-```
-
-```python
-from sentence_transformers import SentenceTransformer
-
-model = SentenceTransformer("WhereIsAI/UAE-Large-V1")
-
-corpus_vectors = model.encode(corpus, normalize_embeddings=True)   # (n, dim) float32
-query_vec      = model.encode(["my search query"], normalize_embeddings=True)  # (1, dim)
-```
-
 ## Saving and loading indexes
 
 Every index type shares the same save/load interface.
@@ -165,7 +175,8 @@ We do not accept contributions to the proprietary engine.
 | Document | Description |
 |----------|-------------|
 | [Concepts](docs/concepts.md) | Architecture and design decisions |
-| [API Reference](docs/concepts.md) | Full public API |
+| [API Reference](docs/api-reference.md) | Full public API |
+| [Installation](docs/installation.md) | Setup and the simlar/simlar-engine compatibility matrix |
 | [Examples](docs/examples/) | Runnable scripts |
 
 ## License
@@ -194,7 +205,7 @@ If you only want to read or contribute to the open layer, you never need a licen
 ## What's open and what's not
 
 **Open (Apache 2.0, in this repo):**
-- The SDK and public API surface (`RelevanceIndex`, `HelixIndex`, `StreamingHybridIndex`, `ReciprocalRankFusion`)
+- The SDK and public API surface (`RelevanceIndex`, `LookupIndex`, `HelixIndex`, `StreamingHybridIndex`, `ReciprocalRankFusion`)
 - Framework adapters (LangChain / LlamaIndex / Haystack)
 - The `load_from_directory()` loader and `@register` extension API
 - Configuration schema, type stubs, examples, and docs

{simlar-1.0.0 → simlar-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simlar"
-version = "1.0.0"
+version = "1.2.0"
 description = "High-performance similarity search — open-source Python wrapper"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -17,16 +17,18 @@ authors = [
     {name = "TekDatum", email = "hello@tekdatum.com"},
 ]
 
-# simlar-engine is the proprietary binary; install from the private index first.
-# See installation.md for instructions.
+# simlar-engine is the proprietary binary (Commercial EULA, not Apache 2.0),
+# so it's not declared here as a normal dependency; install it separately.
+# See docs/installation.md for instructions and the compatible version matrix.
 dependencies = [
     "numpy>=1.24,<2.5",
+    "PyStemmer>=2.0",
 ]
 
 [project.optional-dependencies]
-langchain   = ["langchain-core>=0.2"]
-haystack    = ["haystack-ai>=2.0"]
-llama_index = ["llama-index-core>=0.10"]
+langchain   = ["langchain-core>=1.0"]
+haystack    = ["haystack-ai>=3.0,<4"]
+llama_index = ["llama-index-core>=0.14"]
 dev = [
     "pytest>=8.0",
     "numpy>=1.24,<2.5",
@@ -76,6 +78,18 @@ testpaths  = ["tests"]
 pythonpath = ["src"]
 addopts    = "-ra -q"
 
+# ── Coverage ──────────────────────────────────────────────────────────────────
+
+# CI runs against the engine stub, where the tests for these modules are
+# skipped (they need SIMLAR_REAL_ENGINE=1). Leave them out so the coverage
+# total only measures code the stub run can exercise.
+[tool.coverage.run]
+omit = [
+    "*/simlar/integrations/haystack/_filters.py",
+    "*/simlar/integrations/haystack/simlar_document_store.py",
+    "*/simlar/integrations/llama_index/simlar_vector_store.py",
+]
+
 # ── Mypy ─────────────────────────────────────────────────────────────────────
 
 [tool.mypy]
@@ -108,3 +122,7 @@ ignore_missing_imports = true
 [[tool.mypy.overrides]]
 module = ["fsspec", "fsspec.*"]
 ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["bm25c", "bm25c.*"]
+ignore_missing_imports = true

simlar-1.2.0/src/simlar/__init__.py

@@ -0,0 +1,74 @@
+from simlar_engine import FilterError, MetadataFilter, SQLFilter
+
+from simlar.contracts import SearchResult, TextIndex, VectorIndex
+from simlar.embeddings import CallableEmbedder, Embedder
+from simlar.fusion import ReciprocalRankFusion
+from simlar.indexes.bm25c_index import BM25CIndex
+from simlar.indexes.filtered_index import FilteredIndex
+from simlar.indexes.helix_index import HelixIndex
+from simlar.indexes.lookup_index import LookupIndex
+from simlar.indexes.registry import load_from_directory, register
+from simlar.indexes.relevance_index import RelevanceIndex
+from simlar.indexes.simlar_engine import SimlarEngine
+from simlar.indexes.streaming_index import StreamingHelixIndex as StreamingHybridIndex
+
+_MIN_ENGINE_VERSION = (1, 1, 0)
+
+
+def _check_engine_version() -> None:
+    """Best-effort compatibility guard between this wrapper and simlar-engine.
+
+    simlar-engine is a proprietary binary installed as a separate package
+    (see docs/installation.md) — there is no packaging-level dependency pin
+    tying the two together, so a too-old engine would otherwise fail with a
+    confusing TypeError deep inside a search() call instead of a clear error
+    at import time. Silently skipped when the installed engine doesn't
+    expose __version__ (e.g. a test double, or a build that predates this
+    check) rather than treated as a failure — this is a floor, not a full
+    dependency resolver.
+    """
+    import simlar_engine
+
+    engine_version = getattr(simlar_engine, "__version__", None)
+    if engine_version is None:
+        return
+    try:
+        parsed = tuple(int(p) for p in engine_version.split(".")[:3])
+    except ValueError:
+        return
+    if parsed < _MIN_ENGINE_VERSION:
+        raise RuntimeError(
+            f"simlar requires simlar-engine >= {'.'.join(map(str, _MIN_ENGINE_VERSION))}, "
+            f"but {engine_version} is installed. See docs/installation.md for the "
+            "compatible version matrix."
+        )
+
+
+_check_engine_version()
+
+__all__ = [
+    # Contracts — extension points
+    "SearchResult",
+    "TextIndex",
+    "VectorIndex",
+    # Embeddings
+    "Embedder",
+    "CallableEmbedder",
+    # Fusion
+    "ReciprocalRankFusion",
+    # Indexes
+    "RelevanceIndex",
+    "SimlarEngine",
+    "BM25CIndex",
+    "HelixIndex",
+    "StreamingHybridIndex",
+    "LookupIndex",
+    # Filtering
+    "FilteredIndex",
+    "SQLFilter",
+    "MetadataFilter",
+    "FilterError",
+    # Registry
+    "register",
+    "load_from_directory",
+]

{simlar-1.0.0 → simlar-1.2.0}/src/simlar/contracts.py

@@ -26,11 +26,11 @@ class Index(ABC):
     """Minimal contract: every index can persist and report its type and size."""
 
     @abstractmethod
-    def save(self, path: str) -> None: ...
+    def save(self, path: str, base_dir: str | None = None) -> None: ...
 
     @classmethod
     @abstractmethod
-    def load(cls, path: str) -> Index: ...
+    def load(cls, path: str, base_dir: str | None = None) -> Index: ...
 
     @property
     @abstractmethod
@@ -44,6 +44,10 @@ class Index(ABC):
     @abstractmethod
     def is_trained(self) -> bool: ...
 
+    @property
+    @abstractmethod
+    def ids(self) -> list[str]: ...
+
 
 # ── Text index ────────────────────────────────────────────────────────────────
 
@@ -54,8 +58,12 @@ class TextIndex(Index):
     # ── Public API ─────────────────────────────────────────────────────────────
 
     @abstractmethod
-    def add(self, ids: list[str], texts: list[str]) -> None:
-        """Append new documents. Raises ValueError on duplicate IDs; use update() to replace."""
+    def add(self, ids: list[str], texts: list[str], parallel: bool = True) -> None:
+        """Append new documents. Raises ValueError on duplicate IDs; use update() to replace.
+
+        `parallel` is accepted for parity with the vector side; text indexing
+        is single-threaded in every backend.
+        """
 
     @abstractmethod
     def update(self, ids: list[str], texts: list[str]) -> None:
@@ -66,12 +74,29 @@ class TextIndex(Index):
         """Remove documents by ID, rebuilding internal structures."""
 
     @abstractmethod
-    def search(self, query: str, k: int) -> list[SearchResult]: ...
+    def search(
+        self,
+        query: str | list[str],
+        k: int,
+        parallel: bool = True,
+        batch_size: int | None = None,
+        candidates: np.ndarray | None = None,
+    ) -> list[SearchResult] | list[list[SearchResult]]:
+        """Rank documents against query. `parallel` threads a batch of queries.
+
+        `candidates`, if given, is a single flat array of positions applied
+        to EVERY query in a batch call -- not a per-query restriction like
+        `VectorIndex.search_raw`'s `candidates` (used for Helix's per-query
+        text->vector cascade). A backend that can restrict a search this
+        cheaply doesn't need a per-query shape here: the one caller that
+        needs it (SQLFilter-style pre-filtering) always applies the same
+        filter to every query in a batch.
+        """
 
     # ── Internal ───────────────────────────────────────────────────────────────
 
     @abstractmethod
-    def fit(self, corpus: list[str], parallel: bool = False, **kwargs) -> None:
+    def fit(self, corpus: list[str], parallel: bool = True, **kwargs) -> None:
         """Build the model from a raw corpus list. Called by add() and HelixIndex."""
 
     @abstractmethod
@@ -79,10 +104,12 @@ class TextIndex(Index):
         self,
         queries: str | list[str],
         k: int,
-        parallel: bool = False,
+        parallel: bool = True,
+        candidates: np.ndarray | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
         """Return (ids, scores) shaped (n_queries, k), int64/float64.
-        Used internally by HelixIndex._search_raw().
+        Used internally by HelixIndex._search_raw(). See `search`'s
+        docstring for what `candidates` does.
         """
 
 
@@ -95,10 +122,25 @@ class VectorIndex(Index):
     # ── Public API ─────────────────────────────────────────────────────────────
 
     @abstractmethod
-    def add(self, ids: list[str], vectors: np.ndarray) -> None: ...
+    def add(self, ids: list[str], vectors: np.ndarray, parallel: bool = True) -> None:
+        """Append new vectors. `parallel` threads their quantization."""
 
     @abstractmethod
-    def search(self, query: np.ndarray, k: int) -> list[SearchResult]: ...
+    def search(
+        self,
+        query: np.ndarray,
+        k: int,
+        parallel: bool = True,
+        batch_size: int | None = None,
+        candidates: np.ndarray | None = None,
+    ) -> list[SearchResult]:
+        """Rank documents against query. `parallel` threads a batch of queries.
+
+        `candidates`, if given, is a single flat array of positions applied
+        to every query -- the same pre-filter contract as `TextIndex.search`
+        (used by FilteredIndex). Fewer allowed documents than `k` means
+        fewer results.
+        """
 
     @abstractmethod
     def update(self, ids: list[str], vectors: np.ndarray) -> None:
@@ -110,7 +152,7 @@ class VectorIndex(Index):
     def fit(
         self,
         embeddings: np.ndarray,
-        parallel: bool = False,
+        parallel: bool = True,
         params: _Parameters | None = None,
         **kwargs,
     ) -> None:
@@ -122,11 +164,15 @@ class VectorIndex(Index):
         vectors: np.ndarray,
         k: int,
         candidates: np.ndarray | None = None,
-        parallel: bool = False,
+        parallel: bool = True,
         n_candidates: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
         """Return (ids, distances) shaped (n_queries, k), int64/float64.
         Used internally by HelixIndex._search_raw().
+
+        `candidates` is either a 1D array of positions shared by every query
+        (the pre-filter, see `search`) or a 2D (n_queries, n_cand) array of
+        per-query rows (Helix's text->vector cascade).
         """
 
     @abstractmethod
@@ -151,17 +197,29 @@ class CompositeIndex(Index):
     @abstractmethod
     def search(
         self,
-        query_text: str | None = None,
+        query_text: str | list[str] | None = None,
         query_vector: np.ndarray | None = None,
         k: int = 10,
-    ) -> list[SearchResult]: ...
+        parallel: bool = True,
+        batch_size: int | None = None,
+        candidates: np.ndarray | None = None,
+    ) -> list[SearchResult] | list[list[SearchResult]]:
+        """Search every sub-index and fuse. `parallel` threads a batch of queries.
+
+        A single query returns `list[SearchResult]`; a batch (e.g. a list of
+        query texts, or a 2D array of query vectors) returns one such list
+        per query, in order — the same batch contract as `TextIndex.search`.
+
+        `candidates`, if given, is a single flat array of positions applied
+        to every query, restricting every sub-index (see FilteredIndex).
+        """
 
     @abstractmethod
     def fit(
         self,
         corpus: list,
         vectors: np.ndarray,
-        parallel: bool = False,
+        parallel: bool = True,
         **kwargs,
     ) -> None:
         """Internal: build all sub-indexes. Used by StreamingHybridIndex shards."""
@@ -172,10 +230,8 @@ class CompositeIndex(Index):
 
 @runtime_checkable
 class FusionStrategy(Protocol):
-    """Combines N result lists into a single ranked list."""
-
     def __call__(
         self,
-        results: list[list[SearchResult]],
+        results: list[tuple[np.ndarray, np.ndarray]],
         k: int,
-    ) -> list[SearchResult]: ...
+    ) -> tuple[np.ndarray, np.ndarray]: ...