ai-parrot 0.8.3__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

parrot/stores/qdrant.py

@@ -0,0 +1,170 @@
+from collections.abc import Callable
+from typing import Union, Optional
+from qdrant_client import QdrantClient, models
+from langchain.docstore.document import Document
+from langchain.memory import VectorStoreRetrieverMemory
+from langchain_qdrant import Qdrant
+from .abstract import AbstractStore
+from ..conf import (
+    QDRANT_PROTOCOL,
+    QDRANT_HOST,
+    QDRANT_PORT,
+    QDRANT_USE_HTTPS,
+    QDRANT_CONN_TYPE,
+    QDRANT_URL
+)
+
+
+class QdrantStore(AbstractStore):
+    """Qdrant DB Store Class.
+
+    Using Qdrant as a Document Vector Store.
+
+    """
+
+    def __init__(
+        self,
+        embedding_model: Union[dict, str] = None,
+        embedding: Union[dict, Callable] = None,
+        **kwargs
+    ):
+        super().__init__(
+            embedding_model=embedding_model,
+            embedding=embedding,
+            **kwargs
+        )
+        self.client: Optional[QdrantClient] = None
+        self.host: str = kwargs.pop('host', QDRANT_HOST)
+        self.port: int = kwargs.pop('port', QDRANT_PORT)
+        self.use_https: bool = kwargs.pop('use_https', QDRANT_USE_HTTPS)
+        self.protocol: str = kwargs.pop('protocol', QDRANT_PROTOCOL)
+        self.conn_type: str = kwargs.pop('conn_type', QDRANT_CONN_TYPE)
+        self.url: str = kwargs.pop('url', QDRANT_URL)
+        self._host: str = f"{self.protocol}://{self.host}:{self.port}"
+
+    async def connection(self):
+        """Initialize Qdrant vector store.
+
+        Connects to a Qdrant instance, if connection fails, raise error.
+        """
+        try:
+            self._connection = QdrantClient(
+                host=self.host,
+                port=self.port,
+            )
+            collections = self._connection.get_collections().collections
+            collection_names = [collection.name for collection in collections]
+            if self.collection_name not in collection_names:
+                print(
+                    f"Collection '{self.collection_name}' not found, creating new one."
+                )
+                self._connection.create_collection(
+                    collection_name=self.collection_name,
+                    vectors_config=models.VectorParams(
+                        size=len(self._embed_.embedding.embed_query("test")), distance=models.Distance.EUCLID
+                    )
+                )
+            self.client = Qdrant(
+                client=self._connection,
+                collection_name=self.collection_name,
+                embedding_function=self._embed_.embedding
+            )
+        except Exception as e:
+            print(f"Error connecting to Qdrant: {e}")
+            raise
+        self._connected = True
+        return self._connection
+
+    async def disconnect(self) -> None:
+        """Disconnects from Qdrant instance."""
+        self.client = None # No explicit disconnect needed for QdrantClient in this context.
+        self._connection = None
+        self._connected = False
+
+    def get_vector(
+        self,
+        embedding: Optional[Callable] = None,
+    ) -> Qdrant:
+        """Returns Qdrant VectorStore instance."""
+        if embedding is not None:
+            _embed_ = embedding
+        else:
+            _embed_ = self.create_embedding(
+                embedding_model=self.embedding_model
+            )
+        if not self._connection:
+            # Re-establish client if lost, but should not happen frequently in well-managed context.
+            self._connection = QdrantClient(host=self.host, port=self.port)
+        return Qdrant(
+            client=self._connection,
+            collection_name=self.collection_name,
+            embedding_function=_embed_
+        )
+
+    async def from_documents(self, documents: list[Document], **kwargs):
+        """Save Documents as Vectors in Qdrant."""
+        vectordb = await Qdrant.afrom_documents(
+            documents=documents,
+            embedding=self._embed_.embedding,
+            client=self.client,
+            collection_name=self.collection_name,
+            **kwargs
+        )
+        return vectordb
+
+    async def add_documents(
+        self,
+        documents: list[Document],
+        embedding: Optional[Callable] = None,
+    ) -> bool:
+        """Add Documents to Qdrant."""
+        async with self:
+            vector_db = self.get_vector(embedding=embedding)
+            await vector_db.aadd_documents(documents=documents)
+        return True
+
+    async def update_documents(
+        self,
+        documents: list[Document],
+        embedding: Optional[Callable] = None,
+    ) -> bool:
+        """Update Documents in Qdrant."""
+        async with self:
+            vector_db = self.get_vector(embedding=embedding)
+            if all('id' in doc for doc in documents):
+                ids = [doc.pop('id') for doc in documents]
+                vector_db.delete(ids=ids)  # Remove old entries
+                await vector_db.aadd_documents(documents=documents)  # Add new versions
+                return True
+            return False
+
+    async def similarity_search(
+        self,
+        query: str,
+        embedding: Optional[Callable] = None,
+        limit: int = 2,
+    ) -> list:
+        """Performs similarity search in Qdrant."""
+        async with self:
+            vector_db = self.get_vector(embedding=embedding)
+            return await vector_db.asimilarity_search(query, k=limit) # Use asimilarity_search for async
+
+    def memory_retriever(
+        self,
+        documents: Optional[list] = None,
+        num_results: int = 5
+    ) -> VectorStoreRetrieverMemory:
+        """Retrieves stored memory-based documents."""
+        if not documents:
+            documents = []
+        vectordb = Qdrant.from_documents(
+            documents=documents,
+            embedding=self._embed_.embedding,
+            client=self.client,
+            collection_name=self.collection_name
+        )
+        retriever = Qdrant.as_retriever(
+            vectordb,
+            search_kwargs=dict(k=num_results)
+        )
+        return VectorStoreRetrieverMemory(retriever=retriever)

