ai-parrot 0.3.4__cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/chatbots/asktroc.py

@@ -0,0 +1,16 @@
+from parrot.chatbots import Chatbot
+
+class AskTROC(Chatbot):
+    """Represents an Human Resources agent in Navigator.
+
+        Each agent has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """
+    company_information: dict = {
+        'company': 'T-ROC Global',
+        'company_website': 'https://www.trocglobal.com',
+        'contact_email': 'communications@trocglobal.com',
+        'contact_form': 'https://www.surveymonkey.com/r/TROC_Suggestion_Box'
+    }
+    role: str = 'Expert T-ROCer'
+    goal = 'Bring useful information about T-ROC Global to employees.'

parrot/chatbots/base.py

@@ -0,0 +1,366 @@
+from abc import ABC
+from typing import Any
+from aiohttp import web
+# Langchain:
+from langchain_core.prompts import (
+    PromptTemplate,
+    ChatPromptTemplate
+)
+from langchain.agents.agent import (
+    AgentExecutor,
+    RunnableAgent,
+    RunnableMultiActionAgent,
+)
+from langchain.memory import (
+    ConversationBufferMemory
+)
+from langchain.agents import create_react_agent
+from langchain_community.chat_message_histories import (
+    RedisChatMessageHistory
+)
+from navconfig.logging import logging
+## LLM configuration
+# Vertex
+try:
+    from ..llms.vertex import VertexLLM
+    VERTEX_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    VERTEX_ENABLED = False
+
+# Google
+try:
+    from ..llms.google import GoogleGenAI
+    GOOGLE_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    GOOGLE_ENABLED = False
+
+# Anthropic:
+try:
+    from ..llms.anthropic import Anthropic
+    ANTHROPIC_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    ANTHROPIC_ENABLED = False
+
+# OpenAI
+try:
+    from ..llms.openai import OpenAILLM
+    OPENAI_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    OPENAI_ENABLED = False
+
+# Groq
+try:
+    from ..llms.groq import GroqLLM
+    GROQ_ENABLED = True
+except (ModuleNotFoundError, ImportError):
+    GROQ_ENABLED = False
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_random_exponential,
+)  # for exponential backoff
+from ..interfaces import DBInterface
+from ..models import AgentResponse
+from ..conf import REDIS_HISTORY_URL
+
+
+BASEPROMPT = """
+Your name is {name}. You are a helpful and advanced AI assistant equipped with various tools to help users find information and solve problems efficiently.
+You are designed to be able to assist with a wide range of tasks.
+Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics.
+Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.
+
+**Has access to the following tools:**
+
+- {tools}
+- Google Web Search: Perform web searches to retrieve the latest and most relevant information from the internet.
+- google_maps_location_finder: Find location information, including latitude, longitude, and other geographical details.
+- Wikipedia: Access detailed and verified information from Wikipedia.
+- WikiData: Fetch structured data from WikiData for precise and factual details.
+- Bing Search: Search the web using Microsoft Bing Search, conduct searches using Bing for alternative perspectives and sources.
+- DuckDuckGo Web Search: Search the web using DuckDuckGo Search.
+- zipcode_distance: Calculate the distance between two zip codes.
+- zipcode_location: Obtain geographical information about a specific zip code.
+- zipcodes_by_radius: Find all US zip codes within a given radius of a zip code.
+- asknews_search: Search for up-to-date news and historical news on AskNews site.
+- StackExchangeSearch: Search for questions and answers on Stack Exchange.
+- openweather_tool: Get current weather conditions based on specific location, providing latitude and longitude.
+- OpenWeatherMap: Get weather information about a location.
+- yahoo_finance_news: Retrieve the latest financial news from Yahoo Finance.
+- python_repl_ast: A Python shell. Use this to execute python commands. Input should be a valid python command. When using this tool, sometimes output is abbreviated - make sure it does not look abbreviated before using it in your answer.
+- youtube_search: Search for videos on YouTube based on specific keywords.
+
+
+Use these tools effectively to provide accurate and comprehensive responses.
+
+**Instructions:**
+1. Understand the Query: Comprehend the user's request, especially if it pertains to events that may have already happened.
+2. **Event Timing Validation**: For questions about recent events or events that may have happened already (like sporting events, conferences, etc.), if you're not confident that the event has happened, you must **use one of the web search tools** to confirm before making any conclusions.
+3. Determine Confidence: If confident (90%+), provide the answer directly within the Thought process. If not confident, **always use a web search tool**.
+4. Choose Tool: If needed, select the most suitable tool, using one of [{tool_names}].
+5. Collect Information: Use the tool to gather data.
+6. Analyze Information: Identify patterns, relationships, and insights.
+7. Synthesize Response: Combine the information into a clear response.
+8. Cite Sources: Mention the sources of the information.
+
+** Your Style: **
+- Maintain a professional and friendly tone.
+- Be clear and concise in your explanations.
+- Use simple language for complex topics to ensure user understanding.
+
+To respond directly, use the following format:
+```
+Question: the input question you must answer.
+Thought: Explain your reasoning.
+Final Thought: Summarize your findings.
+Final Answer: Provide a clear and structured answer to the original question with relevant details.
+```
+
+
+To use a tool, please use the following format:
+```
+Question: the input question you must answer.
+Thought: Explain your reasoning, including whether you need to use a tool.
+Action: the action to take, should be one of [{tool_names}].
+- If using a tool: Specify the tool name (e.g., "Google Web Search") and the input.
+Action Input: the input to the action.
+Observation: the result of the action.
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Final Thought: Summarize your findings.
+Final Answer: Provide a clear and structured answer to the original question with relevant details.
+Detailed Result: Include the detailed result from the tool here if applicable.
+```
+
+**Important**: For recent events (such as the Paris 2024 Olympic Games), you must **use a web search tool** to verify the outcome or provide accurate up-to-date information before concluding. Always prioritize using tools if you're unsure or if the event is recent.
+
+
+Begin!
+
+Question: {input}
+{agent_scratchpad}
+"""
+
+class BaseAgent(ABC, DBInterface):
+    """Base Agent Interface.
+
+    This is the base class for all Agent Chatbots. It is an abstract class that
+    must be implemented by all Agent Chatbots.
+
+    """
+    def __init__(
+        self,
+        name: str = 'Agent',
+        llm: str = 'vertexai',
+        tools: list = None,
+        prompt_template: str = None,
+        **kwargs
+    ):
+        self.name = name
+        self.tools = tools
+        self.prompt_template = prompt_template
+        if not self.prompt_template:
+            self.prompt_template = BASEPROMPT
+        self.llm = self.llm_chain(llm, **kwargs)
+        self.prompt = self.get_prompt(self.prompt_template)
+        self.kwargs = kwargs
+        # Bot:
+        self._agent = None
+        self.agent = None
+        # Logger:
+        self.logger = logging.getLogger('Parrot.Agent')
+
+    def get_prompt(self, prompt, **kwargs):
+        partial_prompt = ChatPromptTemplate.from_template(prompt)
+        return partial_prompt.partial(
+            tools=self.tools,
+            name=self.name,
+            **kwargs
+        )
+
+    def get_memory(
+        self,
+        session_id: str = None,
+        key: str = 'chat_history',
+        input_key: str = 'question',
+        output_key: str = 'answer',
+        size: int = 5,
+        ttl: int = 86400
+    ):
+        args = {
+            'memory_key': key,
+            'input_key': input_key,
+            'output_key': output_key,
+            'return_messages': True,
+            'max_len': size
+        }
+        if session_id:
+            message_history = RedisChatMessageHistory(
+                url=REDIS_HISTORY_URL,
+                session_id=session_id,
+                ttl=ttl
+            )
+            args['chat_memory'] = message_history
+        return ConversationBufferMemory(
+            **args
+        )
+
+    def create_agent(self, **kwargs):
+        # Create a ReAct Agent:
+        self.agent = RunnableAgent(
+            runnable = create_react_agent(
+                self.llm,
+                self.tools,
+                prompt=self.prompt,
+            ),  # type: ignore
+            input_keys_arg=["input"],
+            return_keys_arg=["output"],
+        )
+        return self.agent
+
+    @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
+    def llm_chain(
+        self, llm: str = "vertexai", **kwargs
+    ):
+        """llm_chain.
+
+        Args:
+            llm (str): The language model to use.
+
+        Returns:
+            str: The language model to use.
+
+        """
+        if llm == 'openai':
+            mdl = OpenAILLM(model="gpt-3.5-turbo", **kwargs)
+        elif llm in ('vertexai', 'VertexLLM'):
+            mdl = VertexLLM(model="gemini-1.5-pro", **kwargs)
+        elif llm == 'anthropic':
+            mdl = Anthropic(model="claude-3-opus-20240229", **kwargs)
+        elif llm in ('groq', 'Groq', 'llama3'):
+            mdl = GroqLLM(model="llama3-70b-8192", **kwargs)
+        elif llm == 'mixtral':
+            mdl = GroqLLM(model="mixtral-8x7b-32768", **kwargs)
+        elif llm == 'google':
+            mdl = GoogleGenAI(model="models/gemini-1.5-pro-latest", **kwargs)
+        else:
+            raise ValueError(f"Invalid llm: {llm}")
+
+        # get the LLM:
+        return mdl.get_llm()
+
+    def get_executor(self, agent: RunnableAgent, tools: list, verbose: bool = True):
+        return AgentExecutor(
+            agent=agent,
+            tools=tools,
+            # callback_manager=callback_manager,
+            verbose=verbose,
+            return_intermediate_steps=True,
+            max_iterations=5,
+            max_execution_time=360,
+            handle_parsing_errors=True,
+            # memory=self.memory,
+            # early_stopping_method='generate',
+            **(self.kwargs or {}),
+        )
+
+    def get_chatbot(self):
+        return self.get_executor(self.agent, self.tools)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._agent = None
+
+    def get_conversation(self):
+        # Create the agent:
+        self.create_agent()
+        # define conversation:
+        self._agent = self.get_chatbot()
+        return self
+
+    def get_retrieval(self, request: web.Request) -> Any:
+        # Create the agent:
+        self.create_agent()
+        # define conversation:
+        self._agent = self.get_chatbot()
+        self.request = request
+        return self
+
+    async def question(
+            self,
+            question: str = None,
+            chain_type: str = 'stuff',
+            search_type: str = 'similarity',
+            search_kwargs: dict = {"k": 4, "fetch_k": 10, "lambda_mult": 0.89},
+            return_docs: bool = True,
+            metric_type: str = None,
+            memory: Any = None,
+            **kwargs
+    ):
+        """question.
+
+        Args:
+            question (str): The question to ask the chatbot.
+            chain_type (str): The type of chain to use.
+            search_type (str): The type of search to use.
+            search_kwargs (dict): The search kwargs to use.
+            return_docs (bool): Return the documents.
+            metric_type (str): The metric type to use.
+            memory (Any): The memory to use.
+
+        Returns:
+            Any: The response from the chatbot.
+
+        """
+        # TODO: adding the vector-search to the agent
+        input_question = {
+            "input": question
+        }
+        result = self._agent.invoke(input_question)
+        try:
+            response = AgentResponse(question=question, **result)
+            response.response = self.as_markdown(
+                response
+            )
+            return response
+        except Exception as e:
+            self.logger.exception(
+                f"Error on response: {e}"
+            )
+            raise
+
+    def invoke(self, query: str):
+        """invoke.
+
+        Args:
+            query (str): The query to ask the chatbot.
+
+        Returns:
+            str: The response from the chatbot.
+
+        """
+        input_question = {
+            "input": query
+        }
+        result = self._agent.invoke(input_question)
+        try:
+            response = AgentResponse(question=query, **result)
+            try:
+                return self.as_markdown(
+                    response
+                ), response
+            except Exception as exc:
+                self.logger.exception(
+                    f"Error on response: {exc}"
+                )
+                return result.get('output', None), None
+        except Exception as e:
+            return result, e
+
+    def as_markdown(self, response: AgentResponse) -> str:
+        markdown_output = f"**Question**: {response.question}  \n"
+        markdown_output += f"**Answer**: {response.output}  \n"
+        markdown_output += "```"
+        return markdown_output

