feat[Agent]: add agent conversation code

examples/agent.py

@@ -0,0 +1,41 @@
+import pandas as pd
+from pandasai.agent import Agent
+
+from pandasai.llm.openai import OpenAI
+
+employees_data = {
+    "EmployeeID": [1, 2, 3, 4, 5],
+    "Name": ["John", "Emma", "Liam", "Olivia", "William"],
+    "Department": ["HR", "Sales", "IT", "Marketing", "Finance"],
+}
+
+salaries_data = {
+    "EmployeeID": [1, 2, 3, 4, 5],
+    "Salary": [5000, 6000, 4500, 7000, 5500],
+}
+
+employees_df = pd.DataFrame(employees_data)
+salaries_df = pd.DataFrame(salaries_data)
+
+
+llm = OpenAI("OPEN_API_KEY")
+agent = Agent([employees_df, salaries_df], config={"llm": llm}, memory_size=10)
+
+# Chat with the agent
+response = agent.chat("Who gets paid the most?")
+print(response)
+
+
+# Get Clarification Questions
+response = agent.clarification_questions()
+
+if response:
+    for question in response.questions:
+        print(question)
+else:
+    print(response.message)
+
+
+# Explain how the chat response is generated
+response = agent.explain()
+print(response)

pandasai/__init__.py

@@ -44,6 +44,7 @@
 from .callbacks.base import BaseCallback
 from .schemas.df_config import Config
 from .helpers.cache import Cache
+from .agent import Agent
 
 __version__ = importlib.metadata.version(__package__ or __name__)
 
@@ -257,4 +258,4 @@ def clear_cache(filename: str = None):
     cache.clear()
 
 
-__all__ = ["PandasAI", "SmartDataframe", "SmartDatalake", "clear_cache"]
+__all__ = ["PandasAI", "SmartDataframe", "SmartDatalake", "Agent", "clear_cache"]

pandasai/agent/__init__.py

@@ -0,0 +1,136 @@
+import json
+from typing import Union, List, Optional
+from pandasai.agent.response import ClarificationResponse
+from pandasai.helpers.df_info import DataFrameType
+from pandasai.helpers.logger import Logger
+from pandasai.helpers.memory import Memory
+from pandasai.prompts.base import Prompt
+from pandasai.prompts.clarification_questions_prompt import ClarificationQuestionPrompt
+from pandasai.prompts.explain_prompt import ExplainPrompt
+from pandasai.schemas.df_config import Config
+
+from pandasai.smart_datalake import SmartDatalake
+
+
+class Agent:
+    """
+    Agent class to improve the conversational experience in PandasAI
+    """
+
+    _memory: Memory
+    _lake: SmartDatalake = None
+    logger: Optional[Logger] = None
+
+    def __init__(
+        self,
+        dfs: Union[DataFrameType, List[DataFrameType]],
+        config: Optional[Union[Config, dict]] = None,
+        logger: Optional[Logger] = None,
+        memory_size: int = 1,
+    ):
+        """
+        Args:
+            df (Union[SmartDataframe, SmartDatalake]): _description_
+            memory_size (int, optional): _description_. Defaults to 1.
+        """
+
+        if not isinstance(dfs, list):
+            dfs = [dfs]
+
+        self._lake = SmartDatalake(dfs, config, logger)
+        self.logger = self._lake.logger
+        # For the conversation multiple the memory size by 2
+        self._memory = Memory(memory_size * 2)
+
+    def _get_conversation(self):
+        """
+        Get Conversation from history
+
+        """
+        return "\n".join(
+            [
+                f"{'Question' if message['is_user'] else 'Answer'}: "
+                f"{message['message']}"
+                for i, message in enumerate(self._memory.all())
+            ]
+        )
+
+    def chat(self, query: str, output_type: Optional[str] = None):
+        """
+        Simulate a chat interaction with the assistant on Dataframe.
+        """
+        try:
+            self._memory.add(query, True)
+            conversation = self._get_conversation()
+            result = self._lake.chat(
+                query, output_type=output_type, start_conversation=conversation
+            )
+            self._memory.add(result, False)
+            return result
+        except Exception as exception:
+            return (
+                "Unfortunately, I was not able to get your answers, "
+                "because of the following error:\n"
+                f"\n{exception}\n"
+            )
+
+    def _get_clarification_prompt(self) -> Prompt:
+        """
+        Create a clarification prompt with relevant variables.
+        """
+        prompt = ClarificationQuestionPrompt()
+        prompt.set_var("dfs", self._lake.dfs)
+        prompt.set_var("conversation", self._get_conversation())
+        return prompt
+
+    def clarification_questions(self) -> ClarificationResponse:
+        """
+        Generate clarification questions based on the data
+        """
+        try:
+            prompt = self._get_clarification_prompt()
+            result = self._lake.llm.call(prompt)
+            self.logger.log(
+                f"""Clarification Questions:  {result}
+                """
+            )
+            questions: list[str] = json.loads(result)
+            return ClarificationResponse(
+                success=True, questions=questions[:3], message=result
+            )
+        except Exception as exception:
+            return ClarificationResponse(
+                False,
+                [],
+                "Unfortunately, I was not able to get your clarification questions, "
+                "because of the following error:\n"
+                f"\n{exception}\n",
+            )
+
+    def start_new_conversation(self) -> True:
+        """
+        Clears the previous conversation
+        """
+
+        self._memory.clear()
+        return True
+
+    def explain(self) -> str:
+        """
+        Returns the explanation of the code how it reached to the solution
+        """
+        try:
+            prompt = ExplainPrompt()
+            prompt.set_var("code", self._lake.last_code_executed)
+            response = self._lake.llm.call(prompt)
+            self.logger.log(
+                f"""Explaination:  {response}
+                """
+            )
+            return response
+        except Exception as exception:
+            return (
+                "Unfortunately, I was not able to explain, "
+                "because of the following error:\n"
+                f"\n{exception}\n"
+            )

