vectora 0.1.0__tar.gz

vectora-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vectora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vectora-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: vectora
+Version: 0.1.0
+Summary: AI Assurance Platform - Monitor, Explain, Govern every AI system in production
+Author-email: Vectora <hello@vectora.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://vectora.ai
+Project-URL: Repository, https://github.com/vectora-dev/vectora-sdk
+Keywords: machine learning,monitoring,explainability,drift detection,SHAP,MLOps
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: requests>=2.28
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: shap>=0.42
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# Vectora Python SDK
+
+Vectora helps you monitor sklearn models in production without adding latency to your prediction path.
+
+The SDK captures:
+- prediction metrics like accuracy, F1, precision, and recall
+- feature distribution summaries for drift detection
+- SHAP-based feature importance when `shap` is available
+- trace IDs that connect predictions back to the Vectora dashboard
+
+## Install
+
+```bash
+pip install vectora
+```
+
+## Quickstart
+
+```python
+from vectora import VectoraClient
+from vectora.models import SklearnConnector
+
+client = VectoraClient(api_key="vct_live_xxx")
+connector = SklearnConnector(
+    client=client,
+    model=your_sklearn_model,
+    model_id="11111111-1111-1111-1111-111111111111",
+)
+
+predictions = connector.predict(X_test, y_true=y_test)
+```
+
+`predict()` returns the model's predictions immediately. Vectora sends the monitoring payload in a background thread so your production inference path stays fast.
+
+## What gets sent
+
+Each prediction call sends a payload to `/api/ingest/metrics` with:
+- `trace_id`
+- `model_id`
+- `metrics`
+- `feature_distributions`
+- `shap_values`
+- `sample_count`
+- `timestamp`
+
+If SHAP is not installed, the SDK logs a warning once and continues without SHAP values.
+
+If the network call fails, the SDK logs the error to stderr and never raises it back to your prediction path.
+
+## API
+
+### `VectoraClient`
+
+```python
+client = VectoraClient(
+    api_key="vct_live_xxx",
+    base_url="https://vectora.ai",
+    timeout=5.0,
+    max_retries=2,
+)
+```
+
+### `SklearnConnector`
+
+```python
+connector = SklearnConnector(client, model_id="11111111-1111-1111-1111-111111111111", model=trained_model)
+predictions = connector.predict(X, y_true=y_true)
+```
+
+## Coming Soon
+
+`vectora.llm` and `vectora.agent` are reserved for future releases and raise `ComingSoonError` when accessed.
+
+## Release
+
+Tagging the repository with `v*` triggers the GitHub Actions publish workflow in [`.github/workflows/publish.yml`](.github/workflows/publish.yml).
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The workflow:
+- runs the SDK test suite
+- builds the source and wheel distributions
+- publishes to PyPI using GitHub Actions trusted publishing

vectora-0.1.0/README.md

@@ -0,0 +1,86 @@
+# Vectora Python SDK
+
+Vectora helps you monitor sklearn models in production without adding latency to your prediction path.
+
+The SDK captures:
+- prediction metrics like accuracy, F1, precision, and recall
+- feature distribution summaries for drift detection
+- SHAP-based feature importance when `shap` is available
+- trace IDs that connect predictions back to the Vectora dashboard
+
+## Install
+
+```bash
+pip install vectora
+```
+
+## Quickstart
+
+```python
+from vectora import VectoraClient
+from vectora.models import SklearnConnector
+
+client = VectoraClient(api_key="vct_live_xxx")
+connector = SklearnConnector(
+    client=client,
+    model=your_sklearn_model,
+    model_id="11111111-1111-1111-1111-111111111111",
+)
+
+predictions = connector.predict(X_test, y_true=y_test)
+```
+
+`predict()` returns the model's predictions immediately. Vectora sends the monitoring payload in a background thread so your production inference path stays fast.
+
+## What gets sent
+
+Each prediction call sends a payload to `/api/ingest/metrics` with:
+- `trace_id`
+- `model_id`
+- `metrics`
+- `feature_distributions`
+- `shap_values`
+- `sample_count`
+- `timestamp`
+
+If SHAP is not installed, the SDK logs a warning once and continues without SHAP values.
+
+If the network call fails, the SDK logs the error to stderr and never raises it back to your prediction path.
+
+## API
+
+### `VectoraClient`
+
+```python
+client = VectoraClient(
+    api_key="vct_live_xxx",
+    base_url="https://vectora.ai",
+    timeout=5.0,
+    max_retries=2,
+)
+```
+
+### `SklearnConnector`
+
+```python
+connector = SklearnConnector(client, model_id="11111111-1111-1111-1111-111111111111", model=trained_model)
+predictions = connector.predict(X, y_true=y_true)
+```
+
+## Coming Soon
+
+`vectora.llm` and `vectora.agent` are reserved for future releases and raise `ComingSoonError` when accessed.
+
+## Release
+
+Tagging the repository with `v*` triggers the GitHub Actions publish workflow in [`.github/workflows/publish.yml`](.github/workflows/publish.yml).
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The workflow:
+- runs the SDK test suite
+- builds the source and wheel distributions
+- publishes to PyPI using GitHub Actions trusted publishing

