xyberos-qdrant 0.1.0__tar.gz

xyberos_qdrant-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: xyberos-qdrant
+Version: 0.1.0
+Summary: Qdrant VectorStore plugin (RFC-0019, M4): hosted or in-memory Qdrant as an xyberos VectorStore
+License: Apache-2.0
+Keywords: xyberos,plugin,vector,qdrant,rag
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+Provides-Extra: vectors
+Requires-Dist: qdrant-client; extra == "vectors"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# xyberos-qdrant
+
+**Qdrant `VectorStore` plugin — RFC-0019, M4.** Hosted or local [Qdrant](https://qdrant.tech)
+as an `xyberos` `VectorStore`. Passes the same parity scenarios as the stdlib
+`SqliteVectorStore` (the M4 Definition of Done).
+
+## Install
+
+```bash
+pip install -e ./qdrant
+pip install qdrant-client        # or: pip install xyberos[vectors]
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_qdrant import QdrantPlugin
+
+app = create_app()
+app.load_plugin(QdrantPlugin(location=":memory:"))   # local, no infrastructure
+# hosted: QdrantPlugin(url="https://...", api_key=os.getenv("QDRANT_API_KEY"))
+
+store = app.resolve("vector_store")
+store.upsert("ns", "doc-1", [1.0, 0.0, 0.0, 0.0], {"text": "alpha"})
+hits = store.query("ns", [1.0, 0.0, 0.0, 0.0], top_k=3)
+```
+
+Or configure through the environment (`QDRANT_URL`, `QDRANT_API_KEY`,
+`QDRANT_DIM`) and let the `xyberos.plugins` entry point register it.
+
+## Design
+
+- Each **namespace** maps to a Qdrant collection using **cosine** distance
+  (higher score = more relevant, matching the `VectorStore` contract).
+- The client is imported **lazily** and a clear `ProviderError` is raised when
+  `qdrant-client` is missing.
+- Arbitrary string ids are mapped to deterministic UUIDs (Qdrant point ids are
+  `int`/`UUID`); the original id round-trips through the payload, so the
+  contract's string ids hold exactly.
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/          # unit + parity + plugin tests
+```
+
+Parity tests run against Qdrant's **in-memory local mode**, so they need no
+server; they skip cleanly if `qdrant-client` is absent.
+
+## Ship location
+
+`[vectors]` extra (`qdrant-client` already added to `pyproject.toml`).

xyberos_qdrant-0.1.0/README.md

@@ -0,0 +1,54 @@
+# xyberos-qdrant
+
+**Qdrant `VectorStore` plugin — RFC-0019, M4.** Hosted or local [Qdrant](https://qdrant.tech)
+as an `xyberos` `VectorStore`. Passes the same parity scenarios as the stdlib
+`SqliteVectorStore` (the M4 Definition of Done).
+
+## Install
+
+```bash
+pip install -e ./qdrant
+pip install qdrant-client        # or: pip install xyberos[vectors]
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_qdrant import QdrantPlugin
+
+app = create_app()
+app.load_plugin(QdrantPlugin(location=":memory:"))   # local, no infrastructure
+# hosted: QdrantPlugin(url="https://...", api_key=os.getenv("QDRANT_API_KEY"))
+
+store = app.resolve("vector_store")
+store.upsert("ns", "doc-1", [1.0, 0.0, 0.0, 0.0], {"text": "alpha"})
+hits = store.query("ns", [1.0, 0.0, 0.0, 0.0], top_k=3)
+```
+
+Or configure through the environment (`QDRANT_URL`, `QDRANT_API_KEY`,
+`QDRANT_DIM`) and let the `xyberos.plugins` entry point register it.
+
+## Design
+
+- Each **namespace** maps to a Qdrant collection using **cosine** distance
+  (higher score = more relevant, matching the `VectorStore` contract).
+- The client is imported **lazily** and a clear `ProviderError` is raised when
+  `qdrant-client` is missing.
+- Arbitrary string ids are mapped to deterministic UUIDs (Qdrant point ids are
+  `int`/`UUID`); the original id round-trips through the payload, so the
+  contract's string ids hold exactly.
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/          # unit + parity + plugin tests
+```
+
+Parity tests run against Qdrant's **in-memory local mode**, so they need no
+server; they skip cleanly if `qdrant-client` is absent.
+
+## Ship location
+
+`[vectors]` extra (`qdrant-client` already added to `pyproject.toml`).

xyberos_qdrant-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xyberos-qdrant"
+version = "0.1.0"
+description = "Qdrant VectorStore plugin (RFC-0019, M4): hosted or in-memory Qdrant as an xyberos VectorStore"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = ["xyberos>=1.0"]
+keywords = ["xyberos", "plugin", "vector", "qdrant", "rag"]
+
+[project.optional-dependencies]
+vectors = ["qdrant-client"]
+test = ["pytest"]
+
+[project.entry-points."xyberos.plugins"]
+qdrant = "xyberos_qdrant.plugin:plugin"
+
+[tool.setuptools]
+packages = ["xyberos_qdrant"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

xyberos_qdrant-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xyberos_qdrant-0.1.0/tests/test_parity.py

@@ -0,0 +1,49 @@
+"""M4 parity: QdrantVectorStore must behave like SqliteVectorStore."""
+
+from __future__ import annotations
+
+import pytest
+from xyberos.vector import SqliteVectorStore
+
+from xyberos_qdrant import QdrantVectorStore
+
+QUERY = [1.0, 0.0, 0.0, 0.0]
+
+
+def run_parity_scenarios(store) -> None:
+    """The full VectorStore contract; every adapter must pass these."""
+    store.upsert("ns", "a", [1.0, 0.0, 0.0, 0.0], {"text": "alpha"})
+    store.upsert("ns", "b", [0.8, 0.2, 0.0, 0.0], {"text": "beta"})
+    store.upsert("ns", "c", [0.5, 0.5, 0.0, 0.0], {"text": "gamma"})
+    store.upsert("other", "x", [1.0, 1.0, 1.0, 1.0], {"text": "other ns"})
+
+    hits = store.query("ns", QUERY, top_k=3)
+    assert [h.id for h in hits] == ["a", "b", "c"]
+    assert hits[0].payload["text"] == "alpha"
+    assert hits[0].score > hits[1].score > hits[2].score
+    assert len(store.query("ns", QUERY, top_k=1)) == 1
+
+    strict = store.query("ns", QUERY, top_k=3, threshold=0.99)
+    assert [h.id for h in strict] == ["a"]
+
+    store.delete("ns", "b")
+    assert [h.id for h in store.query("ns", QUERY, top_k=3)] == ["a", "c"]
+    assert [h.id for h in store.query("other", [1.0, 1.0, 1.0, 1.0], top_k=2)] == ["x"]
+    assert all(abs(h.score) < 1e-6 for h in store.query("ns", [0.0, 0.0, 0.0, 1.0], top_k=2))
+
+    store.upsert("ns", "a", [1.0, 0.0, 0.0, 0.0], {"text": "alpha-v2"})
+    assert store.query("ns", QUERY, top_k=1)[0].payload["text"] == "alpha-v2"
+
+    store.clear("ns")
+    assert store.query("ns", QUERY, top_k=3) == []
+    assert [h.id for h in store.query("other", [1.0, 1.0, 1.0, 1.0], top_k=1)] == ["x"]
+
+
+def test_sqlite_reference() -> None:
+    """The stdlib reference passes the same scenarios the adapters must match."""
+    run_parity_scenarios(SqliteVectorStore(":memory:"))
+
+
+def test_qdrant_parity():
+    pytest.importorskip("qdrant_client")
+    run_parity_scenarios(QdrantVectorStore(location=":memory:"))

xyberos_qdrant-0.1.0/tests/test_plugin.py

@@ -0,0 +1,25 @@
+"""Tests for loading the qdrant plugin into a Xyberos app."""
+
+from __future__ import annotations
+
+import pytest
+from xyberos import create_app
+
+from xyberos_qdrant import QdrantPlugin
+
+
+def test_plugin_conforms_to_contract():
+    plugin = QdrantPlugin(location=":memory:")
+    assert plugin.name == "qdrant"
+    assert callable(plugin.register) and callable(plugin.unregister)
+    assert plugin.vector_store() is plugin.vector_store()
+
+
+def test_plugin_registers_vector_store():
+    pytest.importorskip("qdrant_client")
+    app = create_app()
+    app.load_plugin(QdrantPlugin(location=":memory:"))
+    store = app.resolve("vector_store")
+    store.upsert("ns", "a", [1.0, 0.0, 0.0, 0.0], {"text": "alpha"})
+    assert store.query("ns", [1.0, 0.0, 0.0, 0.0], top_k=1)[0].payload["text"] == "alpha"
+    app.unload_plugin("qdrant")

xyberos_qdrant-0.1.0/tests/test_vector.py

@@ -0,0 +1,57 @@
+"""Unit tests for the QdrantVectorStore (in-memory local mode)."""
+
+from __future__ import annotations
+
+import pytest
+
+from xyberos_qdrant import QdrantVectorStore
+
+
+@pytest.fixture()
+def store():
+    pytest.importorskip("qdrant_client")
+    instance = QdrantVectorStore(location=":memory:")
+    return instance
+
+
+def test_upsert_and_query(store):
+    store.upsert("ns", "a", [1.0, 0.0, 0.0], {"text": "alpha"})
+    store.upsert("ns", "b", [0.0, 1.0, 0.0], {"text": "beta"})
+    hits = store.query("ns", [1.0, 0.0, 0.0], top_k=2)
+    assert hits[0].id == "a"
+    assert hits[0].payload["text"] == "alpha"
+
+
+def test_string_ids_round_trip(store):
+    store.upsert("ns", "document-1", [1.0, 0.0], {"text": "one"})
+    store.upsert("ns", "document-2", [0.0, 1.0], {"text": "two"})
+    hits = store.query("ns", [1.0, 0.0], top_k=2)
+    assert {h.id for h in hits} == {"document-1", "document-2"}
+    assert {h.payload["text"] for h in hits} == {"one", "two"}
+
+
+def test_delete(store):
+    store.upsert("ns", "a", [1.0, 0.0, 0.0, 0.0])
+    store.upsert("ns", "b", [0.0, 1.0, 0.0, 0.0])
+    store.delete("ns", "a")
+    assert [h.id for h in store.query("ns", [1.0, 0.0, 0.0, 0.0], top_k=2)] == ["b"]
+
+
+def test_clear(store):
+    store.upsert("ns", "a", [1.0, 0.0, 0.0, 0.0])
+    store.clear("ns")
+    assert store.query("ns", [1.0, 0.0, 0.0, 0.0]) == []
+
+
+def test_missing_namespace_returns_empty(store):
+    assert store.query("missing", [1.0, 0.0, 0.0, 0.0]) == []
+
+
+def test_provider_error_when_client_missing(monkeypatch):
+    import importlib.util
+
+    if importlib.util.find_spec("qdrant_client"):
+        pytest.skip("qdrant-client is installed")
+    store = QdrantVectorStore(url="http://localhost:6333")
+    with pytest.raises(Exception):
+        store.upsert("ns", "a", [1.0, 0.0, 0.0])

xyberos_qdrant-0.1.0/xyberos_qdrant/__init__.py

@@ -0,0 +1,6 @@
+"""Qdrant VectorStore plugin (RFC-0019, M4)."""
+
+from .plugin import QdrantPlugin
+from .vector import QdrantVectorStore
+
+__all__ = ["QdrantPlugin", "QdrantVectorStore"]

xyberos_qdrant-0.1.0/xyberos_qdrant/plugin.py

@@ -0,0 +1,65 @@
+"""Qdrant plugin entry point (RFC-0019, M4)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from xyberos.contracts import Plugin, VectorStore
+
+from .vector import QdrantVectorStore
+
+
+class QdrantPlugin(Plugin):
+    """Registers a :class:`QdrantVectorStore` as the app's ``vector_store``.
+
+    Configuration (in priority order): explicit constructor args, then
+    ``QDRANT_URL`` / ``QDRANT_API_KEY`` / ``QDRANT_DIM`` env vars. With no
+    configuration it defaults to Qdrant's in-memory local mode, which is
+    harmless for development and testing.
+    """
+
+    def __init__(
+        self,
+        *,
+        url: str | None = None,
+        api_key: str | None = None,
+        location: str | None = None,
+        path: str | None = None,
+        dim: int | None = None,
+        client: Any | None = None,
+    ) -> None:
+        self._url = url or os.getenv("QDRANT_URL")
+        self._api_key = api_key or os.getenv("QDRANT_API_KEY")
+        self._location = location
+        self._path = path
+        raw_dim = dim if dim is not None else os.getenv("QDRANT_DIM")
+        self._dim = int(raw_dim) if raw_dim else None
+        self._client = client
+        self._store: QdrantVectorStore | None = None
+
+    @property
+    def name(self) -> str:
+        return "qdrant"
+
+    def vector_store(self) -> QdrantVectorStore:
+        if self._store is None:
+            self._store = QdrantVectorStore(
+                url=self._url,
+                api_key=self._api_key,
+                location=self._location or (":memory:" if not self._url and not self._path else None),
+                path=self._path,
+                dim=self._dim,
+                client=self._client,
+            )
+        return self._store
+
+    def register(self, kernel: object) -> None:
+        kernel.register("vector_store", self.vector_store(), replace=True)
+
+    def unregister(self, kernel: object) -> None:
+        pass
+
+
+#: Auto-discovered by ``app.load_entry_points()``.
+plugin = QdrantPlugin()

xyberos_qdrant-0.1.0/xyberos_qdrant/vector.py

@@ -0,0 +1,193 @@
+"""Qdrant-backed :class:`~xyberos.contracts.VectorStore` (lazy ``qdrant-client``).
+
+Each namespace maps to a Qdrant collection using cosine distance. Supports
+hosted Qdrant (``url`` + optional ``api_key``) and local modes (``location=
+":memory:"`` or a ``path``). The client is imported lazily on first use and a
+clear :class:`~xyberos.exceptions.provider.ProviderError` is raised when
+``qdrant-client`` is missing (``pip install xyberos[vectors]``).
+
+Arbitrary string ids are mapped to deterministic UUIDs (Qdrant point ids are
+``int`` or ``UUID``); the original id is preserved in the payload and restored
+on query, so the :class:`VectorStore` contract (string ids) holds exactly.
+"""
+
+from __future__ import annotations
+
+import importlib
+import uuid
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from xyberos.contracts.vector import ScoredHit, VectorStore
+from xyberos.exceptions.provider import ProviderError
+
+_DEFAULT_DIM = 384
+_ID_NAMESPACE = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")  # DNS namespace
+
+
+def _require_qdrant() -> Any:
+    try:
+        importlib.import_module("qdrant_client")  # noqa: F401
+        models = importlib.import_module("qdrant_client.models")
+    except ImportError as exc:
+        raise ProviderError(
+            "the 'qdrant-client' package is required; install it with "
+            "'pip install xyberos[vectors]'"
+        ) from exc
+    return models
+
+
+class QdrantVectorStore(VectorStore):
+    """A :class:`VectorStore` backed by Qdrant (hosted or local)."""
+
+    def __init__(
+        self,
+        *,
+        url: str | None = None,
+        api_key: str | None = None,
+        location: str | None = None,
+        path: str | None = None,
+        dim: int | None = None,
+        prefer_grpc: bool = False,
+        client: Any | None = None,
+    ) -> None:
+        if dim is not None and dim <= 0:
+            raise ValueError("dim must be a positive integer")
+        self._url = url
+        self._api_key = api_key
+        self._location = location
+        self._path = path
+        self._dim = dim
+        self._prefer_grpc = prefer_grpc
+        self._client = client
+        self._known: set[str] = set()
+
+    # -- lifecycle ----------------------------------------------------------
+
+    def start(self) -> None:
+        """Connect to Qdrant (kernel lifecycle hook)."""
+        self._get_client()
+
+    def stop(self) -> None:
+        """Release the client (kernel lifecycle hook)."""
+        self._client = None
+        self._known.clear()
+
+    # -- VectorStore contract -----------------------------------------------
+
+    def upsert(
+        self,
+        namespace: str,
+        id: str,
+        vector: Sequence[float],
+        payload: Mapping[str, Any] | None = None,
+    ) -> None:
+        models = _require_qdrant()
+        client = self._get_client()
+        collection = self._ensure_collection(client, namespace, dim=len(vector), models=models)
+        stored = dict(payload or {})
+        stored["_id"] = str(id)
+        point = models.PointStruct(
+            id=self._point_id(id),
+            vector=[float(value) for value in vector],
+            payload=stored,
+        )
+        client.upsert(collection, points=[point])
+
+    def query(
+        self,
+        namespace: str,
+        vector: Sequence[float],
+        *,
+        top_k: int = 5,
+        threshold: float | None = None,
+    ) -> list[ScoredHit]:
+        client = self._get_client()
+        if not self._collection_exists(client, namespace):
+            return []
+        result = client.query_points(
+            collection_name=namespace,
+            query=[float(value) for value in vector],
+            limit=max(top_k, 1),
+            with_payload=True,
+        )
+        hits: list[ScoredHit] = []
+        for point in result.points:
+            score = float(point.score)
+            if threshold is not None and score < threshold:
+                continue
+            payload = dict(point.payload or {})
+            stored_id = payload.pop("_id", None)
+            hits.append(
+                ScoredHit(
+                    id=str(stored_id) if stored_id is not None else str(point.id),
+                    score=score,
+                    payload=payload or None,
+                )
+            )
+        return hits
+
+    def delete(self, namespace: str, id: str) -> None:
+        models = _require_qdrant()
+        client = self._get_client()
+        if not self._collection_exists(client, namespace):
+            return
+        client.delete(
+            collection_name=namespace,
+            points_selector=models.PointIdsList(points=[self._point_id(id)]),
+        )
+
+    def clear(self, namespace: str) -> None:
+        client = self._get_client()
+        if not self._collection_exists(client, namespace):
+            return
+        client.delete_collection(collection_name=namespace)
+        self._known.discard(namespace)
+
+    # -- helpers ------------------------------------------------------------
+
+    def _get_client(self) -> Any:
+        if self._client is not None:
+            return self._client
+        QdrantClient = importlib.import_module("qdrant_client").QdrantClient
+
+        if self._location is not None or self._path is not None:
+            self._client = QdrantClient(location=self._location, path=self._path)
+        else:
+            self._client = QdrantClient(
+                url=self._url,
+                api_key=self._api_key,
+                prefer_grpc=self._prefer_grpc,
+            )
+        return self._client
+
+    @staticmethod
+    def _point_id(id: str) -> Any:
+        """Map an arbitrary string id to an int or UUID (Qdrant point id)."""
+        if isinstance(id, int):
+            return id
+        text = str(id)
+        if text.isdigit():
+            return int(text)
+        return uuid.uuid5(_ID_NAMESPACE, text)
+
+    def _ensure_collection(self, client: Any, namespace: str, *, dim: int, models: Any) -> str:
+        if namespace in self._known:
+            return namespace
+        if not self._collection_exists(client, namespace):
+            client.create_collection(
+                collection_name=namespace,
+                vectors_config=models.VectorParams(
+                    size=self._dim or dim,
+                    distance=models.Distance.COSINE,
+                ),
+            )
+        self._known.add(namespace)
+        return namespace
+
+    def _collection_exists(self, client: Any, namespace: str) -> bool:
+        try:
+            client.get_collection(collection_name=namespace)
+            return True
+        except Exception:
+            return False

xyberos_qdrant-0.1.0/xyberos_qdrant.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: xyberos-qdrant
+Version: 0.1.0
+Summary: Qdrant VectorStore plugin (RFC-0019, M4): hosted or in-memory Qdrant as an xyberos VectorStore
+License: Apache-2.0
+Keywords: xyberos,plugin,vector,qdrant,rag
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+Provides-Extra: vectors
+Requires-Dist: qdrant-client; extra == "vectors"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# xyberos-qdrant
+
+**Qdrant `VectorStore` plugin — RFC-0019, M4.** Hosted or local [Qdrant](https://qdrant.tech)
+as an `xyberos` `VectorStore`. Passes the same parity scenarios as the stdlib
+`SqliteVectorStore` (the M4 Definition of Done).
+
+## Install
+
+```bash
+pip install -e ./qdrant
+pip install qdrant-client        # or: pip install xyberos[vectors]
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_qdrant import QdrantPlugin
+
+app = create_app()
+app.load_plugin(QdrantPlugin(location=":memory:"))   # local, no infrastructure
+# hosted: QdrantPlugin(url="https://...", api_key=os.getenv("QDRANT_API_KEY"))
+
+store = app.resolve("vector_store")
+store.upsert("ns", "doc-1", [1.0, 0.0, 0.0, 0.0], {"text": "alpha"})
+hits = store.query("ns", [1.0, 0.0, 0.0, 0.0], top_k=3)
+```
+
+Or configure through the environment (`QDRANT_URL`, `QDRANT_API_KEY`,
+`QDRANT_DIM`) and let the `xyberos.plugins` entry point register it.
+
+## Design
+
+- Each **namespace** maps to a Qdrant collection using **cosine** distance
+  (higher score = more relevant, matching the `VectorStore` contract).
+- The client is imported **lazily** and a clear `ProviderError` is raised when
+  `qdrant-client` is missing.
+- Arbitrary string ids are mapped to deterministic UUIDs (Qdrant point ids are
+  `int`/`UUID`); the original id round-trips through the payload, so the
+  contract's string ids hold exactly.
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/          # unit + parity + plugin tests
+```
+
+Parity tests run against Qdrant's **in-memory local mode**, so they need no
+server; they skip cleanly if `qdrant-client` is absent.
+
+## Ship location
+
+`[vectors]` extra (`qdrant-client` already added to `pyproject.toml`).

xyberos_qdrant-0.1.0/xyberos_qdrant.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+tests/test_parity.py
+tests/test_plugin.py
+tests/test_vector.py
+xyberos_qdrant/__init__.py
+xyberos_qdrant/plugin.py
+xyberos_qdrant/vector.py
+xyberos_qdrant.egg-info/PKG-INFO
+xyberos_qdrant.egg-info/SOURCES.txt
+xyberos_qdrant.egg-info/dependency_links.txt
+xyberos_qdrant.egg-info/entry_points.txt
+xyberos_qdrant.egg-info/requires.txt
+xyberos_qdrant.egg-info/top_level.txt

xyberos_qdrant-0.1.0/xyberos_qdrant.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xyberos_qdrant-0.1.0/xyberos_qdrant.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xyberos.plugins]
+qdrant = xyberos_qdrant.plugin:plugin

xyberos_qdrant-0.1.0/xyberos_qdrant.egg-info/requires.txt

@@ -0,0 +1,7 @@
+xyberos>=1.0
+
+[test]
+pytest
+
+[vectors]
+qdrant-client

xyberos_qdrant-0.1.0/xyberos_qdrant.egg-info/top_level.txt

@@ -0,0 +1 @@
+xyberos_qdrant