ai-parrot 0.1.0__cp311-cp311-manylinux_2_28_x86_64.whl

parrot/handlers/chat.py

@@ -0,0 +1,169 @@
+from navigator_auth.decorators import (
+    is_authenticated,
+    user_session
+)
+from navigator.views import BaseView
+
+
+@is_authenticated()
+@user_session()
+class ChatHandler(BaseView):
+    """
+    ChatHandler.
+    description: ChatHandler for Parrot Application.
+    """
+
+    async def get(self, **kwargs):
+        """
+        get.
+        description: Get method for ChatHandler.
+        """
+        name = self.request.match_info.get('chatbot_name', None)
+        if not name:
+            return self.json_response({
+                "message": "Welcome to Parrot Chatbot Service."
+            })
+        else:
+            # retrieve chatbof information:
+            manager = self.request.app['chatbot_manager']
+            chatbot = manager.get_chatbot(name)
+            if not chatbot:
+                return self.error(
+                    f"Chatbot {name} not found.",
+                    status=404
+                )
+            return self.json_response({
+                "chatbot": chatbot.name,
+                "description": chatbot.description,
+                "role": chatbot.role,
+                "embedding_model_name": chatbot.embedding_model_name,
+                "llm": f"{chatbot.get_llm()!r}",
+                "temperature": chatbot.get_llm().temperature,
+                "args": chatbot.get_llm().args,
+                "config_file": chatbot.config_file
+            })
+
+    async def post(self, *args, **kwargs):
+        """
+        post.
+        description: Post method for ChatHandler.
+        """
+        print('ARGS > ', args, kwargs)
+        app = self.request.app
+        name = self.request.match_info.get('chatbot_name', None)
+        qs = self.query_parameters(self.request)
+        data = await self.request.json()
+        if not 'query' in data:
+            return self.json_response(
+                {
+                "message": "No query was found."
+                },
+                status=400
+            )
+        if 'use_llm' in qs:
+            # passing another LLM to the Chatbot:
+            llm = qs.get('use_llm')
+        else:
+            llm = None
+        try:
+            manager = app['chatbot_manager']
+        except KeyError:
+            return self.json_response(
+                {
+                "message": "Chatbot Manager is not installed."
+                },
+                status=404
+            )
+        try:
+            chatbot = manager.get_chatbot(name)
+            if not chatbot:
+                raise KeyError(
+                    f"Chatbot {name} not found."
+                )
+        except (TypeError, KeyError):
+            return self.json_response(
+                {
+                "message": f"Chatbot {name} not found."
+                },
+                status=404
+            )
+        # getting the question:
+        question = data.get('query')
+        session = self.request.session
+        try:
+            session_id = session.get('session_id', None)
+            # print('SESSION ID > ', session_id)
+            memory_key = f'{session.session_id}_{name}_message_store'
+            # print('MEM STORAGE > ', memory_key)
+            memory = chatbot.get_memory(session_id=memory_key)
+            # print('MEMORY >> ', memory)
+            async with chatbot.get_retrieval(request=self.request) as retrieval:
+                qa = retrieval.conversation(
+                    question=question,
+                    search_kwargs={"k": 10},
+                    use_llm=llm,
+                    memory=memory
+                )
+                result = await qa.invoke(question)
+                # Drop "memory" information:
+                result.chat_history = None
+                result.source_documents = None
+            return self.json_response(response=result)
+        except ValueError as exc:
+            return self.error(
+                f"{exc}",
+                exception=exc,
+                status=400
+            )
+        except Exception as exc:
+            return self.error(
+                f"Error invoking chatbot {name}: {exc}",
+                exception=exc,
+                status=400
+            )
+
+
+@is_authenticated()
+@user_session()
+class BotHandler(BaseView):
+    """BotHandler.
+
+
+    Use this handler to interact with a brand new chatbot, consuming a configuration.
+    """
+    async def put(self):
+        """Create a New Bot (passing a configuration).
+        """
+        try:
+            manager = self.request.app['chatbot_manager']
+        except KeyError:
+            return self.json_response(
+                {
+                "message": "Chatbot Manager is not installed."
+                },
+                status=404
+            )
+        # TODO: Making a Validation of data
+        data = await self.request.json()
+        name = data.pop('name', None)
+        if not name:
+            return self.json_response(
+                {
+                "message": "Name for Bot Creation is required."
+                },
+                status=400
+            )
+        try:
+            chatbot = manager.create_chatbot(name=name, **data)
+            await chatbot.configure(name=name, app=self.request.app)
+            return self.json_response(
+                {
+                    "message": f"Chatbot {name} created successfully."
+                }
+            )
+        except Exception as exc:
+            return self.error(
+                f"Error creating chatbot {name}: {exc}",
+                exception=exc,
+                status=400
+            )