vectora-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vectora"
+version = "0.1.0"
+description = "AI Assurance Platform - Monitor, Explain, Govern every AI system in production"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "Vectora", email = "hello@vectora.ai" }]
+keywords = ["machine learning", "monitoring", "explainability", "drift detection", "SHAP", "MLOps"]
+dependencies = [
+  "numpy>=1.21",
+  "requests>=2.28",
+  "scikit-learn>=1.0",
+  "shap>=0.42",
+]
+
+[project.optional-dependencies]
+dev = ["build>=1.2.0", "pytest>=8.0"]
+
+[project.urls]
+Homepage = "https://vectora.ai"
+Repository = "https://github.com/vectora-dev/vectora-sdk"
+
+[tool.setuptools.packages.find]
+include = ["vectora*"]

vectora-0.1.0/setup.cfg

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

vectora-0.1.0/tests/test_client.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import re
+from uuid import uuid4
+
+import numpy as np
+import pytest
+
+from vectora import VectoraClient
+from vectora.compliance.trace import generate_trace_id
+from vectora.exceptions import VectoraConfigError
+from vectora.models import SklearnConnector
+
+
+class FakeModel:
+    def predict(self, X):
+        array = np.asarray(X)
+        return np.where(array[:, 0] > 0.5, 1, 0)
+
+
+def test_client_requires_vectora_key_prefix():
+    with pytest.raises(VectoraConfigError):
+        VectoraClient(api_key="invalid_key")
+
+
+def test_generate_trace_id_matches_expected_format():
+    trace_id = generate_trace_id()
+    assert re.fullmatch(r"vct_\d{8}_[a-z0-9]{4}", trace_id)
+
+
+def test_sklearn_connector_requires_uuid_model_id():
+    with pytest.raises(VectoraConfigError):
+        SklearnConnector(client=VectoraClient(api_key="vct_live_12345678901234567890"), model_id="fraud-detector-v1")
+
+
+def test_predict_returns_underlying_model_predictions(monkeypatch):
+    client = VectoraClient(api_key="vct_live_12345678901234567890")
+    connector = SklearnConnector(client=client, model=FakeModel(), model_id=str(uuid4()))
+
+    monkeypatch.setattr(SklearnConnector, "_send_payload", lambda self, payload: None)
+
+    X = np.array([[0.1, 0.2], [0.8, 0.4], [0.7, 0.9]])
+    expected = FakeModel().predict(X)
+
+    predictions = connector.predict(X)
+
+    assert np.array_equal(predictions, expected)

vectora-0.1.0/vectora/__init__.py

@@ -0,0 +1,13 @@
+from vectora._version import __version__
+from vectora.client import VectoraClient
+from vectora.compliance import generate_trace_id, is_valid_trace_id, isValidTraceId
+from vectora.models import SklearnConnector
+
+__all__ = [
+    "__version__",
+    "VectoraClient",
+    "SklearnConnector",
+    "generate_trace_id",
+    "is_valid_trace_id",
+    "isValidTraceId",
+]

vectora-0.1.0/vectora/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