parrot/chatbots/basic.py

@@ -0,0 +1,9 @@
+from .abstract import AbstractChatbot
+
+
+class Chatbot(AbstractChatbot):
+    """Represents an Chatbot in Navigator.
+
+        Each Chatbot has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """

parrot/chatbots/bose.py

@@ -0,0 +1,17 @@
+from .basic import Chatbot
+
+
+class BoseBot(Chatbot):
+    """Represents an agent in Navigator.
+        https://eminent-kiwi-trusty.ngrok-free.app/api/bose/messages
+        Each agent has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """
+    name: str = 'BoseBot'
+    company: str = 'T-ROC Global'
+    company_website: str = 'https://www.trocglobal.com'
+    contact_information = 'communications@trocglobal.com'
+    contact_form = 'https://bose.trocdigital.io/bose/bose_ticketing_system'
+    role: str = 'Bose Sound Systems Expert Technician and Consultant.'
+    goal = 'Bring useful information to Bose Technicians and Consultants.'
+    specialty_area = 'Bose endcap displays that are used to showcase Bose products'

parrot/chatbots/cody.py

@@ -0,0 +1,17 @@
+from parrot.chatbots import Chatbot
+
+class Cody(Chatbot):
+    """Represents a Python expert in Navigator.
+
+        Each expert has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """
+    name: str = 'Cody'
+    company_information: dict = {
+        'company': 'T-ROC Global',
+        'company_website': 'https://www.trocglobal.com',
+        'contact_email': 'communications@trocglobal.com',
+        'contact_form': 'https://www.surveymonkey.com/r/TROC_Suggestion_Box'
+    }
+    role: str = 'Python Expert'
+    goal = 'Provide useful information about Python programming to employees.'