parrot/interfaces/__init__.py

@@ -0,0 +1,6 @@
+from .database import DBInterface
+
+
+__all__ = (
+    'DBInterface',
+)

parrot/interfaces/database.py

@@ -0,0 +1,29 @@
+"""DB (asyncdb) Extension.
+DB connection for any Application.
+"""
+from abc import ABCMeta
+from asyncdb import AsyncDB
+
+
+
+class DBInterface(metaclass=ABCMeta):
+    """
+    Interface for using database connections in an Application using AsyncDB.
+    """
+
+    def get_database(
+        self,
+        driver: str,
+        dsn: str = None,
+        params: dict = None,
+        timeout: int = 60,
+        **kwargs
+    ) -> AsyncDB:
+        """Get the driver."""
+        return AsyncDB(
+            driver,
+            dsn=dsn,
+            params=params,
+            timeout=timeout,
+            **kwargs
+        )

parrot/llms/abstract.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from langchain_core.prompts import ChatPromptTemplate
+
+
+class AbstractLLM(ABC):
+    """Abstract Language Model class.
+    """
+
+    model: str = "databricks/dolly-v2-3b"
+    embed_model: str = None
+    max_tokens: int = 1024
+    max_retries: int = 3
+
+    def __init__(self, *args, **kwargs):
+        self.model = kwargs.get("model", "databricks/dolly-v2-3b")
+        self.task = kwargs.get("task", "text-generation")
+        self.temperature: float = kwargs.get('temperature', 0.6)
+        self.max_tokens: int = kwargs.get('max_tokens', 1024)
+        self.top_k: float = kwargs.get('top_k', 10)
+        self.top_p: float = kwargs.get('top_p', 0.90)
+        self.args = {
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+        }
+        self._llm = None
+        self._embed = None
+
+    def get_llm(self):
+        return self._llm
+
+    def get_embedding(self):
+        return self._embed
+
+    def __call__(self, text: str, **kwargs):
+        return self._llm.invoke(text, **kwargs)
+
+    def get_prompt(self, system: tuple, human: str) -> ChatPromptTemplate:
+        """Get a prompt for the LLM."""
+        return ChatPromptTemplate.from_messages(
+            [("system", system), ("human", human)]
+        )

parrot/llms/anthropic.py

@@ -0,0 +1,36 @@
+from navconfig import config
+from navconfig.logging import logging
+from langchain_anthropic import ChatAnthropic
+from langchain_core.prompts import ChatPromptTemplate
+from .abstract import AbstractLLM
+
+logging.getLogger(name='anthropic').setLevel(logging.WARNING)
+
+class Anthropic(AbstractLLM):
+    """Anthropic.
+
+    Interact with Anthropic Language Model.
+
+    Returns:
+        _type_: an instance of Anthropic (Claude) LLM Model.
+    """
+    model: str = 'claude-3-opus-20240229'
+    embed_model: str = None
+    max_tokens: int = 1024
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.model = kwargs.get("model", 'claude-3-opus-20240229')
+        self._api_key = kwargs.pop('api_key', config.get('ANTHROPIC_API_KEY'))
+        args = {
+            "temperature": self.temperature,
+            "max_retries": 4,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "verbose": True,
+        }
+        self._llm = ChatAnthropic(
+            model_name=self.model,
+            api_key=self._api_key,
+            **args
+        )