pandasai/agent/response.py

@@ -0,0 +1,38 @@
+from typing import List
+
+
+class ClarificationResponse:
+    """
+    Clarification Response
+
+    """
+
+    def __init__(
+        self, success: bool = True, questions: List[str] = None, message: str = ""
+    ):
+        """
+        Args:
+            success: Whether the response generated or not.
+            questions: List of questions
+        """
+        self._success: bool = success
+        self._questions: List[str] = questions
+        self._message: str = message
+
+    @property
+    def questions(self) -> List[str]:
+        return self._questions
+
+    @property
+    def message(self) -> List[str]:
+        return self._message
+
+    @property
+    def success(self) -> bool:
+        return self._success
+
+    def __bool__(self) -> bool:
+        """
+        Define the success of response.
+        """
+        return self._success

pandasai/helpers/memory.py

@@ -1,17 +1,24 @@
 """ Memory class to store the conversations """
+import sys
 
 
 class Memory:
     """Memory class to store the conversations"""
 
     _messages: list
+    _max_messages: int
 
-    def __init__(self):
+    def __init__(self, max_messages: int = sys.maxsize):
         self._messages = []
+        self._max_messages = max_messages
 
     def add(self, message: str, is_user: bool):
         self._messages.append({"message": message, "is_user": is_user})
 
+        # Delete two entry because of the conversation
+        if len(self._messages) > self._max_messages:
+            del self._messages[:2]
+
     def count(self) -> int:
         return len(self._messages)
 

pandasai/prompts/clarification_questions_prompt.py

@@ -0,0 +1,47 @@
+""" Prompt to get clarification questions
+You are provided with the following pandas DataFrames:
+
+<dataframe>
+{dataframe}
+</dataframe>
+
+<conversation>
+{conversation}
+</conversation>
+
+Based on the conversation, are there any clarification questions that a senior data scientist would ask? These are questions for non technical people, only ask for questions they could ask given low tech expertise and no knowledge about how the dataframes are structured.
+
+Return the JSON array of the clarification questions. If there is no clarification question, return an empty array.
+
+Json:
+"""  # noqa: E501
+
+
+from .base import Prompt
+
+
+class ClarificationQuestionPrompt(Prompt):
+    """Prompt to get clarification questions"""
+
+    text: str = """
+You are provided with the following pandas DataFrames:
+
+<dataframe>
+{dataframes}
+</dataframe>
+
+<conversation>
+{conversation}
+</conversation>
+
+Based on the conversation, are there any clarification questions 
+that a senior data scientist would ask? These are questions for non technical people, 
+only ask for questions they could ask given low tech expertise and 
+no knowledge about how the dataframes are structured.
+
+Return the JSON array of the clarification questions. 
+
+If there is no clarification question, return an empty array.
+
+Json:
+"""

pandasai/prompts/explain_prompt.py

@@ -0,0 +1,23 @@
+""" Prompt to explain solution generated
+Based on the last conversation you generated the code. 
+Can you explain briefly for non technical person on how you came up with code 
+without explaining pandas library?
+"""
+
+
+from .base import Prompt
+
+
+class ExplainPrompt(Prompt):
+    """Prompt to get clarification questions"""
+
+    text: str = """
+Based on the last conversation you generated the code. 
+
+<Code>
+{code}
+</Code
+
+Can you explain briefly for non technical person on how you came up with code 
+without explaining pandas library?
+"""

pandasai/smart_datalake/__init__.py

@@ -255,7 +255,12 @@ def _get_cache_key(self) -> str:
 
         return cache_key
 
-    def chat(self, query: str, output_type: Optional[str] = None):
+    def chat(
+        self,
+        query: str,
+        output_type: Optional[str] = None,
+        start_conversation: Optional[str] = None,
+    ):
         """
         Run a query on the dataframe.
 
@@ -305,6 +310,9 @@ def chat(self, query: str, output_type: Optional[str] = None):
                     "save_charts_path": self._config.save_charts_path.rstrip("/"),
                     "output_type_hint": output_type_helper.template_hint,
                 }
+                if start_conversation is not None:
+                    default_values["conversation"] = start_conversation
+
                 generate_python_code_instruction = self._get_prompt(
                     "generate_python_code",
                     default_prompt=GeneratePythonCodePrompt,
@@ -623,7 +631,7 @@ def last_code_generated(self):
 
     @last_code_generated.setter
     def last_code_generated(self, last_code_generated: str):
-        self._code_manager._last_code_generated = last_code_generated
+        self._last_code_generated = last_code_generated
 
     @property
     def last_code_executed(self):
@@ -644,3 +652,7 @@ def last_error(self):
     @last_error.setter
     def last_error(self, last_error: str):
         self._last_error = last_error
+
+    @property
+    def dfs(self):
+        return self._dfs