parrot/chatbots/copilot.py

@@ -0,0 +1,83 @@
+from langchain_experimental.tools.python.tool import PythonAstREPLTool
+from .base import BaseAgent
+# importing Tools
+from ..tools import (
+    ZipcodeAPIToolkit,
+    WikipediaTool,
+    WikidataTool,
+    GoogleSearchTool,
+    GoogleLocationFinder,
+    BingSearchTool,
+    AskNewsTool,
+    DuckDuckGoSearchTool,
+    YouTubeSearchTool,
+    OpenWeatherMapTool,
+    StackExchangeTool,
+)
+
+
+class CopilotAgent(BaseAgent):
+    """CopilotAgent Agent.
+
+    This is Agent Base class for AI Copilots.
+    """
+    def __init__(
+        self,
+        name: str = 'Agent',
+        llm: str = 'vertexai',
+        tools: list = None,
+        prompt_template: str = None,
+        **kwargs
+    ):
+        super().__init__(name, llm, tools, prompt_template, **kwargs)
+        self.tools = [
+                PythonAstREPLTool(
+                    name='python_repl_ast',
+                    globals={},
+                    locals={}
+                )
+            ] + list(tools)
+        self.prompt = self.get_prompt(
+            self.prompt_template
+        )
+        # print('PROMPT > ', self.prompt)
+
+    @classmethod
+    def default_tools(cls) -> list:
+        # ZipCode API Toolkit
+        tools = []
+        zpt_tools = []
+        try:
+            zpt = ZipcodeAPIToolkit()
+            zpt_tools = zpt.get_tools()
+
+        except Exception as e:
+            print('ERROR LOADING ZIPCODE TOOLS')
+
+        try:
+            wk1 = WikipediaTool()
+            wk12 = WikidataTool()
+
+            g1 = GoogleSearchTool()
+            g2 = GoogleLocationFinder()
+
+            b = BingSearchTool()
+            d = DuckDuckGoSearchTool()
+            ask = AskNewsTool()
+
+            yt = YouTubeSearchTool()
+            stackexchange = StackExchangeTool()
+            weather = OpenWeatherMapTool()
+
+            tools = [
+                wk1,
+                wk12, g1, g2,
+                b, d, ask, yt,
+                weather,
+                stackexchange
+            ] + zpt_tools
+
+        except Exception as e:
+            print('TOOL Error > ', e)
+
+        return tools

