orca-sdk 0.0.93__py3-none-any.whl → 0.0.95__py3-none-any.whl

orca_sdk/telemetry.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import logging
+from abc import ABC
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Generator, Iterable, overload
+from typing import TYPE_CHECKING, Any, Generator, Iterable, Self, overload
 from uuid import UUID
 
 from orca_sdk._utils.common import UNSET
@@ -23,14 +24,21 @@ from ._generated_api_client.models import (
     ListPredictionsRequest,
     PredictionFeedbackCategory,
     PredictionFeedbackRequest,
+    ScorePredictionWithMemoriesAndFeedback,
     UpdatePredictionRequest,
 )
 from ._generated_api_client.types import UNSET as CLIENT_UNSET
 from ._utils.prediction_result_ui import inspect_prediction_result
-from .memoryset import LabeledMemoryLookup, LabeledMemoryset
+from .memoryset import (
+    LabeledMemoryLookup,
+    LabeledMemoryset,
+    ScoredMemoryLookup,
+    ScoredMemoryset,
+)
 
 if TYPE_CHECKING:
     from .classification_model import ClassificationModel
+    from .regression_model import RegressionModel
 
 
 def _parse_feedback(feedback: dict[str, Any]) -> PredictionFeedbackRequest:
@@ -107,88 +115,61 @@ class FeedbackCategory:
         return "FeedbackCategory({" + f"name: {self.name}, " + f"value_type: {self.value_type}" + "})"
 
 
-class LabelPrediction:
-    """
-    A prediction made by a model
-
-    Attributes:
-        prediction_id: Unique identifier for the prediction
-        label: Predicted label for the input value
-        label_name: Name of the predicted label
-        confidence: Confidence of the prediction
-        anomaly_score: The score for how anomalous the input is relative to the memories
-        memory_lookups: List of memories used to ground the prediction
-        input_value: Input value that this prediction was for
-        model: Model that was used to make the prediction
-        memoryset: Memoryset that was used to lookup memories to ground the prediction
-        expected_label: Optional expected label that was set for the prediction
-        expected_label_name: Name of the expected label
-        tags: tags that were set for the prediction
-        feedback: Feedback recorded, mapping from category name to value
-        explanation: Explanation why the model made the prediction generated by a reasoning agent
-    """
-
+class _Prediction(ABC):
     prediction_id: str | None
-    label: int
-    label_name: str | None
     confidence: float
     anomaly_score: float | None
-    memoryset: LabeledMemoryset
-    model: ClassificationModel
-    logits: list[float] | None
 
     def __init__(
         self,
         prediction_id: str | None,
         *,
-        label: int,
+        label: int | None,
         label_name: str | None,
+        score: float | None,
         confidence: float,
         anomaly_score: float | None,
-        memoryset: LabeledMemoryset | str,
-        model: ClassificationModel | str,
-        telemetry: LabelPredictionWithMemoriesAndFeedback | None = None,
+        memoryset: LabeledMemoryset | ScoredMemoryset,
+        model: ClassificationModel | RegressionModel,
+        telemetry: LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback | None = None,
         logits: list[float] | None = None,
+        input_value: str | None = None,
     ):
-        # for internal use only, do not document
-        from .classification_model import ClassificationModel
-
         self.prediction_id = prediction_id
         self.label = label
         self.label_name = label_name
+        self.score = score
         self.confidence = confidence
         self.anomaly_score = anomaly_score
-        self.memoryset = LabeledMemoryset.open(memoryset) if isinstance(memoryset, str) else memoryset
-        self.model = ClassificationModel.open(model) if isinstance(model, str) else model
+        self.memoryset = memoryset
+        self.model = model
         self.__telemetry = telemetry if telemetry else None
         self.logits = logits
-
-    def __repr__(self):
-        return (
-            "LabelPrediction({"
-            + f"label: <{self.label_name}: {self.label}>, "
-            + f"confidence: {self.confidence:.2f}, "
-            + f"anomaly_score: {self.anomaly_score:.2f}, "
-            if self.anomaly_score is not None
-            else ""
-            + f"input_value: '{str(self.input_value)[:100] + '...' if len(str(self.input_value)) > 100 else self.input_value}'"
-            + "})"
-        )
+        self._input_value = input_value
 
     @property
