sql spider

README.md

@@ -1,2 +1,4 @@
 # AutogenMultiAgent
  Autogen Multiagent 
+
+

app.py

@@ -4,6 +4,7 @@ from configfile import Config
 from src.streamlitui.loadui import LoadStreamlitUI
 from src.usecases.multiagentschat import MultiAgentChat
 from src.usecases.withllamaIndex import WithLlamaIndexMultiAgentChat
+from src.usecases.agentchatsqlspider import AgentChatSqlSpider
 from src.LLMS.groqllm import GroqLLM
 
 
@@ -38,3 +39,12 @@ if __name__ == "__main__":
                                                     problem=problem,user_input=user_input)
             obj_usecases_with_llamaIndex_multichat.run()
 
+
+        elif user_input['selected_usecase'] == "AgentChat Sql Spider":
+            obj_sql_spider = AgentChatSqlSpider(assistant_name="Assistant", user_proxy_name='Userproxy',
+                                                    llm_config=llm_config,
+                                                    problem=problem)
+
+            obj_sql_spider.run()
+
+

configfile.ini

@@ -1,6 +1,6 @@
 [DEFAULT]
 PAGE_TITLE = AUTOGEN IN ACTION
 LLM_OPTIONS = Groq, Huggingface
-USECASE_OPTIONS = MultiAgent Chat, RAG Chat, With LLamaIndex Tool, Teachable Agent, With Langchain
+USECASE_OPTIONS = MultiAgent Chat, RAG Chat, With LLamaIndex Tool, AgentChat Sql Spider
 GROQ_MODEL_OPTIONS = mixtral-8x7b-32768, llama3-8b-8192, llama3-70b-8192, gemma-7b-i
 

requirements.txt

@@ -5,4 +5,5 @@ llama-index
 llama-index-tools-wikipedia
 llama-index-readers-wikipedia
 wikipedia
-llama-index-llms-groq
+llama-index-llms-groq
+spider-env

src/agents/sqlspideragent.py

@@ -0,0 +1,9 @@
+from autogen import ConversableAgent
+import streamlit as st
+
+
+class TrackableSpiderConversableAgent(ConversableAgent):
+    def _process_received_message(self, message, sender, silent):
+        with st.chat_message(sender.name):
+            st.write(message)
+        return super()._process_received_message(message, sender, silent)

src/usecases/agentchatsqlspider.py

@@ -0,0 +1,59 @@
+import asyncio
+import json
+from typing import Dict
+
+from autogen import ConversableAgent
+
+from src.agents.sqlspideragent import TrackableSpiderConversableAgent
+from src.agents.userproxyagent import TrackableUserProxyAgent
+import streamlit as st
+import os
+
+from src.utils.sqlexecutor import SQLExec
+
+os.environ["AUTOGEN_USE_DOCKER"] = "False"
+
+
+class AgentChatSqlSpider:
+    def __init__(self, assistant_name, user_proxy_name, llm_config, problem):
+        self.schema = None
+        self.question = None
+        self.sql_writer = TrackableSpiderConversableAgent(
+            "sql_writer",
+            llm_config=llm_config,
+            system_message="You are good at writing SQL queries. Always respond with a function call to execute_sql().",
+            is_termination_msg=self.check_termination,
+        )
+        self.user_proxy = TrackableUserProxyAgent(name=user_proxy_name,
+                                                  system_message="You are Admin",
+                                                  human_input_mode="NEVER",
+                                                  llm_config=llm_config,
+                                                  code_execution_config=False,
+                                                  is_termination_msg=lambda x: x.get("content", "").strip().endswith(
+                                                      "TERMINATE"))
+
+        self.problem = problem
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+    async def initiate_chat(self):
+        message = f"""Below is the schema for a SQL database:
+        {self.schema}
+        Generate a SQL query to answer the following question:
+        {self.question}
+        """
+
+        obj_SQLExec = SQLExec(self.sql_writer,self.user_proxy)
+
+        await self.user_proxy.a_initiate_chat(self.sql_writer, message=message,
+                                              clear_history=st.session_state["chat_with_history"])
+
+    def run(self):
+        self.loop.run_until_complete(self.initiate_chat())
+
+    def check_termination(msg: Dict):
+        if "tool_responses" not in msg:
+            return False
+        json_str = msg["tool_responses"][0]["content"]
+        obj = json.loads(json_str)
+        return "error" not in obj or obj["error"] is None and obj["reward"] == 1

src/usecases/withllamaIndex.py

@@ -64,7 +64,7 @@ class WithLlamaIndexMultiAgentChat:
         llm = Groq(model=self.user_input['selected_groq_model'], api_key=st.session_state["GROQ_API_KEY"])
         llm_70b = Groq(model="llama3-70b-8192")
 
-        location_specialist = ReActAgent.from_tools(tools=[wikipedia_tool], llm=llm, max_iterations=3,
+        location_specialist = ReActAgent.from_tools(tools=[wikipedia_tool], llm=llm, max_iterations=1,
                                                     verbose=True)
 
         return location_specialist

src/utils/sqlexecutor.py

@@ -0,0 +1,47 @@
+import json
+import os
+from typing import Annotated, Dict
+
+from spider_env import SpiderEnv
+
+
+class SQLExec:
+    def __init__(self, sql_writer, user_proxy):
+        self.gym = SpiderEnv(cache_dir='./.cache')
+        self.sql_writer = sql_writer
+        self.user_proxy = user_proxy
+
+    def sql_spider(self):
+        # %pip install spider-env
+
+        #gym = SpiderEnv()
+
+        # Randomly select a question from Spider
+        observation, info = self.gym.reset()
+        # The natural language question
+        question = observation["instruction"]
+        print(question)
+        # The schema of the corresponding database
+        schema = info["schema"]
+        print(schema)
+
+    def sql_exec(self):
+        @self.sql_writer.register_for_llm(description="Function for executing SQL query and returning a response")
+        @self.user_proxy.register_for_execution()
+        def execute_sql(
+                reflection: Annotated[str, "Think about what to do"], sql: Annotated[str, "SQL query"]
+        ) -> Annotated[Dict[str, str], "Dictionary with keys 'result' and 'error'"]:
+            observation, reward, _, _, info = self.gym.step(sql)
+            error = observation["feedback"]["error"]
+            if not error and reward == 0:
+                error = "The SQL query returned an incorrect result"
+            if error:
+                return {
+                    "error": error,
+                    "wrong_result": observation["feedback"]["result"],
+                    "correct_result": info["gold_result"],
+                }
+            else:
+                return {
+                    "result": observation["feedback"]["result"],
+                }