parrot/chatbots/dataframe.py

@@ -0,0 +1,103 @@
+from typing import Union
+import pandas as pd
+from langchain_experimental.tools.python.tool import PythonAstREPLTool
+from .base import BaseAgent
+
+
+BASEPROMPT = """
+Your name is {name}, You are a helpful assistant built to provide comprehensive guidance and support on data calculations and various aspects of payroll, such as earnings, deductions, salary information, and payroll tax. The goal is to ensure accurate, timely, and compliant payroll processing.
+
+**Your Capabilities:**
+
+1. **Earnings Calculation:**
+   - Calculate regular earnings based on hourly rates or salaries.
+   - Handle overtime calculations, including differentials and double-time as needed.
+   - Include bonuses, commissions, and other incentive earnings.
+
+2. **Deductions:**
+   - Calculate mandatory deductions including federal, state, and local taxes.
+   - Handle other withholdings such as Social Security, Medicare, disability insurance, and unemployment insurance.
+   - Process voluntary deductions (e.g., health insurance premiums, retirement plan contributions, charitable donations).
+
+3. **Salary Information:**
+   - Provide gross and net salary breakdowns.
+   - Assist in setting up and adjusting salary structures.
+   - Manage payroll for part-time, full-time, and contract employees.
+
+These keywords must never be translated and transformed:
+- Action:
+- Thought:
+- Action Input:
+because they are part of the thinking process instead of the output.
+
+You are working with {num_dfs} pandas dataframes in Python named df1, df2, etc. You should use the tools below to answer the question posed to you:
+
+- python_repl_ast: A Python shell. Use this to execute python commands. Input should be a valid python command. When using this tool, sometimes output is abbreviated - make sure it does not look abbreviated before using it in your answer.
+- {tools}
+
+To use a tool, please use the following format:
+
+```
+Question: the input question you must answer.
+Thought: You should always think about what to do, don't try to reason out the answer on your own.
+Action: the action to take, should be one of [python_repl_ast,{tool_names}] if using a tool, otherwise answer on your own.
+Action Input: the input to the action.
+Observation: the result of the action.
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Final Thought: I now know the final answer.
+Final Answer: the final answer to the original input question.
+```
+
+
+```
+This is the result of `print(df1.head())` for each dataframe:
+{dfs_head}
+```
+
+Begin!
+
+Question: {input}
+{agent_scratchpad}
+"""
+
+
+class DataFrameAgent(BaseAgent):
+    """Dataframe Agent.
+
+    This is the Pandas Agent Chatbot.
+    """
+    def __init__(
+        self,
+        name: str = 'Agent',
+        llm: str = 'vertexai',
+        tools: list = None,
+        df: Union[list[pd.DataFrame], pd.DataFrame] = None,
+        prompt_template: str = None,
+        **kwargs
+    ):
+        super().__init__(name, llm, tools, prompt_template, **kwargs)
+        for _df in df if isinstance(df, list) else [df]:
+            if not isinstance(_df, pd.DataFrame):
+                raise ValueError(
+                    f"Expected pandas DataFrame, got {type(_df)}"
+                )
+        self.df = df
+        df_locals = {}
+        dfs_head = ""
+        num_dfs = 1
+        if isinstance(df, pd.DataFrame):
+            df = [df]
+        num_dfs = len(df)
+        for i, dataframe in enumerate(df):
+                    df_locals[f"df{i + 1}"] = dataframe
+                    dfs_head += (
+                        f"\n\n- This is the result of `print(df{i + 1}.head())`:\n"
+                        + dataframe.head().to_markdown() + "\n"
+                    )
+        prompt_template = BASEPROMPT
+        self.tools = [PythonAstREPLTool(locals=df_locals)] + list(tools)
+        self.prompt = self.get_prompt(
+            prompt_template,
+            num_dfs=num_dfs,
+            dfs_head=dfs_head
+        )

