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

parrot/handlers/chat.py

@@ -0,0 +1,162 @@
+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.
+        """
+        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)
+            memory_key = f'{session.session_id}_{name}_message_store'
+            memory = chatbot.get_memory(session_id=memory_key)
+            with chatbot.get_retrieval(request=self.request) as retrieval:
+                result = await retrieval.question(
+                    question=question,
+                    memory=memory
+                )
+                # 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/__init__.py

@@ -0,0 +1,137 @@
+# Langchain:
+from langchain import hub
+from ..exceptions import ConfigError  # pylint: disable=E0611
+
+## LLM configuration
+from .abstract import AbstractLLM
+
+# Vertex
+try:
+    from .vertex import VertexLLM
+    VERTEX_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    VERTEX_ENABLED = False
+
+# Anthropic:
+try:
+    from .anthropic import Anthropic
+    ANTHROPIC_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    ANTHROPIC_ENABLED = False
+
+# OpenAI
+try:
+    from .openai import OpenAILLM
+    OPENAI_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    OPENAI_ENABLED = False
+
+# LLM Transformers
+try:
+    from  .pipes import PipelineLLM
+    TRANSFORMERS_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    TRANSFORMERS_ENABLED = False
+
+# HuggingFaces Hub:
+try:
+    from  .hf import HuggingFace
+    HF_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    HF_ENABLED = False
+
+# GroQ:
+try:
+    from .groq import GroqLLM
+    GROQ_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    GROQ_ENABLED = False
+
+# Mixtral:
+try:
+    from .groq import GroqLLM
+    MIXTRAL_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    MIXTRAL_ENABLED = False
+
+# Google
+try:
+    from .google import GoogleGenAI
+    GOOGLE_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    GOOGLE_ENABLED = False
+
+
+def get_llm(llm_name: str, model_name: str, **kwargs) -> AbstractLLM:
+    """get_llm.
+
+    Load the Language Model for the Chatbot.
+    """
+    print('LLM > ', llm_name)
+    if llm_name == 'VertexLLM':
+        if VERTEX_ENABLED is False:
+            raise ConfigError(
+                "VertexAI enabled but not installed."
+            )
+        return VertexLLM(model=model_name, **kwargs)
+    if llm_name == 'Anthropic':
+        if ANTHROPIC_ENABLED is False:
+            raise ConfigError(
+                "ANTHROPIC is enabled but not installed."
+            )
+        return Anthropic(model=model_name, **kwargs)
+    if llm_name == 'OpenAI':
+        if OPENAI_ENABLED is False:
+            raise ConfigError(
+                "OpenAI is enabled but not installed."
+            )
+        return OpenAILLM(model=model_name, **kwargs)
+    if llm_name == 'hf':
+        if HF_ENABLED is False:
+            raise ConfigError(
+                "Hugginfaces Hub is enabled but not installed."
+            )
+        return HuggingFace(model=model_name, **kwargs)
+    if llm_name == 'pipe':
+        if TRANSFORMERS_ENABLED is False:
+            raise ConfigError(
+                "Transformes Pipelines are enabled, but not installed."
+            )
+        return PipelineLLM(model=model_name, **kwargs)
+    if llm_name in ('Groq', 'llama3', 'mixtral'):
+        if GROQ_ENABLED is False:
+            raise ConfigError(
+                "Groq is enabled but not installed."
+            )
+        return GroqLLM(model=model_name, **kwargs)
+    if llm_name == 'Google':
+        if GOOGLE_ENABLED is False:
+            raise ConfigError(
+                "Google is enabled but not installed."
+            )
+        return GoogleGenAI(model=model_name, **kwargs)
+    else:
+        # TODO: Add more LLMs
+        return hub.pull(llm_name)
+
+def get_llm_list():
+    """get_llm_list.
+
+    Get the list of available LLMs.
+    """
+    llms = []
+    if VERTEX_ENABLED:
+        llms.append(VertexLLM.get_supported_models())
+    if ANTHROPIC_ENABLED:
+        llms.append(Anthropic.get_supported_models())
+    if OPENAI_ENABLED:
+        llms.append(OpenAILLM.get_supported_models())
+    if HF_ENABLED:
+        llms.append(HuggingFace.get_supported_models())
+    if TRANSFORMERS_ENABLED:
+        llms.append(PipelineLLM.get_supported_models())
+    if GROQ_ENABLED:
+        llms.append(GroqLLM.get_supported_models())
+    if GOOGLE_ENABLED:
+        llms.append(GoogleGenAI.get_supported_models())
+    return llms

parrot/llms/abstract.py

@@ -0,0 +1,47 @@
+from abc import ABC
+from typing import List
+from langchain_core.prompts import ChatPromptTemplate
+
+
+class AbstractLLM(ABC):
+    """Abstract Language Model class.
+    """
+
+    model: str = "databricks/dolly-v2-3b"
+    supported_models: List[str] = []
+    embed_model: str = None
+    max_tokens: int = 1024
+    max_retries: int = 3
+
+    @classmethod
+    def get_supported_models(cls):
+        return cls.supported_models
+
+    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,42 @@
+from navconfig import config
+from navconfig.logging import logging
+from langchain_anthropic import ChatAnthropic  # pylint: disable=E0401, E0611
+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
+    supported_models: list = [
+        'claude-3-opus-20240229',
+        'claude-3-sonnet-20240229',
+        'claude-3-haiku-20240307',
+        'claude-3-5-sonnet-20240620',
+    ]
+
+    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,42 @@
+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"
+    supported_models: list = [
+        "models/text-bison-001",
+        "models/chat-bison-001",
+        "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,45 @@
+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"
+    supported_models: list = [
+        "llama3-70b-8192",
+        "llama3-80b-8192",
+        "llama-3.1-70b-versatile",
+        "llama-3.1-8b-instant",
+        "mixtral-8x7b-32768",
+        "whisper-large-v3",
+        "llama3-groq-70b-8192-tool-use-preview",
+        "gemma2-9b-it",
+        "gemma-7b-it",
+        "llama-guard-3-8b"
+    ]
+
+    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,45 @@
+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
+    supported_models: list = [
+        "databricks/dolly-v2-3b",
+        "gpt2",
+        "bigscience/bloom-1b7",
+        "meta-llama/Llama-2-7b-hf"
+    ]
+
+    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,59 @@
+from langchain_openai import (  # pylint: disable=E0401, E0611
+    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
+    supported_models: list = [
+        'gpt-4o-mini',
+        'gpt-4-turbo',
+        'gpt-4-turbo-preview',
+        'gpt-4o',
+        'gpt-3.5-turbo',
+        'gpt-3.5-turbo-instruct',
+        'dall-e-3'
+        'tts-1',
+    ]
+
+    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,
+        )