feat: remove max marginal relevance search

custom_pgvector.py

@@ -24,7 +24,6 @@ from langchain.schema.embeddings import Embeddings
 from langchain.utils import get_from_dict_or_env
 from langchain.vectorstores.base import VectorStore
 from langchain.vectorstores.pgvector import BaseModel
-from langchain.vectorstores.utils import maximal_marginal_relevance
 from pgvector.sqlalchemy import Vector
 from sqlalchemy import delete
 from sqlalchemy.orm import Session, declarative_base, relationship
@@ -110,7 +109,6 @@ class CustomPGVector(VectorStore):
         distance_strategy: DistanceStrategy = DEFAULT_DISTANCE_STRATEGY,
         pre_delete_collection: bool = False,
         logger: Optional[logging.Logger] = None,
-        relevance_score_fn: Optional[Callable[[float], float]] = None,
     ) -> None:
         self.connection_string = connection_string
         self.embedding_function = embedding_function
@@ -120,7 +118,6 @@ class CustomPGVector(VectorStore):
         self._distance_strategy = distance_strategy
         self.pre_delete_collection = pre_delete_collection
         self.logger = logger or logging.getLogger(__name__)
-        self.override_relevance_score_fn = relevance_score_fn
         self.__post_init__()
 
     def __post_init__(
@@ -592,217 +589,3 @@ class CustomPGVector(VectorStore):
     ) -> str:
         """Return connection string from database parameters."""
         return f"postgresql+{driver}://{user}:{password}@{host}:{port}/{database}"