parrot/chatbots/hragents.py

@@ -0,0 +1,15 @@
+from parrot.chatbots import Chatbot
+
+class HRAgent(Chatbot):
+    """Represents an Human Resources agent in Navigator.
+
+        Each agent has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """
+    name: str = 'TROCers'
+    company: str = 'T-ROC Global'
+    company_website: str = 'https://www.trocglobal.com'
+    contact_information = 'communications@trocglobal.com'
+    contact_form = 'https://www.surveymonkey.com/r/TROC_Suggestion_Box'
+    role: str = 'Human Resources Assistant'
+    goal = 'Bring useful information to employees'

parrot/chatbots/odoo.py

@@ -0,0 +1,17 @@
+from .basic import Chatbot
+
+
+class OddieBot(Chatbot):
+    """Represents an agent in Navigator.
+
+        Each agent has a name, a role, a goal, a backstory,
+        and an optional language model (llm).
+    """
+    name: str = 'Oddie'
+    company: str = 'T-ROC Global'
+    company_website: str = 'https://www.trocglobal.com'
+    contact_information = 'communications@trocglobal.com'
+    contact_form = 'https://www.surveymonkey.com/r/TROC_Suggestion_Box'
+    role = "Odoo and ERP Specialist and Odoo Programmer"
+    goal = "To provide information and support on Odoo and ERP systems, help with troubleshooting, and answer any questions you may have about any Odoo and ERP systems implementation."
+    specialty_area = 'Bring useful information about Odoo ERP, documentation, usage, samples, etc.'