vectora-0.1.0/vectora/agent/__init__.py

@@ -0,0 +1,7 @@
+from vectora.exceptions import ComingSoonError
+
+
+def __getattr__(name: str) -> None:
+    raise ComingSoonError(
+        "vectora.agent is coming soon. Agent tracing ships in a later Vectora release."
+    )

vectora-0.1.0/vectora/client.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import requests
+
+from vectora.exceptions import (
+    VectoraAuthError,
+    VectoraConfigError,
+    VectoraConnectionError,
+    VectoraNotFoundError,
+    VectoraRateLimitError,
+    VectoraServerError,
+)
+
+
+class VectoraClient:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://vectora.ai",
+        timeout: float = 5.0,
+        max_retries: int = 2,
+    ) -> None:
+        if not isinstance(api_key, str) or not api_key.startswith("vct_"):
+            raise VectoraConfigError("Vectora API keys must start with 'vct_'.")
+
+        if len(api_key.strip()) < 20:
+            raise VectoraConfigError("Vectora API keys must be at least 20 characters long.")
+
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._session = requests.Session()
+
+    def _post(self, path: str, json_payload: dict[str, Any]) -> dict[str, Any]:
+        if not path.startswith("/"):
+            raise VectoraConfigError("Vectora client paths must start with '/'.")
+
+        url = f"{self.base_url}{path}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "vectora-python-sdk/0.1.0",
+        }
+
+        last_error: Exception | None = None
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = self._session.post(
+                    url,
+                    json=json_payload,
+                    headers=headers,
+                    timeout=self.timeout,
+                )
+            except requests.Timeout as exc:
+                last_error = VectoraConnectionError(
+                    "Timed out while reaching the Vectora API. Check your network or increase the timeout."
+                )
+            except requests.RequestException as exc:
+                last_error = VectoraConnectionError(
+                    f"Couldn't reach the Vectora API: {exc}"
+                )
+            else:
+                if response.status_code == 401:
+                    raise VectoraAuthError(
+                        "Vectora rejected the API key. Verify that your key is current and starts with 'vct_'."
+                    )
+
+                if response.status_code == 404:
+                    raise VectoraNotFoundError(
+                        "The requested Vectora endpoint or resource was not found."
+                    )
+
+                if response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+                    detail = (
+                        f" Retry after {retry_after} seconds."
+                        if retry_after and retry_after.isdigit()
+                        else ""
+                    )
+                    raise VectoraRateLimitError(
+                        f"Vectora rate-limited this request.{detail}"
+                    )
+
+                if 500 <= response.status_code:
+                    raise VectoraServerError(
+                        f"Vectora returned a server error ({response.status_code}). Try again shortly."
+                    )
+
+                if not response.ok:
+                    raise VectoraServerError(
+                        f"Vectora rejected the request with status {response.status_code}: {response.text}"
+                    )
+
+                if not response.content:
+                    return {}
+
+                data = response.json()
+                return data if isinstance(data, dict) else {"data": data}
+
+            if attempt < self.max_retries:
+                time.sleep(0.25 * (attempt + 1))
+
+        raise last_error or VectoraConnectionError("Couldn't reach the Vectora API.")

vectora-0.1.0/vectora/compliance/__init__.py

@@ -0,0 +1,3 @@
+from vectora.compliance.trace import generate_trace_id, is_valid_trace_id, isValidTraceId
+
+__all__ = ["generate_trace_id", "is_valid_trace_id", "isValidTraceId"]

vectora-0.1.0/vectora/compliance/trace.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from secrets import token_hex
+import re
+
+TRACE_ID_PATTERN = re.compile(r"^vct_\d{8}_[a-z0-9]{4,}$", re.IGNORECASE)
+
+
+def generate_trace_id() -> str:
+    date_prefix = datetime.now(timezone.utc).strftime("%Y%m%d")
+    return f"vct_{date_prefix}_{token_hex(2)}"
+
+
+def is_valid_trace_id(value: str) -> bool:
+    return bool(TRACE_ID_PATTERN.fullmatch(value))
+
+
+def isValidTraceId(value: str) -> bool:
+    return is_valid_trace_id(value)