parrot/llms/google.py

@@ -0,0 +1,37 @@
+from langchain_google_genai import (
+    GoogleGenerativeAI,
+    ChatGoogleGenerativeAI,
+    GoogleGenerativeAIEmbeddings
+)
+from navconfig import config
+from .abstract import AbstractLLM
+
+
+class GoogleGenAI(AbstractLLM):
+    """GoogleGenAI.
+        Using Google Generative AI models with Google Cloud AI Platform.
+    """
+    model: str = "gemini-pro"
+
+    def __init__(self, *args, **kwargs):
+        self.model_type = kwargs.get("model_type", "chat")
+        super().__init__(*args, **kwargs)
+        self._api_key = kwargs.pop('api_key', config.get('GOOGLE_API_KEY'))
+        if self.model_type == 'chat':
+            base_llm = ChatGoogleGenerativeAI
+        else:
+            base_llm = GoogleGenerativeAI
+        self._llm = base_llm(
+            model=self.model,
+            api_key=self._api_key,
+            temperature=self.temperature,
+            **self.args
+        )
+        embed_model = kwargs.get("embed_model", "models/embedding-001")
+        self._embed = GoogleGenerativeAIEmbeddings(
+            model=embed_model,
+            google_api_key=self._api_key,
+            temperature=self.temperature,
+            top_p=self.top_p,
+            top_k=self.top_k,
+        )

parrot/llms/groq.py

@@ -0,0 +1,33 @@
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_groq import ChatGroq
+from navconfig import config
+from .abstract import AbstractLLM
+
+
+class GroqLLM(AbstractLLM):
+    """GroqLLM.
+        Using Groq Open-source models.
+    """
+    model: str = "mixtral-8x7b-32768"
+
+    def __init__(self, *args, **kwargs):
+        self.model_type = kwargs.get("model_type", "text")
+        system = kwargs.pop('system_prompt', "You are a helpful assistant.")
+        human = kwargs.pop('human_prompt', "{question}")
+        super().__init__(*args, **kwargs)
+        self._api_key = kwargs.pop('api_key', config.get('GROQ_API_KEY'))
+        self._llm = ChatGroq(
+            model_name=self.model,
+            groq_api_key=self._api_key,
+            temperature=self.temperature,
+            max_retries=self.max_retries,
+            max_tokens=self.max_tokens,
+            model_kwargs={
+                "top_p": self.top_p,
+                # "top_k": self.top_k,
+            },
+        )
+        self._embed = None # Not supported
+        self.prompt = ChatPromptTemplate.from_messages(
+            [("system", system), ("human", human)]
+        )

parrot/llms/hf.py

@@ -0,0 +1,39 @@
+from langchain_community.llms import HuggingFacePipeline  # pylint: disable=import-error, E0611
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from .abstract import AbstractLLM
+
+class HuggingFace(AbstractLLM):
+    """HuggingFace.
+
+    Load a LLM (Language Model) from HuggingFace Hub.
+
+    Only supports text-generation, text2text-generation, summarization and translation for now.
+
+    Returns:
+        _type_: an instance of HuggingFace LLM Model.
+    """
+    model: str = "databricks/dolly-v2-3b"
+    embed_model: str = None
+    max_tokens: int = 1024
+
+    def __init__(self, *args, **kwargs):
+        self.batch_size = kwargs.get('batch_size', 4)
+        super().__init__(*args, **kwargs)
+        self._tokenizer = AutoTokenizer.from_pretrained(self.model, chunk_size=self.max_tokens)
+        self._model = AutoModelForCausalLM.from_pretrained(self.model, trust_remote_code=True)
+        self._llm = HuggingFacePipeline.from_model_id(
+            model_id=self.model,
+            task=self.task,
+            device_map='auto',
+            batch_size=self.batch_size,
+            model_kwargs={
+                "max_length": self.max_tokens,
+                "trust_remote_code": True
+            },
+            pipeline_kwargs={
+                "temperature": self.temperature,
+                "repetition_penalty":1.1,
+                "max_new_tokens": self.max_tokens,
+                **self.args
+            }
+        )