-
-    def _select_relevance_score_fn(self) -> Callable[[float], float]:
-        """
-        The 'correct' relevance function
-        may differ depending on a few things, including:
-        - the distance / similarity metric used by the VectorStore
-        - the scale of your embeddings (OpenAI's are unit normed. Many others are not!)
-        - embedding dimensionality
-        - etc.
-        """
-        if self.override_relevance_score_fn is not None:
-            return self.override_relevance_score_fn
-
-        # Default strategy is to rely on distance strategy provided
-        # in vectorstore constructor
-        if self._distance_strategy == DistanceStrategy.COSINE:
-            return self._cosine_relevance_score_fn
-        elif self._distance_strategy == DistanceStrategy.EUCLIDEAN:
-            return self._euclidean_relevance_score_fn
-        elif self._distance_strategy == DistanceStrategy.MAX_INNER_PRODUCT:
-            return self._max_inner_product_relevance_score_fn
-        else:
-            raise ValueError(
-                "No supported normalization function"
-                f" for distance_strategy of {self._distance_strategy}."
-                "Consider providing relevance_score_fn to PGVector constructor."
-            )
-
-    def max_marginal_relevance_search_with_score_by_vector(
-        self,
-        embedding: List[float],
-        k: int = 4,
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        filter: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> List[Tuple[Document, float]]:
-        """Return docs selected using the maximal marginal relevance with score
-            to embedding vector.
-
-        Maximal marginal relevance optimizes for similarity to query AND diversity
-            among selected documents.
-
-        Args:
-            embedding: Embedding to look up documents similar to.
-            k (int): Number of Documents to return. Defaults to 4.
-            fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
-                Defaults to 20.
-            lambda_mult (float): Number between 0 and 1 that determines the degree
-                of diversity among the results with 0 corresponding
-                to maximum diversity and 1 to minimum diversity.
-                Defaults to 0.5.
-            filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
-
-        Returns:
-            List[Tuple[Document, float]]: List of Documents selected by maximal marginal
-                relevance to the query and score for each.
-        """
-        results = self.__query_collection(embedding=embedding, k=fetch_k, filter=filter)
-
-        embedding_list = [result.EmbeddingStore.embedding for result in results]
-
-        mmr_selected = maximal_marginal_relevance(
-            np.array(embedding, dtype=np.float32),
-            embedding_list,
-            k=k,
-            lambda_mult=lambda_mult,
-        )
-
-        candidates = self._results_to_docs_and_scores(results)
-
-        return [r for i, r in enumerate(candidates) if i in mmr_selected]
-
-    def max_marginal_relevance_search(
-        self,
-        query: str,
-        k: int = 4,
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        filter: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> List[Document]:
-        """Return docs selected using the maximal marginal relevance.
-
-        Maximal marginal relevance optimizes for similarity to query AND diversity
-            among selected documents.
-
-        Args:
-            query (str): Text to look up documents similar to.
-            k (int): Number of Documents to return. Defaults to 4.
-            fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
-                Defaults to 20.
-            lambda_mult (float): Number between 0 and 1 that determines the degree
-                of diversity among the results with 0 corresponding
-                to maximum diversity and 1 to minimum diversity.
-                Defaults to 0.5.
-            filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
-
-        Returns:
-            List[Document]: List of Documents selected by maximal marginal relevance.
-        """
-        embedding = self.embedding_function.embed_query(query)
-        return self.max_marginal_relevance_search_by_vector(
-            embedding,
-            k=k,
-            fetch_k=fetch_k,
-            lambda_mult=lambda_mult,
-            **kwargs,
-        )
-
-    def max_marginal_relevance_search_with_score(
-        self,
-        query: str,
-        k: int = 4,
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        filter: Optional[dict] = None,
-        **kwargs: Any,
-    ) -> List[Tuple[Document, float]]:
-        """Return docs selected using the maximal marginal relevance with score.
-
-        Maximal marginal relevance optimizes for similarity to query AND diversity
-            among selected documents.
-
-        Args:
-            query (str): Text to look up documents similar to.
-            k (int): Number of Documents to return. Defaults to 4.
-            fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
-                Defaults to 20.
-            lambda_mult (float): Number between 0 and 1 that determines the degree
-                of diversity among the results with 0 corresponding
-                to maximum diversity and 1 to minimum diversity.
-                Defaults to 0.5.
-            filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
-
-        Returns:
-            List[Tuple[Document, float]]: List of Documents selected by maximal marginal
-                relevance to the query and score for each.
-        """
-        embedding = self.embedding_function.embed_query(query)
-        docs = self.max_marginal_relevance_search_with_score_by_vector(
-            embedding=embedding,
-            k=k,
-            fetch_k=fetch_k,
-            lambda_mult=lambda_mult,
-            filter=filter,
-            **kwargs,
-        )
-        return docs
-
-    def max_marginal_relevance_search_by_vector(
-        self,
-        embedding: List[float],
-        k: int = 4,
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        filter: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> List[Document]:
-        """Return docs selected using the maximal marginal relevance
-            to embedding vector.
-
-        Maximal marginal relevance optimizes for similarity to query AND diversity
-            among selected documents.
-
-        Args:
-            embedding (str): Text to look up documents similar to.
-            k (int): Number of Documents to return. Defaults to 4.
-            fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
-                Defaults to 20.
-            lambda_mult (float): Number between 0 and 1 that determines the degree
-                of diversity among the results with 0 corresponding
-                to maximum diversity and 1 to minimum diversity.
-                Defaults to 0.5.
-            filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
-
-        Returns:
-            List[Document]: List of Documents selected by maximal marginal relevance.
-        """
-        docs_and_scores = self.max_marginal_relevance_search_with_score_by_vector(
-            embedding,
-            k=k,
-            fetch_k=fetch_k,
-            lambda_mult=lambda_mult,
-            filter=filter,
-            **kwargs,
-        )
-
-        return _results_to_docs(docs_and_scores)
-
-    async def amax_marginal_relevance_search_by_vector(
-        self,
-        embedding: List[float],
-        k: int = 4,
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        filter: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> List[Document]:
-        """Return docs selected using the maximal marginal relevance."""
-
-        # This is a temporary workaround to make the similarity search
-        # asynchronous. The proper solution is to make the similarity search
-        # asynchronous in the vector store implementations.
-        func = partial(
-            self.max_marginal_relevance_search_by_vector,
-            embedding,
-            k=k,
-            fetch_k=fetch_k,
-            lambda_mult=lambda_mult,
-            filter=filter,
-            **kwargs,
-        )
-        return await asyncio.get_event_loop().run_in_executor(None, func)