-    def _telemetry(self) -> LabelPredictionWithMemoriesAndFeedback:
+    def _telemetry(self) -> LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback:
         # for internal use only, do not document
         if self.__telemetry is None:
             self.__telemetry = get_prediction(prediction_id=UUID(self.prediction_id))
         return self.__telemetry
 
     @property
-    def memory_lookups(self) -> list[LabeledMemoryLookup]:
-        return [LabeledMemoryLookup(self.memoryset.id, lookup) for lookup in self._telemetry.memories]
+    def input_value(self) -> str:
+        if self._input_value is not None:
+            return self._input_value
+        assert isinstance(self._telemetry.input_value, str)
+        return self._telemetry.input_value
 
     @property
-    def input_value(self) -> str | list[list[float]] | None:
-        return self._telemetry.input_value
+    def memory_lookups(self) -> list[LabeledMemoryLookup] | list[ScoredMemoryLookup]:
+        match self._telemetry:
+            case LabelPredictionWithMemoriesAndFeedback():
+                return [
+                    LabeledMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories
+                ]
+            case ScorePredictionWithMemoriesAndFeedback():
+                return [ScoredMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories]
 
     @property
     def feedback(self) -> dict[str, bool | float]:
@@ -199,14 +180,6 @@ class LabelPrediction:
             for f in self._telemetry.feedbacks
         }
 
-    @property
-    def expected_label(self) -> int | None:
-        return self._telemetry.expected_label
-
-    @property
-    def expected_label_name(self) -> str | None:
-        return self._telemetry.expected_label_name
-
     @property
     def tags(self) -> set[str]:
         return set(self._telemetry.tags)
@@ -244,16 +217,16 @@ class LabelPrediction:
 
     @overload
     @classmethod
-    def get(cls, prediction_id: str) -> LabelPrediction:  # type: ignore -- this takes precedence
+    def get(cls, prediction_id: str) -> Self:  # type: ignore -- this takes precedence
         pass
 
     @overload
     @classmethod
-    def get(cls, prediction_id: Iterable[str]) -> list[LabelPrediction]:
+    def get(cls, prediction_id: Iterable[str]) -> list[Self]:
         pass
 
     @classmethod
-    def get(cls, prediction_id: str | Iterable[str]) -> LabelPrediction | list[LabelPrediction]:
+    def get(cls, prediction_id: str | Iterable[str]) -> Self | list[Self]:
         """
         Fetch a prediction or predictions
 
@@ -301,30 +274,40 @@ class LabelPrediction:
                 }),
             ]
         """
-        if isinstance(prediction_id, str):
-            prediction = get_prediction(prediction_id=UUID(prediction_id))
+        from .classification_model import ClassificationModel
+        from .regression_model import RegressionModel
+
+        def create_prediction(
+            prediction: LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback,
+        ) -> Self:
+
+            if isinstance(prediction, LabelPredictionWithMemoriesAndFeedback):
+                memoryset = LabeledMemoryset.open(prediction.memoryset_id)
+                model = ClassificationModel.open(prediction.model_id)
+            elif isinstance(prediction, ScorePredictionWithMemoriesAndFeedback):
+                memoryset = ScoredMemoryset.open(prediction.memoryset_id)
+                model = RegressionModel.open(prediction.model_id)
+            else:
+                raise ValueError(f"Invalid prediction type: {type(prediction)}")
+
             return cls(
                 prediction_id=prediction.prediction_id,
-                label=prediction.label,
-                label_name=prediction.label_name,
+                label=getattr(prediction, "label", None),
+                label_name=getattr(prediction, "label_name", None),
+                score=getattr(prediction, "score", None),
                 confidence=prediction.confidence,
                 anomaly_score=prediction.anomaly_score,
-                memoryset=prediction.memoryset_id,
-                model=prediction.model_id,
+                memoryset=memoryset,
+                model=model,
                 telemetry=prediction,
             )