parrot/tools/__init__.py

@@ -0,0 +1,23 @@
+"""
+Tools infrastructure for building Agents.
+"""
+# Abstract Agent interface
+from .abstract import AbstractTool
+from .basic import SearchTool, MathTool
+from .duck import DuckDuckGoSearchTool, DuckDuckGoRelevantSearch
+from .gamma import GammaLink
+from .gvoice import GoogleVoiceTool
+from .docx import WordToMarkdownTool
+
+# from langchain_community.tools.yahoo_finance_news import YahooFinanceNewsTool
+# from langchain_community.tools import YouTubeSearchTool
+# from langchain_community.agent_toolkits import O365Toolkit
+# from navconfig import config
+# # from .wikipedia import WikipediaTool, WikidataTool
+# from .asknews import AskNewsTool
+
+# from .weather import OpenWeather, OpenWeatherMapTool
+# from .google import GoogleLocationFinder, GoogleSiteSearchTool, GoogleSearchTool
+# from .zipcode import ZipcodeAPIToolkit
+# from .bing import BingSearchTool
+# from .stack import StackExchangeTool

parrot/tools/abstract.py

@@ -0,0 +1,68 @@
+from typing import Optional, Dict, Any, Type
+from abc import abstractmethod
+# from langchain_core.pydantic_v1 import BaseModel
+from pydantic import BaseModel, Field
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseTool
+from navconfig.logging import logging
+
+
+logging.getLogger(name='cookie_store').setLevel(logging.INFO)
+logging.getLogger(name='httpx').setLevel(logging.INFO)
+logging.getLogger(name='httpcore').setLevel(logging.WARNING)
+logging.getLogger(name='primp').setLevel(logging.WARNING)
+
+class AbstractToolArgsSchema(BaseModel):
+    """Schema for the arguments to the AbstractTool."""
+
+    # This Field allows any number of arguments to be passed in.
+    args: list = Field(description="A list of arguments to the tool")
+
+
+class AbstractTool(BaseTool):
+    """Abstract class for tools."""
+
+    args_schema: Type[BaseModel] = AbstractToolArgsSchema
+
+    class Config:
+        """Configuration for this pydantic object."""
+        arbitrary_types_allowed = True
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = kwargs.pop('name', self.__class__.__name__)
+        self.logger = logging.getLogger(
+            f'{self.name}.Tool'
+        )
+
+
+    @abstractmethod
+    def _search(self, query: str) -> str:
+        """Run the tool."""
+
+    async def _asearch(self, *args, **kwargs):
+        """Run the tool asynchronously."""
+        return self._search(*args, **kwargs)
+
+    def _run(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> Dict[str, Any]:
+        args = [a.strip() for a in query.split(',')]
+        try:
+            return self._search(*args)
+        except Exception as e:
+            raise ValueError(f"Error running tool: {e}") from e
+
+    async def _arun(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> Dict[str, Any]:
+        """Use the tool asynchronously."""
+        args = [a.strip() for a in query.split(',')]
+        try:
+            return await self._asearch(*args)
+        except Exception as e:
+            raise ValueError(f"Error running tool: {e}") from e

parrot/tools/asknews.py

@@ -0,0 +1,33 @@
+from typing import Any
+import os
+from navconfig import config
+from langchain_community.tools.asknews import AskNewsSearch
+from langchain.tools import BaseTool
+
+class AskNewsTool(BaseTool):
+    """Tool that searches the AskNews API."""
+    name: str = "asknews_search"
+    description: str = (
+        "Search for up-to-date news and historical news on AskNews site. "
+        "This tool allows you to perform a search on up-to-date news and historical news. "
+        "If you needs news from more than 48 hours ago, you can estimate the "
+        "number of hours back to search."
+    )
+    search: Any = None
+
+    def __init__(self, max_results: int = 5, **kwargs):
+        super().__init__(**kwargs)
+        os.environ["ASKNEWS_CLIENT_ID"] = config.get('ASKNEWS_CLIENT_ID')
+        os.environ["ASKNEWS_CLIENT_SECRET"] = config.get('ASKNEWS_CLIENT_SECRET')
+        self.search = AskNewsSearch(max_results=5)
+
+    def _run(
+        self,
+        query: str
+    ) -> str:
+        """Use the Wikipedia tool."""
+        return self.search.invoke(
+            {
+                "query": query,
+            }
+        )

parrot/tools/basic.py

@@ -0,0 +1,51 @@
+from langchain.tools import Tool
+# Tools:
+from langchain.chains.llm_math.base import LLMMathChain
+from langchain_community.utilities import SerpAPIWrapper
+from langchain_groq import ChatGroq
+from ..conf import (
+    SERPAPI_API_KEY,
+    GROQ_API_KEY
+)
+
+class SearchTool:
+    """Search Tool."""
+    name: str = "web_search"
+    def __new__(cls, *args, **kwargs):
+        search = SerpAPIWrapper(
+            serpapi_api_key=kwargs.get('serpapi_api_key', SERPAPI_API_KEY)
+        )
+        tool = Tool(
+            name="Web Search",
+            func=search.run,
+            description="""
+            useful for when you need to answer questions about current events or general knowledge. Input should be a search query.
+            """,
+            coroutine=search.arun
+        )
+        tool.name = "Web Search"
+        return tool
+
+
+class MathTool:
+    """Math Tool."""
+    def __new__(cls, *args, **kwargs):
+        groq = ChatGroq(
+            model="llama-3.1-8b-instant",
+            temperature=0.1,
+            api_key=kwargs.get('GROQ_API_KEY', GROQ_API_KEY)
+        )
+        llm = kwargs.get('llm', groq)
+        math_chain = LLMMathChain.from_llm(
+            llm=llm,
+            verbose=True
+        )
+        tool = Tool(
+            name="math_calculator",
+            func=math_chain.run,
+            description="""
+            useful for when you need to solve math problems or perform mathematical calculations. Input should be a math equation or a mathematical expression.
+            """,
+            coroutine=math_chain.arun
+        )
+        return tool