ai-parrot 0.8.3__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

parrot/handlers/agents.py

@@ -0,0 +1,292 @@
+from typing import List
+from aiohttp import web
+import pandas as pd
+from navigator_auth.decorators import (
+    is_authenticated,
+    user_session
+)
+from navigator.views import BaseView
+from querysource.queries.qs import QS
+from querysource.queries.multi import MultiQS
+from ..bots.abstract import AbstractBot
+from ..llms.vertex import VertexLLM
+from ..bots.data import PandasAgent
+from ..models import AgentModel
+
+
+@is_authenticated()
+@user_session()
+class AgentHandler(BaseView):
+    """
+    AgentHandler.
+    description: Agent Handler for Parrot Application.
+
+    TODO: Support for per-user session agents.
+    - Tool for doing an EDA (exploratory data-analysis) on a dataframe.
+    - Tool for doing a data profiling on a dataframe.
+    """
+    async def put(self, *args, **kwargs):
+        """
+        put.
+        description: Put method for AgentHandler
+
+        Use this method to create a new Agent.
+        """
+        app = self.request.app
+        _id = self.request.match_info.get('agent_name', None)
+        data = await self.request.json()
+        name = data.pop('name', None)
+        if not name:
+            return self.json_response(
+                {
+                "message": "Agent name not found."
+                },
+                status=404
+            )
+        _id = data.pop('chatbot_id', None)
+        # To create a new agent, we need:
+        # A list of queries (Query slugs) to be converted into dataframes
+        query = data.pop('query', None)
+        if not query:
+            return self.json_response(
+                {
+                "message": "No query was found."
+                },
+                status=400
+            )
+        # A list of tools to be used by the agent
+        tools = kwargs.pop('tools', [])
+        # a backstory and an optional capabilities for Bot.
+        backstory = data.pop('backstory', None)
+        capabilities = data.pop('capabilities', None)
+        try:
+            manager = app['bot_manager']
+        except KeyError:
+            return self.json_response(
+                {
+                "message": "Chatbot Manager is not installed."
+                },
+                status=404
+            )
+        if agent := manager.get_agent(_id):
+            args = {
+                "message": f"Agent {name} already exists.",
+                "agent": agent.name,
+                "agent_id": agent.chatbot_id,
+                "description": agent.description,
+                "backstory": agent.backstory,
+                "capabilities": agent.get_capabilities(),
+                "type": 'PandasAgent',
+                "llm": f"{agent.llm!r}",
+                "temperature": agent.llm.temperature,
+            }
+            return self.json_response(
+                args,
+                status=208
+            )
+        try:
+            # Generate the Data Frames from the queries:
+            dfs = await PandasAgent.gen_data(
+                query=query.copy(),
+                agent_name=_id,
+                refresh=True,
+                no_cache=True
+            )
+        except Exception as e:
+            return self.json_response(
+                {
+                "message": f"Error generating dataframes: {e}"
+                },
+                status=400
+            )
+        try:
+            args = {
+                "name": name,
+                "df": dfs,
+                "query": query,
+                "tools": tools,
+                "backstory": backstory,
+                "capabilities": capabilities,
+                **data
+            }
+            if _id:
+                args['chatbot_id'] = _id
+            # Create and Add the agent to the manager
+            agent = await manager.create_agent(
+                class_name=PandasAgent,
+                **args
+            )
+            await agent.configure(app=app)
+        except Exception as e:
+            return self.json_response(
+                {
+                "message": f"Error on Agent creation: {e}"
+                },
+                status=400
+            )
+        # Check if the agent was created successfully
+        if not agent:
+            return self.json_response(
+                {
+                "message": f"Error creating agent: {e}"
+                },
+                status=400
+            )
+        # Saving Agent into DB:
+        try:
+            args.pop('df')
+            args['query'] = query
+            result = await manager.save_agent(**args)
+            if not result:
+                manager.remove_agent(agent)
+                return self.json_response(
+                    {
+                    "message": f"Error saving agent {agent.name}"
+                    },
+                    status=400
+                )
+        except Exception as e:
+            manager.remove_agent(agent)
+            return self.json_response(
+                {
+                "message": f"Error saving agent {agent.name}: {e}"
+                },
+                status=400
+            )
+        # Return the agent information
+        return self.json_response(
+            {
+                "message": f"Agent {name} created successfully.",
+                "agent": agent.name,
+                "agent_id": agent.chatbot_id,
+                "description": agent.description,
+                "backstory": agent.backstory,
+                "capabilities": agent.get_capabilities(),
+                "type": 'PandasAgent',
+                "llm": f"{agent.llm!r}",
+                "temperature": agent.llm.temperature,
+            },
+            status=201
+        )
+
+    async def post(self, *args, **kwargs):
+        """
+        post.
+        description: Do a query to the Agent.
+        Use this method to interact with a Agent.
+        """
+        app = self.request.app
+        try:
+            manager = app['bot_manager']
+        except KeyError:
+            return self.json_response(
+                {
+                "message": "Chatbot Manager is not installed."
+                },
+                status=404
+            )
+        name = self.request.match_info.get('agent_name', None)
+        if not name:
+            return self.json_response(
+                {
+                "message": "Agent name not found."
+                },
+                status=404
+            )
+        data = await self.request.json()
+        if not 'query' in data:
+            return self.json_response(
+                {
+                "message": "No query was found."
+                },
+                status=400
+            )
+        if agent := manager.get_agent(name):
+            # doing a question to the agent:
+            try:
+                response, result = await agent.invoke(
+                    data['query']
+                )
+                result.response = response
+                # null the chat_history:
+                result.chat_history = []
+                return self.json_response(response=result)
+            except Exception as e:
+                return self.json_response(
+                    {
+                    "message": f"Error invoking agent: {e}"
+                    },
+                    status=400
+                )
+        else:
+            return self.json_response(
+                {
+                "message": f"Agent {name} not found."
+                },
+                status=404
+            )
+
+    async def patch(self, *args, **kwargs):
+        """
+        patch.
+        description: Update the data of the Agent.
+        Use this method to update the dataframes assigned to the Agent.
+        """
+        app = self.request.app
+        try:
+            manager = app['bot_manager']
+        except KeyError:
+            return self.json_response(
+                {
+                "message": "Chatbot Manager is not installed."
+                },
+                status=404
+            )
+        name = self.request.match_info.get('agent_name', None)
+        if not name:
+            return self.json_response(
+                {
+                "message": "Agent name not found."
+                },
+                status=404
+            )
+        try:
+            data = await self.request.json()
+        except Exception as e:
+            data = {}
+        query = data.pop('query', None)
+        if agent := manager.get_agent(name):
+            # dextract the new query from the request, or from agent
+            qry = query if query else agent.get_query()
+            try:
+                # Generate the Data Frames from the queries:
+                dfs = await PandasAgent.gen_data(
+                    agent_name=str(agent.chatbot_id),
+                    query=qry,
+                    refresh=True
+                )
+                if dfs:
+                    # Update the agent with the new dataframes
+                    agent.df = dfs
+                    # Update the agent with the new query
+                    await agent.configure(df=dfs)
+                return self.json_response(
+                    {
+                    "message": f"{agent.name}: Agent Data was Updated."
+                    },
+                    status=202
+                )
+            except Exception as e:
+                return self.json_response(
+                    {
+                    "message": f"Error refreshing agent {agent.name}: {e}"
+                    },
+                    status=400
+                )
+        else:
+            return self.json_response(
+                {
+                "message": f"Agent {name} not found."
+                },
+                status=404
+            )

