lfx-nextplaid 0.1.0__py3-none-any.whl

lfx_nextplaid/__init__.py

@@ -0,0 +1,26 @@
+"""lfx-nextplaid: NextPlaid multi-vector vector store bundle.
+
+This package is the distribution unit ``lfx-nextplaid``.  At runtime
+Langflow's loader discovers ``extension.json`` shipped alongside this
+``__init__.py`` and registers the bundle's two components under the
+namespaced IDs:
+
+* ``ext:nextplaid:NextPlaidVectorStoreComponent@official``
+* ``ext:nextplaid:VllmMultivectorEmbeddingsComponent@official``
+
+NextPlaid stores each document as a matrix of token embeddings
+(ColBERT/ColPali-style late interaction, MaxSim scoring) backed by a
+running NextPlaid server via the ``langchain-plaid`` client.  The
+companion ``VllmMultivectorEmbeddings`` component produces the token-matrix
+embeddings NextPlaid ingests by calling vLLM's ``/pooling`` endpoint; the
+two ship together because the multivector embeddings exist to feed
+NextPlaid.
+"""
+
+from lfx_nextplaid.components.nextplaid.nextplaid import NextPlaidVectorStoreComponent
+from lfx_nextplaid.components.nextplaid.vllm_multivector_embeddings import VllmMultivectorEmbeddingsComponent
+
+__all__ = [
+    "NextPlaidVectorStoreComponent",
+    "VllmMultivectorEmbeddingsComponent",
+]

lfx_nextplaid/components/nextplaid/__init__.py

@@ -0,0 +1,15 @@
+"""Component re-exports for the ``nextplaid`` bundle.
+
+Saved-flow migration entries that target ``lfx.components.nextplaid.<Class>``
+(and the legacy ``lfx.components.vllm.<Class>`` path for the multivector
+embeddings) resolve through this package, so the moved Component classes must
+be importable from here by name.
+"""
+
+from .nextplaid import NextPlaidVectorStoreComponent
+from .vllm_multivector_embeddings import VllmMultivectorEmbeddingsComponent
+
+__all__ = [
+    "NextPlaidVectorStoreComponent",
+    "VllmMultivectorEmbeddingsComponent",
+]

