ai-parrot 0.5.10__tar.gz → 0.5.12__tar.gz

{ai_parrot-0.5.10 → ai_parrot-0.5.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ai-parrot
-Version: 0.5.10
+Version: 0.5.12
 Summary: Live Chatbots based on Langchain chatbots and Agents     Integrated into Navigator Framework or used into any aiohttp applications.
 Home-page: https://github.com/phenobarbital/ai-parrot
 Author: Jesus Lara

{ai_parrot-0.5.10 → ai_parrot-0.5.12}/parrot/bots/abstract.py

@@ -466,6 +466,7 @@ class AbstractBot(DBInterface, ABC):
 
     def configure_store(self, **kwargs):
         # TODO: Implement VectorStore Configuration
+        print('SELF > ', self._vector_store)
         if isinstance(self._vector_store, list):
             # Is a list of vector stores instances:
             for st in self._vector_store:
@@ -476,6 +477,7 @@ class AbstractBot(DBInterface, ABC):
                 except ImportError:
                     continue
         elif isinstance(self._vector_store, dict):
+            print('< ENTERING HERE > ', )
             # Is a single vector store instance:
             store_cls = self._get_database_store(self._vector_store)
             store_cls.use_database = self._use_vector
@@ -487,6 +489,10 @@ class AbstractBot(DBInterface, ABC):
         self.logger.info(f"Configured Vector Stores: {self.stores}")
         if self.stores:
             self.store = self.stores[0]
+        print('=================================')
+        print('END STORES >> ', self.stores, self.store)
+        print('=================================')
+
 
     def get_memory(
         self,

{ai_parrot-0.5.10 → ai_parrot-0.5.12}/parrot/bots/chatbot.py

@@ -244,6 +244,9 @@ class Chatbot(AbstractBot):
         vector_db = database.pop('vector_database', None)
         # configure vector database:
         if vector_db:
+            # Initialize the store:
+            self.stores = []
+            self.store = None
             self._use_vector = vector_store
             self._vector_store = database
             self.configure_store()

ai_parrot-0.5.12/parrot/bots/retrievals/multi.py

@@ -0,0 +1,123 @@
+from typing import List, Dict, Any, Optional
+from collections.abc import Callable
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from pydantic import Field
+
+class MultiVectorStoreRetriever(BaseRetriever):
+    """
+    This aggregator retriever queries multiple vector stores
+    and merges the results into a single list.
+    """
+
+    # Define class attributes with default values
+    stores: List[Any] = Field(description="List of vector stores that provide an as_retriever() method")
+    search_kwargs: Dict[str, Any] = Field(default_factory=dict, description="Dict to pass to each store's retrieve method (like 'k' for top_k)")
+    chain_type: str = Field(default="stuff", description="Chain type for the retriever")
+    search_type: str = Field(default="similarity", description="Search type (similarity, mmr)")
+    metric_type: str = Field(default="COSINE", description="Similarity metric (COSINE, EUCLIDEAN, DOT_PRODUCT)")
+
+    class Config:
+        """Configuration for this pydantic object."""
+        arbitrary_types_allowed = True
+
+    def __init__(
+        self,
+        stores: List[Any],
+        metric_type: str = 'COSINE',
+        chain_type: str = 'stuff',
+        search_type: str = 'similarity',
+        search_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ):
+        """
+        Initialize the MultiVectorStoreRetriever.
+
+        Args:
+            stores: List of vector stores that provide an as_retriever() method
+            metric_type: Similarity metric (COSINE, EUCLIDEAN, DOT_PRODUCT)
+            chain_type: Chain type for the retriever
+            search_type: Search type (similarity, mmr)
+            search_kwargs: Dict to pass to each store's retrieve method (like 'k' for top_k)
+        """
+        # Initialize with default values
+        search_kwargs = search_kwargs or {}
+
+        # Call super().__init__ with all properties
+        super().__init__(
+            stores=stores,
+            search_kwargs=search_kwargs,
+            chain_type=chain_type,
+            search_type=search_type,
+            metric_type=metric_type,
+            **kwargs
+        )
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """
+        Get documents relevant to the query.
+        Implements the required method from BaseRetriever.
+
+        Args:
+            query: Query string
+            run_manager: CallbackManager for the run
+
+        Returns:
+            List of relevant documents
+        """
+        all_results = []
+        for store in self.stores:
+            try:
+                retriever = store.as_retriever(
+                    search_type=self.search_type,
+                    search_kwargs=self.search_kwargs,
+                )
+                # Pass the run_manager to the sub-retrievers if they support it
+                if hasattr(retriever, "_get_relevant_documents"):
+                    callback_manager = run_manager.get_child()
+                    docs = retriever._get_relevant_documents(query, run_manager=callback_manager)
+                else:
+                    docs = retriever.get_relevant_documents(query)
+                all_results.extend(docs)
+            except Exception as e:
+                # Log the error but continue with other stores
+                run_manager.on_retriever_error(f"Error retrieving from store: {str(e)}")
+                continue
+        return all_results
+
+    async def _aget_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """
+        Asynchronously get documents relevant to the query.
+        Implements the required async method from BaseRetriever.
+
+        Args:
+            query: Query string
+            run_manager: CallbackManager for the run
+
+        Returns:
+            List of relevant documents
+        """
+        all_results = []
+        for store in self.stores:
+            try:
+                retriever = store.as_retriever(
+                    search_type=self.search_type,
+                    search_kwargs=self.search_kwargs,
+                )
+                # Pass the run_manager to the sub-retrievers if they support it
+                if hasattr(retriever, "_aget_relevant_documents"):
+                    callback_manager = run_manager.get_child()
+                    docs = await retriever._aget_relevant_documents(query, run_manager=callback_manager)
+                else:
+                    docs = await retriever.aget_relevant_documents(query)
+                all_results.extend(docs)
+            except Exception as e:
+                # Log the error but continue with other stores
+                run_manager.on_retriever_error(f"Error retrieving from store: {str(e)}")
+                continue
+        return all_results

{ai_parrot-0.5.10 → ai_parrot-0.5.12}/parrot/version.py

@@ -3,7 +3,7 @@
 __title__ = "ai-parrot"
 __description__ = "Live Chatbots based on Langchain chatbots and Agents \
     Integrated into Navigator Framework or used into any aiohttp applications."
-__version__ = "0.5.10"
+__version__ = "0.5.12"
 __author__ = "Jesus Lara"
 __author_email__ = "jesuslarag@gmail.com"
 __license__ = "MIT"

ai_parrot-0.5.10/parrot/bots/retrievals/multi.py

@@ -1,102 +0,0 @@
-from typing import List, Dict, Any, Optional
-from langchain_core.retrievers import BaseRetriever
-from langchain_core.callbacks import CallbackManagerForRetrieverRun
-from langchain_core.documents import Document
-
-
-class MultiVectorStoreRetriever(BaseRetriever):
-    """
-    This aggregator retriever queries multiple vector stores
-    and merges the results into a single list.
-    """
-
-    stores: List[Any]
-    search_kwargs: Dict[str, Any]
-    chain_type: str
-    search_type: str
-    metric_type: str
-
-    def __init__(
-        self,
-        stores: List[Any],
-        metric_type: str = 'COSINE',
-        chain_type: str = 'stuff',
-        search_type: str = 'similarity',
-        search_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Initialize the MultiVectorStoreRetriever.
-
-        Args:
-            stores: List of vector stores that provide an as_retriever() method
-            metric_type: Similarity metric (COSINE, EUCLIDEAN, DOT_PRODUCT)
-            chain_type: Chain type for the retriever
-            search_type: Search type (similarity, mmr)
-            search_kwargs: Dict to pass to each store's retrieve method (like 'k' for top_k)
-        """
-        super().__init__()
-        self.stores = stores
-        self.search_kwargs = search_kwargs or {}
-        self.chain_type = chain_type
-        self.search_type = search_type
-        self.metric_type = metric_type
-
-    def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> List[Document]:
-        """
-        Get documents relevant to the query.
-        Implements the required method from BaseRetriever.
-
-        Args:
-            query: Query string
-            run_manager: CallbackManager for the run
-
-        Returns:
-            List of relevant documents
-        """
-        all_results = []
-        for store in self.stores:
-            retriever = store.as_retriever(
-                search_type=self.search_type,
-                search_kwargs=self.search_kwargs,
-                chain_type=self.chain_type
-            )
-            # Pass the run_manager to the sub-retrievers if they support it
-            if hasattr(retriever, "_get_relevant_documents"):
-                callback_manager = run_manager.get_child()
-                docs = retriever._get_relevant_documents(query, run_manager=callback_manager)
-            else:
-                docs = retriever.get_relevant_documents(query)
-            all_results.extend(docs)
-        return all_results
-
-    async def _aget_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> List[Document]:
-        """
-        Asynchronously get documents relevant to the query.
-        Implements the required async method from BaseRetriever.
-
-        Args:
-            query: Query string
-            run_manager: CallbackManager for the run
-
-        Returns:
-            List of relevant documents
-        """
-        all_results = []
-        for store in self.stores:
-            retriever = store.as_retriever(
-                search_type=self.search_type,
-                search_kwargs=self.search_kwargs,
-                chain_type=self.chain_type
-            )
-            # Pass the run_manager to the sub-retrievers if they support it
-            if hasattr(retriever, "_aget_relevant_documents"):
-                callback_manager = run_manager.get_child()
-                docs = await retriever._aget_relevant_documents(query, run_manager=callback_manager)
-            else:
-                docs = await retriever.aget_relevant_documents(query)
-            all_results.extend(docs)
-        return all_results