parrot/handlers/bots.py

@@ -0,0 +1,196 @@
+from asyncdb import AsyncDB
+from navigator.views import (
+    ModelView,
+    BaseView,
+    FormModel
+)
+from parrot.conf import (
+    BIGQUERY_CREDENTIALS,
+    BIGQUERY_PROJECT_ID,
+)
+from ..models import (
+    ChatbotModel,
+    ChatbotUsage,
+    PromptLibrary,
+    ChatbotFeedback,
+    FeedbackType
+)
+
+
+class PromptLibraryManagement(ModelView):
+    """
+    PromptLibraryManagement.
+    description: PromptLibraryManagement for Parrot Application.
+    """
+
+    model = PromptLibrary
+    name: str = "Prompt Library Management"
+    path: str = '/api/v1/prompt_library'
+    pk: str = 'prompt_id'
+
+    async def _set_created_by(self, value, column, data):
+        if not value:
+            return await self.get_userid(session=self._session)
+        return value
+
+
+class ChatbotUsageHandler(ModelView):
+    """
+    ChatbotUsageHandler.
+    description: ChatbotUsageHandler for Parrot Application.
+    """
+
+    model = ChatbotUsage
+    driver: str = 'bigquery'
+    credentials: dict = {
+        "credentials": BIGQUERY_CREDENTIALS,
+        "project_id": BIGQUERY_PROJECT_ID,
+    }
+    name: str = "Chatbot Usage"
+    path: str = '/api/v1/chatbots/usage'
+    pk: str = 'sid'
+
+
+class ChatbotSharingQuestion(BaseView):
+    """
+    ChatbotSharingQuestion.
+    description: ChatbotSharingQuestion for Parrot Application.
+    """
+
+    def get_connection(self):
+        params = {
+            "credentials": BIGQUERY_CREDENTIALS,
+            "project_id": BIGQUERY_PROJECT_ID,
+        }
+        return AsyncDB(
+            'bigquery',
+            params=params
+        )
+
+    async def get(self):
+        qs = self.get_arguments(self.request)
+        sid = qs.get('sid', None)
+        if not sid:
+            return self.error(
+                response={
+                    "message": "You need to Provided a ID of Question"
+                },
+                status=400
+            )
+        db = self.get_connection()
+        try:
+            async with await db.connection() as conn:  #pylint: disable=E1101
+                ChatbotUsage.Meta.connection = conn
+                # Getting a SID from sid
+                question = await ChatbotUsage.get(sid=sid)
+                if not question:
+                    return self.error(
+                        response={
+                            "message": "Question not found"
+                        },
+                        status=404
+                    )
+                return self.json_response(
+                    {
+                        "chatbot": question.chatbot_id,
+                        "question": question.question,
+                        "answer": question.response,
+                        "at": question.used_at
+                    }
+                )
+        except Exception as e:
+            return self.error(
+                response={
+                    "message": f"Error on Chatbot Sharing Question: {e}"
+                },
+                status=400
+            )
+
+
+
+class FeedbackTypeHandler(BaseView):
+    """
+    FeedbackTypeHandler.
+    description: FeedbackTypeHandler for Parrot Application.
+    """
+
+    async def get(self):
+        qs = self.get_arguments(self.request)
+        category = qs.get('feedback_type', 'good').capitalize()
+        feedback_list = FeedbackType.list_feedback(category)
+        return self.json_response({
+            "feedback": feedback_list
+        })
+
+# Manage Feedback:
+class ChatbotFeedbackHandler(FormModel):
+    """
+    ChatbotFeedbackHandler.
+    description: ChatbotFeedbackHandler for Parrot Application.
+    """
+    model = ChatbotFeedback
+    path: str = '/api/v1/bot_feedback'
+
+    def get_connection(self):
+        params = {
+            "credentials": BIGQUERY_CREDENTIALS,
+            "project_id": BIGQUERY_PROJECT_ID,
+        }
+        return AsyncDB(
+            'bigquery',
+            params=params,
+            force_closing=False
+        )
+
+    async def post(self):
+        feedback = await self.validate_payload()
+        if not feedback:
+            return self.error(
+                response={
+                    "message": "Error on Bot Feedback"
+                },
+                status=400
+            )
+        db = self.get_connection()
+        try:
+            async with await db.connection() as conn:  #pylint: disable=E1101
+                data = feedback.to_dict()
+                # convert to string (bigquery uses json.dumps to convert to string)
+                data['sid'] = str(data['sid'])
+                data['chatbot_id'] = str(data['chatbot_id'])
+                data['expiration_timestamp'] = str(data['expiration_timestamp'])
+                data['feedback_type'] = feedback.feedback_type.value
+                # writing directly to bigquery
+                await conn.write(
+                    [data],
+                    table_id=ChatbotFeedback.Meta.name,
+                    dataset_id=ChatbotFeedback.Meta.schema,
+                    use_streams=False,
+                    use_pandas=False
+                )
+                return self.json_response({
+                    "message": "Bot Feedback Submitted, Thank you for your feedback!.",
+                    "question": f"Question of ID: {feedback.sid} for bot {feedback.chatbot_id}"
+                }, status=201)
+        except Exception as e:
+            return self.error(
+                response={
+                    "message": f"Error on Bot Feedback: {e}"
+                },
+                status=400
+            )
+
+
+class ChatbotHandler(ModelView):
+    """
+    ChatbotHandler.
+    description: ChatbotHandler for Parrot Application.
+    """
+
+    model = ChatbotModel
+    name: str = "Chatbot Management"
+    pk: str = 'chatbot_id'
+
+
+    async def _set_created_by(self, value, column, data):
+        return await self.get_userid(session=self._session)