lfx_nextplaid/components/nextplaid/nextplaid.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+from typing import Any
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import (
+    BoolInput,
+    DropdownInput,
+    FloatInput,
+    HandleInput,
+    IntInput,
+    Output,
+    StrInput,
+)
+from lfx.schema.data import Data
+
+
+class NextPlaidVectorStoreComponent(LCVectorStoreComponent):
+    """NextPlaid multi-vector (ColBERT/ColPali-style) vector store."""
+
+    display_name: str = "NextPlaid"
+    description: str = (
+        "Multi-vector (ColBERT/PLAID) vector store backed by NextPlaid. "
+        "Supports text retrieval via ColBERT models and image retrieval via "
+        "ColPali models. Connect a vLLM Multivector Embeddings component."
+    )
+    name = "NextPlaid"
+    icon = "NextPlaid"
+
+    inputs = [
+        StrInput(
+            name="url",
+            display_name="Server URL",
+            value="http://localhost:8080",
+            info="Base URL of the running NextPlaid server.",
+        ),
+        StrInput(
+            name="index_name",
+            display_name="Index Name",
+            value="langflow",
+            info="Name of the index to create or connect to.",
+        ),
+        DropdownInput(
+            name="nbits",
+            display_name="Quantization Bits",
+            options=["2", "4"],
+            value="4",
+            info="Bit-width for PLAID quantization. 4-bit gives better quality.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="create_index_if_not_exists",
+            display_name="Create Index If Not Exists",
+            value=True,
+            advanced=True,
+        ),
+        FloatInput(
+            name="write_timeout",
+            display_name="Write Timeout (seconds)",
+            value=30.0,
+            info=(
+                "Seconds to wait for each batch to finish indexing. "
+                "0 = async (search may return empty on first run). "
+                "Recommended: 30+ when ingesting and searching in the same flow run."
+            ),
+            advanced=True,
+        ),
+        IntInput(
+            name="index_batch_size",
+            display_name="Index Batch Size",
+            value=500,
+            advanced=True,
+            info=(
+                "Documents per indexing request. PLAID builds its initial cluster "
+                "centroids from the first batch — larger batches produce better "
+                "retrieval quality. Approximate limits per 1GB request: "
+                "~26,000 text docs (ColBERT-small, 96-dim), "
+                "~2,000 PDF pages (ColPali, 1000-patch x 128-dim)."
+            ),
+        ),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(
+            name="embedding",
+            display_name="Embedding (Multivector)",
+            input_types=["Embeddings"],
+            info=(
+                "Connect a vLLM Multivector Embeddings component. "
+                "For image indexing, the model must support embed_images() "
+                "(requires a ColPali model such as ModernVBERT/colmodernvbert)."
+            ),
+        ),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return from similarity search.",
+            value=4,
+            advanced=True,
+        ),
+    ]
+
+    # Declared explicitly (rather than inherited from LCVectorStoreComponent) so the
+    # static extension validator can resolve the component's output methods; mirrors
+    # the base outputs and keeps the search output usable as an agent tool.
+    outputs = [
+        Output(
+            display_name="Search Results",
+            name="search_results",
+            method="search_documents",
+            tool_mode=True,
+        ),
+        Output(
+            display_name="Table",
+            name="dataframe",
+            method="as_dataframe",
+        ),
+    ]
+
+    @staticmethod
+    def _data_to_pil(item: Data):
+        """Extract a PIL Image from a Data object produced by PdfPagesToImages."""
+        from PIL import Image as PILImage
+
+        b64 = item.data.get("base64_image", "")
+        if not b64:
+            msg = f"Data object with content_type '{item.data.get('content_type')}' has no 'base64_image' field."
+            raise ValueError(msg)
+        return PILImage.open(io.BytesIO(base64.b64decode(b64)))
+
+    @staticmethod
+    def _stable_image_id(item: Data, index_name: str, position: int) -> str:
+        """Derive a stable upsert ID from available metadata."""
+        return (
+            item.data.get("document_id")
+            or hashlib.sha256(
+                f"{index_name}:{item.data.get('source', '')}:{item.data.get('page', position)}".encode()
+            ).hexdigest()
+        )
+
+    @staticmethod
+    def _stable_text_id(doc, index_name: str) -> str:
+        """Derive a stable upsert ID for a text document.
+
+        Prefers explicit id metadata; otherwise fingerprints the content
+        together with its source/page so identical chunk text from different
+        sources does not collide onto the same vector.
+        """
+        explicit = doc.metadata.get("document_id") or doc.metadata.get("doc_id") or doc.metadata.get("id")
+        if explicit:
+            return explicit
+        fingerprint = (
+            f"{index_name}:"
+            f"{doc.metadata.get('source', '')}:"
+            f"{doc.metadata.get('page', '')}:"
+            f"{(doc.page_content or '').strip()}"
+        )
+        return hashlib.sha256(fingerprint.encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def _stable_raw_image_id(image, index_name: str) -> str:
+        """Fingerprint a raw PIL image so re-ingesting it upserts instead of relying on batch position."""
+        if hasattr(image, "convert") and hasattr(image, "tobytes"):
+            fingerprint = hashlib.sha256(image.convert("RGB").tobytes()).hexdigest()
+        else:
+            fingerprint = hashlib.sha256(repr(image).encode("utf-8")).hexdigest()
+        return hashlib.sha256(f"{index_name}:raw_image:{fingerprint}".encode()).hexdigest()
+
+    @check_cached_vector_store
+    def build_vector_store(self):
+        try:
+            from langchain_plaid.vectorstores import NextPlaidVectorStore as LangchainNextPlaid
+        except ImportError as e:
+            msg = "Could not import langchain-plaid. Install it with: pip install langchain-plaid"
+            raise ImportError(msg) from e
+
+        if self.embedding is None:
+            msg = (
+                "No embedding model connected. Connect a vLLM Multivector Embeddings component to the Embedding input."
+            )
+            raise ValueError(msg)
+
+        nextplaid_store = LangchainNextPlaid(
+            url=self.url,
+            index_name=self.index_name,
+            embedding=self.embedding,
+            nbits=int(self.nbits),
+            create_index_if_not_exists=self.create_index_if_not_exists,
+            write_timeout=self.write_timeout,
+        )
+
+        self.ingest_data = self._prepare_ingest_data()
+
+        # Flatten — Langflow wraps ingest data in a list: [[doc1, doc2, ...]]
+        raw_inputs: list[Any] = []
+        for item in self.ingest_data or []:
+            if isinstance(item, list):
+                raw_inputs.extend(item)
+            else:
+                raw_inputs.append(item)
+
+        if not raw_inputs:
+            return nextplaid_store
+
+        # Route items into text documents or images.
+        # A Data object is treated as an image when it carries content_type: image/*
+        # (set by PdfPagesToImages). Everything else is a text document.
+        text_docs = []
+        image_data_items: list[Data] = []  # Data objects wrapping images
+        raw_image_items: list[Any] = []  # raw PIL Images (advanced usage)
+
+        for item in raw_inputs:
+            if isinstance(item, Data):
+                if item.data.get("content_type", "").startswith("image/"):
+                    image_data_items.append(item)
+                else:
+                    doc = item.to_lc_document()
+                    if doc.id is None:
+                        doc.id = self._stable_text_id(doc, self.index_name)
+                    text_docs.append(doc)
+            else:
+                # Raw PIL Image passed directly (e.g. from a custom component)
+                raw_image_items.append(item)
+
+        batch_size = max(self.index_batch_size or 500, 1)
+
+        # ── Text ingestion ────────────────────────────────────────────────────
+        if text_docs:
+            for i in range(0, len(text_docs), batch_size):
+                nextplaid_store.add_documents(text_docs[i : i + batch_size])
+
+        # ── Image ingestion from Data objects (PdfPagesToImages output) ───────
+        if image_data_items:
+            if not hasattr(self.embedding, "embed_images"):
+                msg = (
+                    f"{type(self.embedding).__name__} does not implement embed_images()."
+                    " Use a ColPali-compatible model (e.g. ModernVBERT/colmodernvbert)."
+                )
+                raise TypeError(msg)
+
+            for i in range(0, len(image_data_items), batch_size):
+                batch = image_data_items[i : i + batch_size]
+
+                pil_images = [self._data_to_pil(item) for item in batch]
+                metadatas = [{k: v for k, v in item.data.items() if k != "base64_image"} for item in batch]
+                ids = [self._stable_image_id(item, self.index_name, i + j) for j, item in enumerate(batch)]
+                nextplaid_store.add_images(pil_images, metadatas=metadatas, ids=ids)
+
+        # ── Raw PIL image ingestion (advanced / programmatic use) ─────────────
+        if raw_image_items:
+            if not hasattr(self.embedding, "embed_images"):
+                msg = (
+                    f"{type(self.embedding).__name__} does not implement embed_images()."
+                    " Use a ColPali-compatible model (e.g. ModernVBERT/colmodernvbert)."
+                )
+                raise TypeError(msg)
+
+            for i in range(0, len(raw_image_items), batch_size):
+                batch = raw_image_items[i : i + batch_size]
+                ids = [self._stable_raw_image_id(image, self.index_name) for image in batch]
+                nextplaid_store.add_images(batch, ids=ids)
+
+        return nextplaid_store
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx_nextplaid/components/nextplaid/vllm_multivector_embeddings.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+
+# Kept as a runtime import (not under TYPE_CHECKING): the framework resolves
+# build_embeddings()'s ``-> Embeddings`` return hint via get_type_hints() at runtime.
+from lfx.field_typing import Embeddings  # noqa: TC002
+from lfx.io import FloatInput, IntInput, MessageTextInput, SecretStrInput
+from lfx_nextplaid.components.nextplaid.vllm_multivector_impl import VllmMultivectorEmbeddings
+
+
+class VllmMultivectorEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "vLLM Multivector Embeddings"
+    description = (
+        "Multi-vector (ColBERT/ColPali-style) token embeddings via vLLM's /pooling endpoint. "
+        "Compatible with text-only ColBERT models and multi-modal ColPali models. "
+        "Required for use with the NextPlaid vector store."
+    )
+    icon = "vLLM"
+    name = "VllmMultivectorEmbeddings"
+
+    inputs = [
+        MessageTextInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            info=(
+                "Multi-vector model served by vLLM. Examples:\n"
+                "Text (ColBERT): answerdotai/answerai-colbert-small-v1\n"
+                "Text + Images (ColPali): ModernVBERT/colmodernvbert"
+            ),
+            value="answerdotai/answerai-colbert-small-v1",
+        ),
+        MessageTextInput(
+            name="api_base",
+            display_name="vLLM API Base",
+            advanced=False,
+            info=(
+                "Base URL of the vLLM server (no /v1 suffix). "
+                "Start vLLM with: vllm serve <model> --runner pooling "
+                '--pooler-config \'{"task": "token_embed"}\''
+            ),
+            value="http://localhost:8000",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="API key for the vLLM server. Leave empty for local servers.",
+            advanced=False,
+            value="",
+            required=False,
+        ),
+        FloatInput(
+            name="request_timeout",
+            display_name="Request Timeout",
+            advanced=True,
+            value=60.0,
+            info="Timeout in seconds for each request to the vLLM API.",
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max Retries",
+            advanced=True,
+            value=3,
+            info="Number of times to retry a failed request before raising an error.",
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        return VllmMultivectorEmbeddings(
+            url=self.api_base or "http://localhost:8000",
+            model=self.model_name,
+            api_key=self.api_key or "",
+            timeout=self.request_timeout or 60.0,
+            max_retries=self.max_retries or 1,
+        )

lfx_nextplaid/components/nextplaid/vllm_multivector_impl.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import base64
+import io
+import time
+from typing import TYPE_CHECKING
+
+import requests
+from langchain_core.embeddings import Embeddings as LCEmbeddings
+
+if TYPE_CHECKING:
+    from PIL.Image import Image as PILImage
+
+
+class VllmMultivectorEmbeddings(LCEmbeddings):
+    """Multi-vector embeddings via vLLM's /pooling endpoint.
+
+    Works with any multi-vector model served by vLLM including:
+      Text ColBERT  : answerdotai/answerai-colbert-small-v1
+                      lightonai/ColBERT-Zero
+      Multi-modal   : ModernVBERT/colmodernvbert
+                      vidore/colqwen2-v1.0
+
+    vLLM must be started with --runner pooling and the correct pooler config:
+        vllm serve <model> --runner pooling
+
+    For token-level (multi-vector) output, also pass:
+        --pooler-config '{"task": "token_embed"}'
+
+    Note: the `task` field in the HTTP request body is deprecated in vLLM >= 0.20.
+    Set it at server startup instead.
+
+    Shape contract (required by NextPlaid):
+        embed_documents(texts) -> List[List[List[float]]]  (n_docs, n_tokens, dim)
+        embed_query(text)      -> List[List[float]]         (n_tokens, dim)
+        embed_images(images)   -> List[List[List[float]]]  (n_imgs, n_patches, dim)
+            — only available for multi-modal ColPali models
+    """
+
+    def __init__(
+        self,
+        url: str,
+        model: str,
+        api_key: str = "",
+        timeout: float = 60.0,
+        max_retries: int = 1,
+    ) -> None:
+        self.url = url.rstrip("/")
+        self.model = model
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._headers: dict = {
+            "Content-Type": "application/json",
+            **({"Authorization": f"Bearer {api_key}"} if api_key else {}),
+        }
+
+    def __repr__(self) -> str:
+        return f"VllmMultivectorEmbeddings(url={self.url!r}, model={self.model!r})"
+
+    def __hash__(self) -> int:
+        return hash((self.url, self.model, self.api_key))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+        return (self.url, self.model, self.api_key) == (other.url, other.model, other.api_key)
+
+    @staticmethod
+    def _extract_embedding_rows(payload: object) -> list[dict]:
+        """Validate the vLLM /pooling envelope before nested indexing.
+
+        Raises a clear ``RuntimeError`` instead of letting a malformed or
+        partial response crash with ``KeyError``/``IndexError`` downstream.
+        """
+        data = payload.get("data") if isinstance(payload, dict) else None
+        if not isinstance(data, list) or not data:
+            msg = "vLLM /pooling response missing non-empty 'data' list"
+            raise RuntimeError(msg)
+        return data
+
+    def _post_pooling(self, input_data: list) -> list[list[list[float]]]:
+        last_exc: Exception | None = None
+        for attempt in range(max(self.max_retries, 1)):
+            try:
+                resp = requests.post(
+                    f"{self.url}/pooling",
+                    json={"model": self.model, "input": input_data},
+                    headers=self._headers,
+                    timeout=self.timeout,
+                )
+                resp.raise_for_status()
+                rows = self._extract_embedding_rows(resp.json())
+                try:
+                    results = sorted(rows, key=lambda x: x["index"])
+                    return [item["data"] for item in results]
+                except (KeyError, TypeError) as exc:
+                    msg = "vLLM /pooling response has invalid embedding row shape"
+                    raise RuntimeError(msg) from exc
+            except requests.HTTPError as exc:
+                valid_client_status_codes = 500
+                if exc.response is not None and exc.response.status_code < valid_client_status_codes:
+                    raise  # don't retry 4xx — surface immediately
+                last_exc = exc
+                if attempt < self.max_retries - 1:
+                    time.sleep(2**attempt)
+            except requests.RequestException as exc:
+                last_exc = exc
+                if attempt < self.max_retries - 1:
+                    time.sleep(2**attempt)
+        raise last_exc  # type: ignore[misc]
+
+    @staticmethod
+    def _pil_to_content_item(img: PILImage) -> dict:
+        """Convert a PIL Image to an OpenAI Vision API content item.
+
+        This is the format vLLM expects for multi-modal pooling input.
+        """
+        buf = io.BytesIO()
+        img.convert("RGB").save(buf, format="JPEG")
+        b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+        return {
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
+        }
+
+    def embed_documents(self, texts: list[str]) -> list[list[list[float]]]:  # type: ignore[override]
+        """Encode text documents. Returns one token matrix per document."""
+        if not texts:
+            return []
+        return self._post_pooling(texts)
+
+    def embed_query(self, text: str) -> list[list[float]]:  # type: ignore[override]
+        """Encode a single query string. Returns one token matrix."""
+        return self._post_pooling([text])[0]
+
+    def embed_images(self, images: list[PILImage]) -> list[list[list[float]]]:
+        if not images:
+            return []
+
+        embeddings: list[list[list[float]]] = []
+        for img in images:
+            last_exc: Exception | None = None
+            for attempt in range(max(self.max_retries, 1)):
+                try:
+                    resp = requests.post(
+                        f"{self.url}/pooling",
+                        json={
+                            "model": self.model,
+                            "messages": [
+                                {
+                                    "role": "user",
+                                    "content": [self._pil_to_content_item(img)],
+                                }
+                            ],
+                        },
+                        headers=self._headers,
+                        timeout=self.timeout,
+                    )
+                    resp.raise_for_status()
+                    rows = self._extract_embedding_rows(resp.json())
+                    try:
+                        embeddings.append(rows[0]["data"])
+                    except (KeyError, TypeError, IndexError) as exc:
+                        msg = "vLLM /pooling image response has invalid embedding row shape"
+                        raise RuntimeError(msg) from exc
+                    break
+                except requests.HTTPError as exc:
+                    valid_client_status_codes = 500
+                    if exc.response is not None and exc.response.status_code < valid_client_status_codes:
+                        msg = f"vLLM {exc.response.status_code}: {exc.response.text}"
+                        raise RuntimeError(msg) from exc
+                    last_exc = exc
+                    if attempt < self.max_retries - 1:
+                        time.sleep(2**attempt)
+                except requests.RequestException as exc:
+                    last_exc = exc
+                    if attempt < self.max_retries - 1:
+                        time.sleep(2**attempt)
+            else:
+                raise last_exc  # type: ignore[misc]
+
+        return embeddings

lfx_nextplaid/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-nextplaid",
+  "version": "0.1.0",
+  "name": "NextPlaid",
+  "description": "NextPlaid multi-vector (ColBERT/PLAID) vector store and its companion vLLM multivector embeddings as a standalone Langflow Extension Bundle.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "nextplaid",
+      "path": "components/nextplaid"
+    }
+  ]
+}