vectora-0.1.0/vectora/exceptions.py

@@ -0,0 +1,30 @@
+class VectoraError(Exception):
+    """Base exception for all SDK errors."""
+
+
+class VectoraConfigError(VectoraError):
+    """Raised when the SDK is configured incorrectly."""
+
+
+class VectoraAuthError(VectoraError):
+    """Raised when the API key is invalid or expired."""
+
+
+class VectoraConnectionError(VectoraError):
+    """Raised when the SDK cannot reach the Vectora API."""
+
+
+class VectoraRateLimitError(VectoraError):
+    """Raised when the Vectora API rate-limits the caller."""
+
+
+class VectoraNotFoundError(VectoraError):
+    """Raised when a requested Vectora resource does not exist."""
+
+
+class VectoraServerError(VectoraError):
+    """Raised when the Vectora API returns an unexpected server error."""
+
+
+class ComingSoonError(VectoraError):
+    """Raised when a not-yet-shipped SDK surface is accessed."""

vectora-0.1.0/vectora/explain/__init__.py

@@ -0,0 +1,3 @@
+from vectora.explain.shap import SHAPWrapper
+
+__all__ = ["SHAPWrapper"]

vectora-0.1.0/vectora/explain/shap.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import warnings
+from importlib import import_module
+from typing import Any
+
+import numpy as np
+
+_SHAP_WARNING_EMITTED = False
+
+
+class SHAPWrapper:
+    def compute(self, model: Any, X: Any, feature_names: list[str]) -> dict[str, float] | None:
+        shap_module = self._import_shap()
+        if shap_module is None:
+            return None
+
+        array = np.asarray(X)
+        if array.ndim == 1:
+            array = array.reshape(1, -1)
+
+        explainer = self._build_explainer(shap_module, model, array)
+        if explainer is None:
+            return None
+
+        try:
+            shap_values = explainer(array)
+            values = getattr(shap_values, "values", shap_values)
+        except Exception:
+            return None
+
+        normalized = self._normalize_values(values)
+        if normalized is None or normalized.shape[-1] != len(feature_names):
+            return None
+
+        mean_abs = np.mean(np.abs(normalized), axis=0)
+        return {
+            feature_name: float(value)
+            for feature_name, value in zip(feature_names, mean_abs)
+        }
+
+    def _build_explainer(self, shap_module: Any, model: Any, background: np.ndarray) -> Any:
+        try:
+            return shap_module.Explainer(model, background)
+        except Exception:
+            try:
+                return shap_module.Explainer(model.predict, background)
+            except Exception:
+                return None
+
+    def _import_shap(self) -> Any | None:
+        global _SHAP_WARNING_EMITTED
+
+        try:
+            return import_module("shap")
+        except Exception:
+            if not _SHAP_WARNING_EMITTED:
+                warnings.warn(
+                    "The 'shap' package is not installed. Vectora will skip SHAP values until it is available.",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+                _SHAP_WARNING_EMITTED = True
+            return None
+
+    def _normalize_values(self, values: Any) -> np.ndarray | None:
+        array = np.asarray(values)
+
+        if array.ndim == 3:
+            array = array[..., 0]
+
+        if array.ndim == 1:
+            array = array.reshape(1, -1)
+
+        if array.ndim != 2:
+            return None
+
+        return array

vectora-0.1.0/vectora/llm/__init__.py

@@ -0,0 +1,7 @@
+from vectora.exceptions import ComingSoonError
+
+
+def __getattr__(name: str) -> None:
+    raise ComingSoonError(
+        "vectora.llm is coming soon. LLM observability ships in a later Vectora release."
+    )

vectora-0.1.0/vectora/models/__init__.py

@@ -0,0 +1,3 @@
+from vectora.models.sklearn import SklearnConnector
+
+__all__ = ["SklearnConnector"]

vectora-0.1.0/vectora/models/sklearn.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import sys
+import threading
+from typing import Any
+from uuid import UUID
+
+import numpy as np
+
+from vectora.compliance.trace import generate_trace_id
+from vectora.exceptions import VectoraConfigError
+from vectora.explain.shap import SHAPWrapper
+
+try:
+    from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+except Exception:  # pragma: no cover - dependency contract handles this at install time
+    accuracy_score = None
+    f1_score = None
+    precision_score = None
+    recall_score = None
+
+
+class SklearnConnector:
+    def __init__(self, client: Any, model_id: str, model: Any | None = None) -> None:
+        self.client = client
+        self.model = model
+        self.model_id = self._validate_model_id(model_id)
+        self._shap = SHAPWrapper()
+
+    def predict(self, X: Any, y_true: Any | None = None, model: Any | None = None) -> Any:
+        model_to_use = model or self.model
+        if model_to_use is None:
+            raise VectoraConfigError(
+                "Provide a fitted sklearn-compatible model when creating SklearnConnector or calling predict()."
+            )
+
+        predictions = model_to_use.predict(X)
+        payload = self._build_payload(model_to_use, X, predictions, y_true=y_true)
+
+        thread = threading.Thread(
+            target=self._send_payload,
+            args=(payload,),
+            daemon=True,
+        )
+        thread.start()
+
+        return predictions
+
+    def _build_payload(
+        self,
+        model: Any,
+        X: Any,
+        predictions: Any,
+        y_true: Any | None = None,
+    ) -> dict[str, Any]:
+        feature_names = self._feature_names(X)
+        metrics = self._compute_metrics(y_true, predictions)
+        feature_distributions = self._compute_distributions(X, feature_names)
+        shap_values = self._shap.compute(model, X, feature_names)
+
+        return {
+            "trace_id": generate_trace_id(),
+            "model_id": self.model_id,
+            "metrics": metrics,
+            "feature_distributions": feature_distributions,
+            "shap_values": shap_values,
+            "sample_count": int(self._row_count(X)),
+            "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        }
+
+    def _compute_metrics(self, y_true: Any | None, predictions: Any) -> dict[str, float]:
+        if y_true is None:
+            return {}
+
+        if accuracy_score is None or f1_score is None or precision_score is None or recall_score is None:
+            return {}
+
+        y_true_array = np.asarray(y_true)
+        predictions_array = np.asarray(predictions)
+        average = "binary" if len(np.unique(y_true_array)) <= 2 else "weighted"
+
+        return {
+            "accuracy": float(accuracy_score(y_true_array, predictions_array)),
+            "f1": float(f1_score(y_true_array, predictions_array, average=average, zero_division=0)),
+            "precision": float(
+                precision_score(y_true_array, predictions_array, average=average, zero_division=0)
+            ),
+            "recall": float(recall_score(y_true_array, predictions_array, average=average, zero_division=0)),
+        }
+
+    def _compute_distributions(self, X: Any, feature_names: list[str]) -> dict[str, dict[str, float]]:
+        array = self._as_2d_array(X)
+        distributions: dict[str, dict[str, float]] = {}
+
+        for index, feature_name in enumerate(feature_names):
+            column = array[:, index].astype(float)
+            distributions[feature_name] = {
+                "mean": float(np.mean(column)),
+                "std": float(np.std(column)),
+                "p25": float(np.percentile(column, 25)),
+                "p50": float(np.percentile(column, 50)),
+                "p75": float(np.percentile(column, 75)),
+            }
+
+        return distributions
+
+    def _send_payload(self, payload: dict[str, Any]) -> None:
+        trace_id = payload.get("trace_id", "unknown-trace")
+        try:
+            self.client._post("/api/ingest/metrics", payload)
+        except Exception as exc:
+            print(
+                f"[vectora] failed to send metrics for trace_id={trace_id}: {exc}",
+                file=sys.stderr,
+            )
+
+    def _feature_names(self, X: Any) -> list[str]:
+        if hasattr(X, "columns"):
+            return [str(column) for column in X.columns]
+
+        array = self._as_2d_array(X)
+        return [f"feature_{index}" for index in range(array.shape[1])]
+
+    def _as_2d_array(self, X: Any) -> np.ndarray:
+        if hasattr(X, "to_numpy"):
+            array = X.to_numpy()
+        else:
+            array = np.asarray(X)
+
+        if array.ndim == 1:
+            array = array.reshape(1, -1)
+
+        if array.ndim != 2:
+            raise VectoraConfigError("X must be a 2D array-like object for Vectora monitoring.")
+
+        return array
+
+    def _row_count(self, X: Any) -> int:
+        return int(self._as_2d_array(X).shape[0])
+
+    def _validate_model_id(self, model_id: str) -> str:
+        try:
+            return str(UUID(model_id))
+        except (ValueError, TypeError) as exc:
+            raise VectoraConfigError("model_id must be a valid UUID string.") from exc

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

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: vectora
+Version: 0.1.0
+Summary: AI Assurance Platform - Monitor, Explain, Govern every AI system in production
+Author-email: Vectora <hello@vectora.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://vectora.ai
+Project-URL: Repository, https://github.com/vectora-dev/vectora-sdk
+Keywords: machine learning,monitoring,explainability,drift detection,SHAP,MLOps
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: requests>=2.28
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: shap>=0.42
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# Vectora Python SDK
+
+Vectora helps you monitor sklearn models in production without adding latency to your prediction path.
+
+The SDK captures:
+- prediction metrics like accuracy, F1, precision, and recall
+- feature distribution summaries for drift detection
+- SHAP-based feature importance when `shap` is available
+- trace IDs that connect predictions back to the Vectora dashboard
+
+## Install
+
+```bash
+pip install vectora
+```
+
+## Quickstart
+
+```python
+from vectora import VectoraClient
+from vectora.models import SklearnConnector
+
+client = VectoraClient(api_key="vct_live_xxx")
+connector = SklearnConnector(
+    client=client,
+    model=your_sklearn_model,
+    model_id="11111111-1111-1111-1111-111111111111",
+)
+
+predictions = connector.predict(X_test, y_true=y_test)
+```
+
+`predict()` returns the model's predictions immediately. Vectora sends the monitoring payload in a background thread so your production inference path stays fast.
+
+## What gets sent
+
+Each prediction call sends a payload to `/api/ingest/metrics` with:
+- `trace_id`
+- `model_id`
+- `metrics`
+- `feature_distributions`
+- `shap_values`
+- `sample_count`
+- `timestamp`
+
+If SHAP is not installed, the SDK logs a warning once and continues without SHAP values.
+
+If the network call fails, the SDK logs the error to stderr and never raises it back to your prediction path.
+
+## API
+
+### `VectoraClient`
+
+```python
+client = VectoraClient(
+    api_key="vct_live_xxx",
+    base_url="https://vectora.ai",
+    timeout=5.0,
+    max_retries=2,
+)
+```
+
+### `SklearnConnector`
+
+```python
+connector = SklearnConnector(client, model_id="11111111-1111-1111-1111-111111111111", model=trained_model)
+predictions = connector.predict(X, y_true=y_true)
+```
+
+## Coming Soon
+
+`vectora.llm` and `vectora.agent` are reserved for future releases and raise `ComingSoonError` when accessed.
+
+## Release
+
+Tagging the repository with `v*` triggers the GitHub Actions publish workflow in [`.github/workflows/publish.yml`](.github/workflows/publish.yml).
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The workflow:
+- runs the SDK test suite
+- builds the source and wheel distributions
+- publishes to PyPI using GitHub Actions trusted publishing

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

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_client.py
+vectora/__init__.py
+vectora/_version.py
+vectora/client.py
+vectora/exceptions.py
+vectora.egg-info/PKG-INFO
+vectora.egg-info/SOURCES.txt
+vectora.egg-info/dependency_links.txt
+vectora.egg-info/requires.txt
+vectora.egg-info/top_level.txt
+vectora/agent/__init__.py
+vectora/compliance/__init__.py
+vectora/compliance/trace.py
+vectora/explain/__init__.py
+vectora/explain/shap.py
+vectora/llm/__init__.py
+vectora/models/__init__.py
+vectora/models/sklearn.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,8 @@
+numpy>=1.21
+requests>=2.28
+scikit-learn>=1.0
+shap>=0.42
+
+[dev]
+build>=1.2.0
+pytest>=8.0

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

@@ -0,0 +1 @@
+vectora