parrot/llms/openai.py

@@ -0,0 +1,49 @@
+from langchain_openai import (
+    OpenAI,
+    ChatOpenAI,
+    OpenAIEmbeddings
+)
+from navconfig import config
+from .abstract import AbstractLLM
+
+
+class OpenAILLM(AbstractLLM):
+    """OpenAI.
+    Interact with OpenAI Language Model.
+
+    Returns:
+        _type_: an instance of OpenAI LLM Model.
+    """
+    model: str = "gpt-4-turbo"
+    embed_model: str = "text-embedding-3-large"
+    max_tokens: int = 1024
+
+    def __init__(self, *args, **kwargs):
+        self.model_type = kwargs.get("model_type", "text")
+        super().__init__(*args, **kwargs)
+        self.model = kwargs.get("model", "davinci")
+        self._api_key = kwargs.pop('api_key', config.get('OPENAI_API_KEY'))
+        organization = config.get("OPENAI_ORGANIZATION")
+        if self.model_type == 'chat':
+            base_llm = ChatOpenAI
+        else:
+            base_llm = OpenAI
+        self._llm = base_llm(
+            model_name=self.model,
+            api_key=self._api_key,
+            organization=organization,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            **self.args
+        )
+        # Embedding
+        embed_model = kwargs.get("embed_model", "text-embedding-3-large")
+        self._embed = OpenAIEmbeddings(
+            model=embed_model,
+            dimensions=self.max_tokens,
+            api_key=self._api_key,
+            organization=organization,
+            temperature=self.temperature,
+            top_p=self.top_p,
+            top_k=self.top_k,
+        )

parrot/llms/pipes.py

@@ -0,0 +1,103 @@
+import torch
+from langchain_community.llms import HuggingFacePipeline  # pylint: disable=import-error, E0611
+from transformers import (
+    AutoModelForCausalLM,
+    AutoProcessor,
+    LlavaForConditionalGeneration,
+    AutoTokenizer,
+    GenerationConfig,
+    pipeline
+)
+from .abstract import AbstractLLM
+
+
+class PipelineLLM(AbstractLLM):
+    """PipelineLLM.
+
+    Load a LLM (Language Model) from HuggingFace Hub.
+
+    Returns:
+        _type_: an instance of HuggingFace LLM Model.
+    """
+    model: str = "databricks/dolly-v2-3b"
+    embed_model: str = None
+    max_tokens: int = 1024
+
+    def __init__(self, *args, **kwargs):
+        self.batch_size = kwargs.get('batch_size', 4)
+        self.use_llava: bool = kwargs.get('use_llava', False)
+        self.model_args = kwargs.get('model_args', {})
+        super().__init__(*args, **kwargs)
+        dtype = kwargs.get('dtype', 'float16')
+        if dtype == 'bfloat16':
+            torch_dtype = torch.bfloat16
+        if dtype == 'float16':
+            torch_dtype = torch.float16
+        elif dtype == 'float32':
+            torch_dtype = torch.float32
+        elif dtype == 'float8':
+            torch_dtype = torch.float8
+        else:
+            torch_dtype = "auto"
+        use_fast = kwargs.get('use_fast', True)
+        if self.use_llava is False:
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model,
+                chunk_size=self.max_tokens
+            )
+            self._model = AutoModelForCausalLM.from_pretrained(
+                self.model,
+                device_map="auto",
+                torch_dtype=torch_dtype,
+                trust_remote_code=True,
+            )
+            config = GenerationConfig(
+                do_sample=True,
+                temperature=self.temperature,
+                max_new_tokens=self.max_tokens,
+                top_p=self.top_p,
+                top_k=self.top_k,
+                repetition_penalty=1.15,
+            )
+            self._pipe = pipeline(
+                task=self.task,
+                model=self._model,
+                tokenizer=self.tokenizer,
+                return_full_text=True,
+                use_fast=use_fast,
+                device_map='auto',
+                batch_size=self.batch_size,
+                generation_config=config,
+                pad_token_id = 50256,
+                framework="pt"
+            )
+        else:
+            self._model = LlavaForConditionalGeneration.from_pretrained(
+                self.model,
+                device_map="auto",
+                torch_dtype=torch_dtype,
+                trust_remote_code=True,
+                low_cpu_mem_usage=True,
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model)
+            processor = AutoProcessor.from_pretrained(self.model)
+            self._pipe = pipeline(
+                task=self.task,
+                model=self._model,
+                tokenizer=self.tokenizer,
+                use_fast=use_fast,
+                device_map='auto',
+                batch_size=self.batch_size,
+                image_processor=processor.image_processor,
+                framework="pt",
+                **self.model_args
+            )
+        self._pipe.tokenizer.pad_token_id = self._pipe.model.config.eos_token_id
+        self._llm = HuggingFacePipeline(
+            model_id=self.model,
+            pipeline=self._pipe,
+            verbose=True
+        )
+
+    def pipe(self, *args, **kwargs):
+        return self._pipe(*args, **kwargs, generate_kwargs={"max_new_tokens": self.max_tokens})