parrot/handlers/chat.py

@@ -0,0 +1,192 @@
+from aiohttp import web
+from navigator_auth.decorators import (
+    is_authenticated,
+    user_session,
+    allowed_organizations
+)
+from navigator.views import BaseView
+from ..bots.abstract import AbstractBot
+
+
+@is_authenticated()
+@user_session()
+class ChatHandler(BaseView):
+    """
+    ChatHandler.
+    description: Chat Handler 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['bot_manager']
+            chatbot = manager.get_bot(name)
+            if not chatbot:
+                return self.error(
+                    f"Chatbot {name} not found.",
+                    status=404
+                )
+            config_file = getattr(chatbot, 'config_file', None)
+            return self.json_response({
+                "chatbot": chatbot.name,
+                "description": chatbot.description,
+                "role": chatbot.role,
+                "embedding_model": chatbot.embedding_model,
+                "llm": f"{chatbot.llm!r}",
+                "temperature": chatbot.llm.temperature,
+                "config_file": config_file
+            })
+
+    async def post(self, *args, **kwargs):
+        """
+        post.
+        description: Post method for ChatHandler.
+
+        Use this method to interact with a Chatbot.
+        """
+        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['bot_manager']
+        except KeyError:
+            return self.json_response(
+                {
+                "message": "Chatbot Manager is not installed."
+                },
+                status=404
+            )
+        try:
+            chatbot: AbstractBot = manager.get_bot(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.pop('query')
+        try:
+            session = self.request.session
+        except AttributeError:
+            session = None
+        if not session:
+            return self.json_response(
+                {
+                "message": "User Session is required to interact with a Chatbot."
+                },
+                status=400
+            )
+        try:
+            async with chatbot.retrieval(request=self.request) as retrieval:
+                session_id = session.get('session_id', None)
+                memory_key = f'{session.session_id}_{name}_message_store'
+                memory = retrieval.get_memory(session_id=memory_key)
+                result = await retrieval.invoke(
+                    question=question,
+                    llm=llm,
+                    memory=memory,
+                    **data
+                )
+                # Drop "memory" information:
+                result.chat_history = None
+                if result.source_documents:
+                    documents = []
+                    for doc in result.source_documents:
+                        dc = {
+                            **doc.metadata
+                        }
+                        documents.append(dc)
+                    result.source_documents = documents
+                return self.json_response(response=result)
+        except ValueError as exc:
+            return self.error(
+                f"{exc}",
+                exception=exc,
+                status=400
+            )
+        except web.HTTPException 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['bot_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',
+)