+
+        if isinstance(prediction_id, str):
+            prediction = get_prediction(prediction_id=UUID(prediction_id))
+            return create_prediction(prediction)
         else:
             return [
-                cls(
-                    prediction_id=prediction.prediction_id,
-                    label=prediction.label,
-                    label_name=prediction.label_name,
-                    confidence=prediction.confidence,
-                    anomaly_score=prediction.anomaly_score,
-                    memoryset=prediction.memoryset_id,
-                    model=prediction.model_id,
-                    telemetry=prediction,
-                )
+                create_prediction(prediction)
                 for prediction in list_predictions(body=ListPredictionsRequest(prediction_ids=list(prediction_id)))
             ]
 
@@ -332,30 +315,15 @@ class LabelPrediction:
         """Refresh the prediction data from the OrcaCloud"""
         if self.prediction_id is None:
             raise ValueError("Cannot refresh prediction with no prediction ID")
-        self.__dict__.update(LabelPrediction.get(self.prediction_id).__dict__)
-
-    def inspect(self):
-        """Open a UI to inspect the memories used by this prediction"""
-        inspect_prediction_result(self)
-
-    def update(self, *, expected_label: int | None = UNSET, tags: set[str] | None = UNSET) -> None:
-        """
-        Update editable prediction properties.
-
-        Params:
-            expected_label: Value to set for the expected label, defaults to `[UNSET]` if not provided.
-            tags: Value to replace existing tags with, defaults to `[UNSET]` if not provided.
+        self.__dict__.update(self.get(self.prediction_id).__dict__)
 
-        Examples:
-            Update the expected label:
-            >>> prediction.update(expected_label=1)
-
-            Add a new tag:
-            >>> prediction.update(tags=prediction.tags | {"new_tag"})
-
-            Remove expected label and tags:
-            >>> prediction.update(expected_label=None, tags=None)
-        """
+    def _update(
+        self,
+        *,
+        tags: set[str] | None = UNSET,
+        expected_label: int | None = UNSET,
+        expected_score: float | None = UNSET,
+    ) -> None:
         if self.prediction_id is None:
             raise ValueError("Cannot update prediction with no prediction ID")
 
@@ -363,6 +331,7 @@ class LabelPrediction:
             prediction_id=self.prediction_id,
             body=UpdatePredictionRequest(
                 expected_label=expected_label if expected_label is not UNSET else CLIENT_UNSET,
+                expected_score=expected_score if expected_score is not UNSET else CLIENT_UNSET,
                 tags=[] if tags is None else list(tags) if tags is not UNSET else CLIENT_UNSET,
             ),
         )
@@ -375,7 +344,7 @@ class LabelPrediction:
         Params:
             tag: Tag to add to the prediction
         """
-        self.update(tags=self.tags | {tag})
+        self._update(tags=self.tags | {tag})
 
     def remove_tag(self, tag: str) -> None:
         """