parrot/llms/vertex.py

@@ -0,0 +1,68 @@
+import os
+from navconfig import config, BASE_DIR
+from google.cloud import aiplatform
+from langchain_google_vertexai import (
+    ChatVertexAI,
+    VertexAI,
+    VertexAIModelGarden,
+    VertexAIEmbeddings
+)
+from .abstract import AbstractLLM
+
+class VertexLLM(AbstractLLM):
+    """VertexLLM.
+
+    Interact with VertexAI Language Model.
+
+    Returns:
+        _type_: VertexAI LLM.
+    """
+    model: str = "gemini-1.0-pro"
+    embed_model: str = "textembedding-gecko@003"
+    max_tokens: int = 1024
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        use_garden: bool = kwargs.get("use_garden", False)
+        project_id = config.get("VERTEX_PROJECT_ID")
+        region = config.get("VERTEX_REGION")
+        config_file = config.get('GOOGLE_CREDENTIALS_FILE', 'env/google/vertexai.json')
+        config_dir = BASE_DIR.joinpath(config_file)
+        os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = str(config_dir)
+        self.args = {
+            "project": project_id,
+            "location": region,
+            "max_output_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "max_retries": 4,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "verbose": True,
+        }
+        if use_garden is True:
+            base_llm = VertexAIModelGarden
+            self.args['endpoint_id'] = self.model
+        elif self.model == "chat":
+            self.args['model_name'] = "chat-bison@001"
+            base_llm = ChatVertexAI
+        else:
+            self.args['model_name'] = self.model
+            base_llm = VertexAI
+        # LLM
+        self._llm = base_llm(
+            system_prompt="Always respond in the same language as the user's question. If the user's language is not English, translate your response into their language.",
+            **self.args
+        )
+        # Embedding Model:
+        embed_model = kwargs.get("embed_model", self.embed_model)
+        self._embed = VertexAIEmbeddings(
+            model_name=embed_model,
+            project=project_id,
+            location=region,
+            request_parallelism=5,
+            max_retries=4,
+            temperature=self.temperature,
+            top_p=self.top_p,
+            top_k=self.top_k,
+        )
+        self._version_ = aiplatform.__version__

parrot/loaders/__init__.py

@@ -0,0 +1,20 @@
+from .dir import load_directory
+from .pdf import PDFLoader
+from .web import WebLoader
+from .youtube import YoutubeLoader
+from .vimeo import VimeoLoader
+from .word import MSWordLoader
+from .ppt import PPTXLoader
+from .repo import RepositoryLoader
+from .github import GithubLoader
+from .json import JSONLoader
+from .excel import ExcelLoader
+from .web_base import WebBaseLoader
+from .pdfmark import PDFMarkdownLoader
+from .pdfimages import PDFImageLoader
+from .pdftables import PDFTablesLoader
+from .pdfchapters import PDFChapterLoader
+from .txt import TXTLoader
+from .qa import QAFileLoader
+from .rtd import ReadTheDocsLoader
+from .videolocal import VideoLocalLoader