lfx_nextplaid-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: lfx-nextplaid
+Version: 0.1.0
+Summary: NextPlaid multi-vector vector store (+ vLLM multivector embeddings) as a standalone Langflow Extension Bundle.
+Project-URL: Homepage, https://github.com/langflow-ai/langflow
+Project-URL: Documentation, https://docs.langflow.org/extensions
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Author-email: Langflow <contact@langflow.org>
+License: MIT
+Keywords: bundle,colbert,extension,langflow,lfx,multi-vector,nextplaid,plaid,vector-store
+Requires-Python: <3.15,>=3.10
+Requires-Dist: langchain-plaid<1.0.0,>=0.1.0
+Requires-Dist: lfx<2.0.0,>=1.11.0.dev0
+Requires-Dist: pillow>=10.0.0
+Description-Content-Type: text/markdown
+
+# lfx-nextplaid
+
+NextPlaid multi-vector vector store (plus its companion vLLM multivector
+embeddings) as a standalone Langflow Extension Bundle.
+
+NextPlaid stores each document as a *matrix* of token embeddings rather than
+a single vector, enabling ColBERT/ColPali-style late interaction (MaxSim
+scoring) for significantly higher retrieval quality on semantic search.
+The bundle ships two components:
+
+- **`NextPlaidVectorStoreComponent`** — vector store backed by a running
+  [NextPlaid server](https://github.com/meetdoshi90/next-plaid) via the
+  [`langchain-plaid`](https://pypi.org/project/langchain-plaid/) client.
+  Supports text (ColBERT) and image (ColPali) ingestion with full upsert
+  semantics via stable document IDs.
+- **`VllmMultivectorEmbeddingsComponent`** — produces the token-matrix
+  embeddings NextPlaid ingests by calling vLLM's `/pooling` endpoint with
+  `task: token_embed`. Compatible with ColBERT models such as
+  `answerdotai/answerai-colbert-small-v1`.
+
+## Requirements
+
+- A running [NextPlaid server](https://github.com/meetdoshi90/next-plaid).
+- A running [vLLM server](https://docs.vllm.ai/) with a ColBERT-compatible
+  model loaded via `--runner pooling`.
+
+## Install
+
+```bash
+pip install lfx-nextplaid
+```
+
+The bundle is registered automatically via the `langflow.extensions`
+entry-point. After install, restart your Langflow server; the components
+appear in the palette under the `nextplaid` bundle group.
+
+## Develop
+
+```bash
+cd src/bundles/nextplaid
+pip install -e .
+lfx extension validate src/lfx_nextplaid
+```
+
+## Manifest
+
+The extension manifest is shipped at `src/lfx_nextplaid/extension.json` and
+points at the bundle at `components/nextplaid`. Components register under the
+canonical namespaced IDs `ext:nextplaid:NextPlaidVectorStoreComponent@official`
+and `ext:nextplaid:VllmMultivectorEmbeddingsComponent@official`.
+
+## Migration
+
+Saved flows referencing the legacy class names or the old import paths under
+`lfx.components.nextplaid.*` / `lfx.components.vllm.VllmMultivectorEmbeddingsComponent`
+are rewritten to the new namespaced IDs by the migration table in
+`src/lfx/src/lfx/extension/migration/migration_table.json`.

lfx_nextplaid-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+lfx_nextplaid/__init__.py,sha256=_nDTDeT8qzcW6kZI8UfnP-qAMx2sOwuSEJQq-utD-64,1133
+lfx_nextplaid/extension.json,sha256=MSt-OHZJXgj7vfLQfP7NRoyKR1awX2_a5eA_2Dt0ZeA,429
+lfx_nextplaid/components/nextplaid/__init__.py,sha256=M-huINV6lfNW3BYV4J7aB2yRlqewmkuqB6G-3iuRQAU,545
+lfx_nextplaid/components/nextplaid/nextplaid.py,sha256=3px9zAj7_5S72IGg--9vO7DmBSdRgsNpIcnopLQqArU,10977
+lfx_nextplaid/components/nextplaid/vllm_multivector_embeddings.py,sha256=0xNtrHbwEgJXwF7Cko7iy1i0co2DMPrW73XtEfCDD5w,2841
+lfx_nextplaid/components/nextplaid/vllm_multivector_impl.py,sha256=7bzwf4h7fD37p2rnWHfXQ7jeP9HyM2HhP1L7Gp-HV2I,7418
+lfx_nextplaid-0.1.0.dist-info/METADATA,sha256=55isHQFK4MdI876rpsJcbzGWSjSXg8-u2bKtmTdBq-Q,2874
+lfx_nextplaid-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lfx_nextplaid-0.1.0.dist-info/entry_points.txt,sha256=aj3ETYatcieUGi7bvAaSpOBL7wlwMJaMcsOy1n0DuJ8,52
+lfx_nextplaid-0.1.0.dist-info/RECORD,,

lfx_nextplaid-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_nextplaid-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-nextplaid = lfx_nextplaid