@@ -384,7 +353,7 @@ class LabelPrediction:
         Params:
             tag: Tag to remove from the prediction
         """
-        self.update(tags=self.tags - {tag})
+        self._update(tags=self.tags - {tag})
 
     def record_feedback(
         self,
@@ -446,3 +415,153 @@ class LabelPrediction:
             body=[PredictionFeedbackRequest(prediction_id=self.prediction_id, category_name=category, value=None)]
         )
         self.refresh()
+
+    def inspect(self) -> None:
+        """
+        Display an interactive UI with the details about this prediction
+
+        Params:
+            **kwargs: Additional keyword arguments to pass to the display function
+
+        Note:
+            This method is only available in Jupyter notebooks.
+        """
+        inspect_prediction_result(self)  # type: ignore
+
+
+class ClassificationPrediction(_Prediction):
+    """
+    Labeled prediction result from a [`ClassificationModel`][orca_sdk.ClassificationModel]
+
+    Attributes:
+        prediction_id: Unique identifier of this prediction used for feedback
+        label: Label predicted by the model
+        label_name: Human-readable name of the label
+        confidence: Confidence of the prediction
+        anomaly_score: Anomaly score of the input
+        input_value: The input value used for the prediction
+        expected_label: Expected label for the prediction, useful when evaluating the model
+        expected_label_name: Human-readable name of the expected label
+        memory_lookups: Memories used by the model to make the prediction
+        explanation: Natural language explanation of the prediction, only available if the model
+            has the Explain API enabled
+        tags: Tags for the prediction, useful for filtering and grouping predictions
+        model: Model used to make the prediction
+        memoryset: Memoryset that was used to lookup memories to ground the prediction
+    """
+
+    label: int
+    label_name: str
+    logits: list[float] | None
+    model: ClassificationModel
+    memoryset: LabeledMemoryset
+
+    def __repr__(self):
+        return (
+            "ClassificationPrediction({"
+            + f"label: <{self.label_name}: {self.label}>, "
+            + f"confidence: {self.confidence:.2f}, "
+            + (f"anomaly_score: {self.anomaly_score:.2f}, " if self.anomaly_score is not None else "")
+            + f"input_value: '{str(self.input_value)[:100] + '...' if len(str(self.input_value)) > 100 else self.input_value}'"
+            + "})"
+        )
+
+    @property
+    def memory_lookups(self) -> list[LabeledMemoryLookup]:
+        assert isinstance(self._telemetry, LabelPredictionWithMemoriesAndFeedback)
+        return [LabeledMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories]
+
+    @property
+    def expected_label(self) -> int | None:
+        assert isinstance(self._telemetry, LabelPredictionWithMemoriesAndFeedback)
+        return self._telemetry.expected_label
+
+    @property
+    def expected_label_name(self) -> str | None:
+        assert isinstance(self._telemetry, LabelPredictionWithMemoriesAndFeedback)
+        return self._telemetry.expected_label_name
+
+    def update(
+        self,
+        *,
+        tags: set[str] | None = UNSET,
+        expected_label: int | None = UNSET,
+    ) -> None:
+        """
+        Update the prediction.
+
+        Note:
+            If a field is not provided, it will default to [UNSET][orca_sdk.UNSET] and not be updated.
+
+        Params:
+            tags: New tags to set for the prediction. Set to `None` to remove all tags.
+            expected_label: New expected label to set for the prediction. Set to `None` to remove.
+        """
+        self._update(tags=tags, expected_label=expected_label)
+
+
+class RegressionPrediction(_Prediction):
+    """
+    Score-based prediction result from a [`RegressionModel`][orca_sdk.RegressionModel]
+
+    Attributes:
+        prediction_id: Unique identifier of this prediction used for feedback
+        score: Score predicted by the model
+        confidence: Confidence of the prediction
+        anomaly_score: Anomaly score of the input
+        input_value: The input value used for the prediction
+        expected_score: Expected score for the prediction, useful when evaluating the model
+        memory_lookups: Memories used by the model to make the prediction
+        explanation: Natural language explanation of the prediction, only available if the model
+            has the Explain API enabled
+        tags: Tags for the prediction, useful for filtering and grouping predictions
+        model: Model used to make the prediction
+        memoryset: Memoryset that was used to lookup memories to ground the prediction
+    """
+
+    score: float
+    model: RegressionModel
+    memoryset: ScoredMemoryset
+
+    def __repr__(self):
+        return (
+            "RegressionPrediction({"
+            + f"score: {self.score:.2f}, "
+            + f"confidence: {self.confidence:.2f}, "
+            + (f"anomaly_score: {self.anomaly_score:.2f}, " if self.anomaly_score is not None else "")
+            + f"input_value: '{str(self.input_value)[:100] + '...' if len(str(self.input_value)) > 100 else self.input_value}'"
+            + "})"
+        )
+
+    @property
+    def memory_lookups(self) -> list[ScoredMemoryLookup]:
+        assert isinstance(self._telemetry, ScorePredictionWithMemoriesAndFeedback)
+        return [ScoredMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories]
+
+    @property
+    def explanation(self) -> str:
+        """The explanation for this prediction. Requires `lighthouse_client_api_key` to be set."""
+        raise NotImplementedError("Explanation is not supported for regression predictions")
+
+    @property
+    def expected_score(self) -> float | None:
+        assert isinstance(self._telemetry, ScorePredictionWithMemoriesAndFeedback)
+        return self._telemetry.expected_score
+
+    def update(
+        self,
+        *,
+        tags: set[str] | None = UNSET,
+        expected_score: float | None = UNSET,
+    ) -> None:
+        """
+        Update the prediction.
+
+        Note:
+            If a field is not provided, it will default to [UNSET][orca_sdk.UNSET] and not be updated.
+
+        Params:
+            tags: New tags to set for the prediction. Set to `None` to remove all tags.
+            expected_score: New expected score to set for the prediction. Set to `None` to remove.
+        """
+        self._update(tags=tags, expected_score=expected_score)

orca_sdk/telemetry_test.py

@@ -2,75 +2,79 @@ import pytest
 
 from .classification_model import ClassificationModel
 from .memoryset import LabeledMemoryLookup
-from .telemetry import FeedbackCategory, LabelPrediction
+from .telemetry import ClassificationPrediction, FeedbackCategory
 
 
-def test_get_prediction(model: ClassificationModel):
-    predictions = model.predict(["Do you love soup?", "Are cats cute?"])
+def test_get_prediction(classification_model: ClassificationModel):
+    predictions = classification_model.predict(["Do you love soup?", "Are cats cute?"])
     assert len(predictions) == 2
     assert predictions[0].prediction_id is not None
     assert predictions[1].prediction_id is not None
-    prediction_with_telemetry = LabelPrediction.get(predictions[0].prediction_id)
+    prediction_with_telemetry = ClassificationPrediction.get(predictions[0].prediction_id)
     assert prediction_with_telemetry is not None
     assert prediction_with_telemetry.label == 0
     assert prediction_with_telemetry.input_value == "Do you love soup?"
 
 
-def test_get_predictions(model: ClassificationModel):
-    predictions = model.predict(["Do you love soup?", "Are cats cute?"])
+def test_get_predictions(classification_model: ClassificationModel):
+    predictions = classification_model.predict(["Do you love soup?", "Are cats cute?"])
     assert len(predictions) == 2
     assert predictions[0].prediction_id is not None
     assert predictions[1].prediction_id is not None
-    prediction_with_telemetry = LabelPrediction.get([predictions[0].prediction_id, predictions[1].prediction_id])
+    prediction_with_telemetry = ClassificationPrediction.get(
+        [predictions[0].prediction_id, predictions[1].prediction_id]
+    )
     assert len(prediction_with_telemetry) == 2
     assert prediction_with_telemetry[0].label == 0
     assert prediction_with_telemetry[0].input_value == "Do you love soup?"
     assert prediction_with_telemetry[1].label == 1
 
 
-def test_get_predictions_with_expected_label_match(model: ClassificationModel):
-    model.predict(["Do you love soup?", "Are cats cute?"], expected_labels=[0, 0], tags={"expected_label_match"})
-    model.predict("no expectations", tags={"expected_label_match"})
-    assert len(model.predictions(tag="expected_label_match")) == 3
-    assert len(model.predictions(expected_label_match=True, tag="expected_label_match")) == 1
-    assert len(model.predictions(expected_label_match=False, tag="expected_label_match")) == 1
+def test_get_predictions_with_expected_label_match(classification_model: ClassificationModel):
+    classification_model.predict(
+        ["Do you love soup?", "Are cats cute?"], expected_labels=[0, 0], tags={"expected_label_match"}
+    )
+    classification_model.predict("no expectations", tags={"expected_label_match"})
+    assert len(classification_model.predictions(tag="expected_label_match")) == 3
+    assert len(classification_model.predictions(expected_label_match=True, tag="expected_label_match")) == 1
+    assert len(classification_model.predictions(expected_label_match=False, tag="expected_label_match")) == 1
 
 
-def test_get_prediction_memory_lookups(model: ClassificationModel):
-    prediction = model.predict("Do you love soup?")
+def test_get_prediction_memory_lookups(classification_model: ClassificationModel):
+    prediction = classification_model.predict("Do you love soup?")
     assert isinstance(prediction.memory_lookups, list)
     assert len(prediction.memory_lookups) > 0
     assert all(isinstance(lookup, LabeledMemoryLookup) for lookup in prediction.memory_lookups)
 
 
-def test_record_feedback(model: ClassificationModel):
-    prediction = model.predict("Do you love soup?")
+def test_record_feedback(classification_model: ClassificationModel):
+    prediction = classification_model.predict("Do you love soup?")
     assert "correct" not in prediction.feedback
     prediction.record_feedback(category="correct", value=prediction.label == 0)
     assert prediction.feedback["correct"] is True
 
 
-def test_record_feedback_with_invalid_value(model: ClassificationModel):
+def test_record_feedback_with_invalid_value(classification_model: ClassificationModel):
     with pytest.raises(ValueError, match=r"Invalid input.*"):
-        model.predict("Do you love soup?").record_feedback(category="correct", value="not a bool")  # type: ignore
+        classification_model.predict("Do you love soup?").record_feedback(category="correct", value="not a bool")  # type: ignore
 
 
-def test_record_feedback_with_inconsistent_value_for_category(model: ClassificationModel):
-    model.predict("Do you love soup?").record_feedback(category="correct", value=True)
+def test_record_feedback_with_inconsistent_value_for_category(classification_model: ClassificationModel):
+    classification_model.predict("Do you love soup?").record_feedback(category="correct", value=True)
     with pytest.raises(ValueError, match=r"Invalid input.*"):
-        model.predict("Do you love soup?").record_feedback(category="correct", value=-1.0)
+        classification_model.predict("Do you love soup?").record_feedback(category="correct", value=-1.0)
 
 
-def test_delete_feedback(model: ClassificationModel):
-    prediction = model.predict("Do you love soup?")
+def test_delete_feedback(classification_model: ClassificationModel):
+    prediction = classification_model.predict("Do you love soup?")
     prediction.record_feedback(category="test_delete", value=True)
     assert "test_delete" in prediction.feedback
     prediction.delete_feedback("test_delete")
     assert "test_delete" not in prediction.feedback
 
 
-def test_list_feedback_categories(model: ClassificationModel):
-    prediction = model.predict("Do you love soup?")
+def test_list_feedback_categories(classification_model: ClassificationModel):
+    prediction = classification_model.predict("Do you love soup?")
     prediction.record_feedback(category="correct", value=True)
     prediction.record_feedback(category="confidence", value=0.8)
     categories = FeedbackCategory.all()
@@ -79,8 +83,8 @@ def test_list_feedback_categories(model: ClassificationModel):
     assert any(c.name == "confidence" and c.value_type == float for c in categories)
 
 
-def test_drop_feedback_category(model: ClassificationModel):
-    prediction = model.predict("Do you love soup?")
+def test_drop_feedback_category(classification_model: ClassificationModel):
+    prediction = classification_model.predict("Do you love soup?")
     prediction.record_feedback(category="test_category", value=True)
     assert any(c.name == "test_category" for c in FeedbackCategory.all())
     FeedbackCategory.drop("test_category")
@@ -89,8 +93,8 @@ def test_drop_feedback_category(model: ClassificationModel):
     assert "test_category" not in prediction.feedback
 
 
-def test_update_prediction(model: ClassificationModel):
-    prediction = model.predict("Do you love soup?")
+def test_update_prediction(classification_model: ClassificationModel):
+    prediction = classification_model.predict("Do you love soup?")
     assert prediction.expected_label is None
     assert prediction.tags == set()
     # update expected label

{orca_sdk-0.0.93.dist-info → orca_sdk-0.0.95.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: orca_sdk
-Version: 0.0.93
+Version: 0.0.95
 Summary: SDK for interacting with Orca Services
 License: Apache-2.0
 Author: Orca DB Inc.
@@ -15,14 +15,12 @@ Requires-Dist: attrs (>=22.2.0)
 Requires-Dist: datasets (>=3.1.0,<4.0.0)
 Requires-Dist: gradio (==5.13.0)
 Requires-Dist: httpx (>=0.20.0,<0.29.0)
-Requires-Dist: networkx (>=3.4.2,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyarrow (>=18.0.0,<19.0.0)
 Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.0,<2.0.0)
 Requires-Dist: scikit-learn (>=1.6.1,<2.0.0)
 Requires-Dist: torch (>=2.5.1,<3.0.0)
-Requires-Dist: transformers (>=4.51.3,<5.0.0)
 Description-Content-Type: text/markdown
 
 <!--
@@ -75,7 +73,7 @@ model = ClassificationModel("my_model", memoryset)
 prediction = model.predict("my input")
 ```
 
-For a more detailed walkthrough, check out our [Quick Start Guide](https://docs.orcadb.ai/quickstart/).
+For a more detailed walkthrough, check out our [Quick Start Guide](https://docs.orcadb.ai/quickstart-sdk/).
 
 ## Support