qdrant-loader-core 0.7.1__tar.gz

qdrant_loader_core-0.7.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: qdrant-loader-core
+Version: 0.7.1
+Summary: Shared core for provider-agnostic LLM support and configuration mapping for qdrant-loader ecosystem
+Author-email: Martin Papy <martin.papy@cbtw.tech>
+License-Expression: GPL-3.0
+Project-URL: Homepage, https://qdrant-loader.net
+Project-URL: Documentation, https://qdrant-loader.net/docs/packages/core/README.html
+Project-URL: Repository, https://github.com/martin-papy/qdrant-loader
+Project-URL: Issues, https://github.com/martin-papy/qdrant-loader/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Environment :: Console
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.3.0; extra == "openai"
+Requires-Dist: tiktoken>=0.5.0; extra == "openai"
+Provides-Extra: ollama
+Requires-Dist: httpx>=0.24.0; extra == "ollama"

qdrant_loader_core-0.7.1/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = [
+    "setuptools>=61.0",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qdrant-loader-core"
+version = "0.7.1"
+description = "Shared core for provider-agnostic LLM support and configuration mapping for qdrant-loader ecosystem"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "GPL-3.0"
+authors = [
+    { name = "Martin Papy", email = "martin.papy@cbtw.tech" },
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Database :: Database Engines/Servers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Indexing",
+    "Topic :: Text Processing :: Linguistic",
+    "Environment :: Console",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+openai = [
+    "openai>=1.3.0",
+    "tiktoken>=0.5.0",
+]
+ollama = [
+    "httpx>=0.24.0",
+]
+
+[project.urls]
+Homepage = "https://qdrant-loader.net"
+Documentation = "https://qdrant-loader.net/docs/packages/core/README.html"
+Repository = "https://github.com/martin-papy/qdrant-loader"
+Issues = "https://github.com/martin-papy/qdrant-loader/issues"
+
+[tool.setuptools.packages.find]
+where = [
+    "src",
+]
+
+[tool.pytest.ini_options]
+testpaths = [
+    "packages/qdrant-loader-core/tests",
+]

qdrant_loader_core-0.7.1/setup.cfg

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

qdrant_loader_core-0.7.1/src/qdrant_loader_core/__init__.py

@@ -0,0 +1,25 @@
+# qdrant-loader-core package root
+
+from .llm import (
+    ChatClient,
+    EmbeddingPolicy,
+    EmbeddingsClient,
+    LLMProvider,
+    LLMSettings,
+    RateLimitPolicy,
+    RequestPolicy,
+    TokenCounter,
+    create_provider,
+)
+
+__all__ = [
+    "EmbeddingsClient",
+    "ChatClient",
+    "TokenCounter",
+    "LLMProvider",
+    "LLMSettings",
+    "RequestPolicy",
+    "RateLimitPolicy",
+    "EmbeddingPolicy",
+    "create_provider",
+]

qdrant_loader_core-0.7.1/src/qdrant_loader_core/llm/__init__.py

@@ -0,0 +1,17 @@
+# Re-export core interfaces for convenience
+
+from .factory import create_provider
+from .settings import EmbeddingPolicy, LLMSettings, RateLimitPolicy, RequestPolicy
+from .types import ChatClient, EmbeddingsClient, LLMProvider, TokenCounter
+
+__all__ = [
+    "EmbeddingsClient",
+    "ChatClient",
+    "TokenCounter",
+    "LLMProvider",
+    "LLMSettings",
+    "RequestPolicy",
+    "RateLimitPolicy",
+    "EmbeddingPolicy",
+    "create_provider",
+]

qdrant_loader_core-0.7.1/src/qdrant_loader_core/llm/errors.py

@@ -0,0 +1,22 @@
+class LLMError(Exception):
+    pass
+
+
+class TimeoutError(LLMError):
+    pass
+
+
+class RateLimitedError(LLMError):
+    pass
+
+
+class InvalidRequestError(LLMError):
+    pass
+
+
+class AuthError(LLMError):
+    pass
+
+
+class ServerError(LLMError):
+    pass

qdrant_loader_core-0.7.1/src/qdrant_loader_core/llm/factory.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from .providers.ollama import OllamaProvider
+from .providers.openai import OpenAIProvider
+
+try:
+    from .providers.azure_openai import AzureOpenAIProvider  # type: ignore
+except Exception:  # pragma: no cover - optional dependency surface
+    AzureOpenAIProvider = None  # type: ignore
+from .settings import LLMSettings
+from .types import ChatClient, EmbeddingsClient, LLMProvider, TokenCounter
+
+
+class _NoopEmbeddings(EmbeddingsClient):
+    async def embed(self, inputs: list[str]) -> list[list[float]]:
+        raise NotImplementedError("Embeddings provider not implemented")
+
+
+class _NoopChat(ChatClient):
+    async def chat(self, messages, **kwargs):  # type: ignore[no-untyped-def]
+        raise NotImplementedError("Chat provider not implemented")
+
+
+class _NoopTokenizer(TokenCounter):
+    def count(self, text: str) -> int:  # naive char-count fallback
+        return len(text)
+
+
+class _NoopProvider(LLMProvider):
+    def embeddings(self) -> EmbeddingsClient:
+        return _NoopEmbeddings()
+
+    def chat(self) -> ChatClient:
+        return _NoopChat()
+
+    def tokenizer(self) -> TokenCounter:
+        return _NoopTokenizer()
+
+
+def _safe_hostname(url: str | None) -> str | None:
+    if not url:
+        return None
+    try:
+        host = urlparse(url).hostname
+        return host.lower() if host else None
+    except Exception:
+        return None
+
+
+def create_provider(settings: LLMSettings) -> LLMProvider:
+    """Create a provider by settings.
+
+    Phase 0: route OpenAI/OpenAI-compatible to OpenAIProvider when available; otherwise return a noop provider.
+    Ollama returns a stub provider for now.
+    """
+    provider_name = (settings.provider or "").lower()
+    base_url = (settings.base_url or "")
+    base_host = _safe_hostname(base_url)
+
+    # Route Azure before generic OpenAI routing
+    is_azure = (
+        "azure" in provider_name
+        or (
+            base_host is not None
+            and (
+                base_host == "openai.azure.com"
+                or base_host.endswith(".openai.azure.com")
+                or base_host == "cognitiveservices.azure.com"
+                or base_host.endswith(".cognitiveservices.azure.com")
+            )
+        )
+    )
+    if is_azure and AzureOpenAIProvider is not None:  # type: ignore[truthy-bool]
+        try:
+            return AzureOpenAIProvider(settings)  # type: ignore[misc]
+        except Exception:
+            return _NoopProvider()
+
+    if "openai" in provider_name or "openai" in base_url.lower():
+        try:
+            return OpenAIProvider(settings)
+        except Exception:
+            return _NoopProvider()
+
+    if provider_name == "ollama" or (base_host in ("localhost", "127.0.0.1")):
+        return OllamaProvider(settings)
+
+    return _NoopProvider()

qdrant_loader_core-0.7.1/src/qdrant_loader_core/llm/providers/__init__.py

@@ -0,0 +1,8 @@
+# Namespace package for LLM providers
+
+__all__ = [
+    "openai",
+    "ollama",
+]
+
+

qdrant_loader_core-0.7.1/src/qdrant_loader_core/llm/providers/azure_openai.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlparse
+
+try:
+    from openai import AzureOpenAI  # type: ignore
+except Exception:  # pragma: no cover - optional dependency surface
+    AzureOpenAI = None  # type: ignore
+
+from ...logging import LoggingConfig
+from ..settings import LLMSettings
+from ..types import ChatClient, EmbeddingsClient, LLMProvider, TokenCounter
+from .openai import OpenAIChat, OpenAIEmbeddings, _OpenAITokenCounter
+
+logger = LoggingConfig.get_logger(__name__)
+
+
+def _host_of(url: str | None) -> str | None:
+    if not url:
+        return None
+    try:
+        return urlparse(url).hostname or None
+    except Exception:
+        return None
+
+
+def _validate_azure_settings(settings: LLMSettings) -> None:
+    base_url = settings.base_url or ""
+    if "/openai/deployments" in base_url:
+        raise ValueError(
+            "Azure OpenAI base_url must be the resource root (e.g. https://<resource>.openai.azure.com). Do not include /openai/deployments/... in base_url."
+        )
+    if not (settings.api_version and isinstance(settings.api_version, str)):
+        raise ValueError(
+            "Azure OpenAI requires api_version (e.g. '2024-05-01-preview') in global.llm.api_version"
+        )
+
+
+class AzureOpenAIProvider(LLMProvider):
+    def __init__(self, settings: LLMSettings):
+        self._settings = settings
+        _validate_azure_settings(settings)
+
+        self._base_host = _host_of(settings.base_url)
+        if AzureOpenAI is None:
+            self._client = None
+        else:
+            # Prefer explicit azure_endpoint in provider_options; fallback to base_url
+            provider_opts = settings.provider_options or {}
+            endpoint = provider_opts.get("azure_endpoint") or settings.base_url
+            kwargs: dict[str, Any] = {
+                "api_key": settings.api_key,
+                "api_version": settings.api_version,
+            }
+            if endpoint:
+                kwargs["azure_endpoint"] = endpoint
+            self._client = AzureOpenAI(**{k: v for k, v in kwargs.items() if v is not None})
+
+    def embeddings(self) -> EmbeddingsClient:
+        model = self._settings.models.get("embeddings", "")
+        return OpenAIEmbeddings(self._client, model, self._base_host, provider_label="azure_openai")
+
+    def chat(self) -> ChatClient:
+        model = self._settings.models.get("chat", "")
+        return OpenAIChat(self._client, model, self._base_host, provider_label="azure_openai")
+
+    def tokenizer(self) -> TokenCounter:
+        return _OpenAITokenCounter(self._settings.tokenizer)
+
+

qdrant_loader_core-0.7.1/src/qdrant_loader_core/llm/providers/ollama.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+from typing import Any
+
+try:
+    import httpx  # type: ignore
+except Exception:  # pragma: no cover - optional dependency
+    httpx = None  # type: ignore
+
+from ...logging import LoggingConfig
+from ..errors import (
+    AuthError,
+    InvalidRequestError,
+    RateLimitedError,
+    ServerError,
+)
+from ..errors import (
+    TimeoutError as LLMTimeoutError,
+)
+from ..settings import LLMSettings
+from ..types import ChatClient, EmbeddingsClient, LLMProvider, TokenCounter
+
+logger = LoggingConfig.get_logger(__name__)
+
+
+def _join_url(base: str | None, path: str) -> str:
+    base = (base or "").rstrip("/")
+    path = path.lstrip("/")
+    return f"{base}/{path}" if base else f"/{path}"
+
+
+class OllamaEmbeddings(EmbeddingsClient):
+    def __init__(
+        self,
+        base_url: str | None,
+        model: str,
+        headers: dict[str, str] | None,
+        *,
+        timeout_s: float | None = None,
+        provider_options: dict[str, Any] | None = None,
+    ):
+        self._base_url = (base_url or "http://localhost:11434").rstrip("/")
+        self._model = model
+        self._headers = headers or {}
+        self._timeout_s = float(timeout_s) if timeout_s is not None else 30.0
+        self._provider_options = provider_options or {}
+
+    async def embed(self, inputs: list[str]) -> list[list[float]]:
+        if httpx is None:
+            raise NotImplementedError("httpx not available for Ollama embeddings")
+
+        # Prefer OpenAI-compatible if base_url seems to expose /v1
+        use_v1 = "/v1" in (self._base_url or "")
+        async with httpx.AsyncClient(timeout=self._timeout_s) as client:
+            try:
+                if use_v1:
+                    # OpenAI-compatible embeddings endpoint
+                    url = _join_url(self._base_url, "/embeddings")
+                    payload = {"model": self._model, "input": inputs}
+                    resp = await client.post(url, json=payload, headers=self._headers)
+                    resp.raise_for_status()
+                    data = resp.json()
+                    logger.info(
+                        "LLM request",
+                        provider="ollama",
+                        operation="embeddings",
+                        model=self._model,
+                        base_host=self._base_url,
+                        inputs=len(inputs),
+                        # latency for v1 path hard to compute here; omitted for now
+                    )
+                    return [item["embedding"] for item in data.get("data", [])]
+                else:
+                    # Determine native endpoint preference: embed | embeddings | auto (default)
+                    native_pref = str(self._provider_options.get("native_endpoint", "auto")).lower()
+                    prefer_embed = native_pref != "embeddings"
+
+                    # Try batch embed first when preferred
+                    if prefer_embed:
+                        url = _join_url(self._base_url, "/api/embed")
+                        payload = {"model": self._model, "input": inputs}
+                        try:
+                            resp = await client.post(
+                                url, json=payload, headers=self._headers
+                            )
+                            resp.raise_for_status()
+                            data = resp.json()
+                            vectors = data.get("embeddings")
+                            if not isinstance(vectors, list) or (
+                                len(vectors) != len(inputs)
+                            ):
+                                raise ValueError(
+                                    "Invalid embeddings response from /api/embed"
+                                )
+                            # Normalize to list[list[float]]
+                            norm = [list(vec) for vec in vectors]
+                            logger.info(
+                                "LLM request",
+                                provider="ollama",
+                                operation="embeddings",
+                                model=self._model,
+                                base_host=self._base_url,
+                                inputs=len(inputs),
+                                # latency for native batch path not measured in this stub
+                            )
+                            return norm
+                        except httpx.HTTPStatusError as exc:
+                            status = exc.response.status_code if exc.response else None
+                            # Fallback for servers that don't support /api/embed
+                            if status not in (404, 405, 501):
+                                raise
+
+                    # Per-item embeddings endpoint fallback or preference
+                    url = _join_url(self._base_url, "/api/embeddings")
+                    vectors2: list[list[float]] = []
+                    for text in inputs:
+                        payload = {"model": self._model, "input": text}
+                        resp = await client.post(
+                            url, json=payload, headers=self._headers
+                        )
+                        resp.raise_for_status()
+                        data = resp.json()
+                        emb = data.get("embedding")
+                        if emb is None and isinstance(data.get("data"), dict):
+                            emb = data["data"].get("embedding")
+                        if emb is None:
+                            raise ValueError(
+                                "Invalid embedding response from /api/embeddings"
+                            )
+                        vectors2.append(list(emb))
+                    logger.info(
+                        "LLM request",
+                        provider="ollama",
+                        operation="embeddings",
+                        model=self._model,
+                        base_host=self._base_url,
+                        inputs=len(inputs),
+                        # latency for per-item path not measured in this stub
+                    )
+                    return vectors2
+            except httpx.TimeoutException as exc:
+                raise LLMTimeoutError(str(exc))
+            except httpx.HTTPStatusError as exc:
+                status = exc.response.status_code if exc.response else None
+                if status == 401:
+                    raise AuthError(str(exc))
+                if status == 429:
+                    raise RateLimitedError(str(exc))
+                if status and 400 <= status < 500:
+                    raise InvalidRequestError(str(exc))
+                raise ServerError(str(exc))
+            except httpx.HTTPError as exc:
+                raise ServerError(str(exc))
+
+
+class OllamaChat(ChatClient):
+    def __init__(self, base_url: str | None, model: str, headers: dict[str, str] | None):
+        self._base_url = base_url or "http://localhost:11434"
+        self._model = model
+        self._headers = headers or {}
+
+    async def chat(self, messages: list[dict[str, Any]], **kwargs: Any) -> dict[str, Any]:
+        if httpx is None:
+            raise NotImplementedError("httpx not available for Ollama chat")
+
+        # Prefer OpenAI-compatible if base_url exposes /v1
+        use_v1 = "/v1" in (self._base_url or "")
+        # Flatten messages to a single prompt for native API; preserve roles when possible
+        if use_v1:
+            url = _join_url(self._base_url, "/chat/completions")
+            payload = {"model": self._model, "messages": messages}
+            # Map common kwargs
+            for k in ("temperature", "max_tokens", "top_p", "stop"):
+                if k in kwargs and kwargs[k] is not None:
+                    payload[k] = kwargs[k]
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                try:
+                    from datetime import datetime
+                    started = datetime.utcnow()
+                    resp = await client.post(url, json=payload, headers=self._headers)
+                    resp.raise_for_status()
+                    data = resp.json()
+                    text = ""
+                    choices = data.get("choices") or []
+                    if choices:
+                        msg = (choices[0] or {}).get("message") or {}
+                        text = msg.get("content", "") or ""
+                    duration_ms = int((datetime.utcnow() - started).total_seconds() * 1000)
+                    logger.info(
+                        "LLM request",
+                        provider="ollama",
+                        operation="chat",
+                        model=self._model,
+                        base_host=self._base_url,
+                        messages=len(messages),
+                        latency_ms=duration_ms,
+                    )
+                    return {"text": text, "raw": data, "usage": data.get("usage"), "model": data.get("model", self._model)}
+                except httpx.TimeoutException as exc:
+                    raise LLMTimeoutError(str(exc))
+                except httpx.HTTPStatusError as exc:
+                    status = exc.response.status_code if exc.response else None
+                    if status == 401:
+                        raise AuthError(str(exc))
+                    if status == 429:
+                        raise RateLimitedError(str(exc))
+                    if status and 400 <= status < 500:
+                        raise InvalidRequestError(str(exc))
+                    raise ServerError(str(exc))
+                except httpx.HTTPError as exc:
+                    raise ServerError(str(exc))
+        else:
+            # Native API
+            url = _join_url(self._base_url, "/api/chat")
+            payload = {
+                "model": self._model,
+                "messages": messages,
+                "stream": False,
+            }
+            if "temperature" in kwargs and kwargs["temperature"] is not None:
+                payload["options"] = {"temperature": kwargs["temperature"]}
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                try:
+                    from datetime import datetime
+                    started = datetime.utcnow()
+                    resp = await client.post(url, json=payload, headers=self._headers)
+                    resp.raise_for_status()
+                    data = resp.json()
+                    # Ollama native returns {"message": {"content": "..."}, ...}
+                    text = ""
+                    if isinstance(data.get("message"), dict):
+                        text = data["message"].get("content", "") or ""
+                    duration_ms = int((datetime.utcnow() - started).total_seconds() * 1000)
+                    logger.info(
+                        "LLM request",
+                        provider="ollama",
+                        operation="chat",
+                        model=self._model,
+                        base_host=self._base_url,
+                        messages=len(messages),
+                        latency_ms=duration_ms,
+                    )
+                    return {"text": text, "raw": data, "usage": None, "model": self._model}
+                except httpx.TimeoutException as exc:
+                    raise LLMTimeoutError(str(exc))
+                except httpx.HTTPStatusError as exc:
+                    status = exc.response.status_code if exc.response else None
+                    if status == 401:
+                        raise AuthError(str(exc))
+                    if status == 429:
+                        raise RateLimitedError(str(exc))
+                    if status and 400 <= status < 500:
+                        raise InvalidRequestError(str(exc))
+                    raise ServerError(str(exc))
+                except httpx.HTTPError as exc:
+                    raise ServerError(str(exc))
+
+
+class OllamaTokenizer(TokenCounter):
+    def count(self, text: str) -> int:
+        return len(text)
+
+
+class OllamaProvider(LLMProvider):
+    def __init__(self, settings: LLMSettings):
+        self._settings = settings
+
+    def embeddings(self) -> EmbeddingsClient:
+        model = self._settings.models.get("embeddings", "")
+        timeout = (self._settings.request.timeout_s if self._settings and self._settings.request else 30.0)
+        return OllamaEmbeddings(
+            self._settings.base_url,
+            model,
+            self._settings.headers,
+            timeout_s=timeout,
+            provider_options=self._settings.provider_options,
+        )
+
+    def chat(self) -> ChatClient:
+        model = self._settings.models.get("chat", "")
+        return OllamaChat(self._settings.base_url, model, self._settings.headers)
+
+    def tokenizer(self) -> TokenCounter:
+        return OllamaTokenizer()