Add gradio interface

Dockerfile

@@ -13,5 +13,6 @@ WORKDIR /app/src
 ENV PATH="/root/.local/bin:${PATH}"
 
 EXPOSE 8501
+EXPOSE 7000
 
-CMD ["streamlit", "run", "main.py", ]
+CMD python main.py

README.MD

@@ -27,4 +27,17 @@ Coming Soon
 
 ### Deployment
 
-Project is packaged with a dockerfile and docker-compose job that should expose a streamlit ui on localhost:8501. Please use the envtemplate file to create your .env for running the project
+Project is packaged with a dockerfile expose a gradio ui on localhost:7000. Please use the envtemplate file to create your .env for running the project
+
+To build & run
+
+```
+docker build . -t ai_agent:latest
+docker run -it -p 7000:7000 ai_agent:latest
+```
+
+To build, run, and, clean up image in one command :
+
+```
+docker build . -t ai_agent:latest && docker run --rm -it -p 7000:7000 --name ai_agent_container ai_agent:latest
+```

docker-compose.yml

@@ -1,10 +0,0 @@
-version: '3.8'
-
-services:
-  app:
-    build: .
-    ports:
-      - "8501:8501"
-    volumes:
-      - ./src:/app/src
-    command: streamlit run main.py 

requirements.txt

@@ -1,5 +1,7 @@
 langchain
 streamlit
+gradio
 python-dotenv
 openai
-wikipedia
+wikipedia
+ipykernel

sandbox.ipynb

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jphillips/ai_agents/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "def greet(name):\n",
+    "    return \"Hello \" + name + \"!\"\n",
+    "\n",
+    "demo = gr.Interface(fn=greet, inputs=\"text\", outputs=\"text\")\n",
+    "\n",
+    "demo.launch()   "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

src/main.py

@@ -1,30 +1,26 @@
 from dotenv import load_dotenv, find_dotenv
 import os
-import streamlit as st
-from reasoning import ReasoningRouter, default_reasoning_router_config
+import gradio as gr
+from reasoning import ReasoningRouter, get_reasoning_router_config
 load_dotenv(find_dotenv())
 
+openai_api_key = os.getenv("OPENAI_API_KEY")
 
-def run_app():
-    """
-    Runs the Streamlit application.
 
-    Returns:
-        None
-    """
-    openai_api_key = os.getenv("OPENAI_API_KEY")
+def determine_and_execute(question, temperature):
+    config = get_reasoning_router_config(temperature=temperature)
+    config.temperature = temperature
+    determiner = ReasoningRouter(api_key=openai_api_key, config=config, question=question, display=print)
+    determine_output, execute_output = determiner.determine_and_execute()
+    return determine_output, execute_output
 
-    col1, col2 = st.columns([1, 3])
-    with col1:
-        st.text("AI Agents Sandbox")
-    with col2:
-        st.title("Prompt Strategy Demo")
-    question = st.text_area('Enter your question here:', height=200)
-    config = default_reasoning_router_config()
-    if question:
-        determiner = ReasoningRouter(api_key=openai_api_key, config=config, question=question,display=st.write)
-        determiner.determine_and_execute()
+iface = gr.Interface(
+    fn=determine_and_execute,
+    inputs=[gr.components.Textbox(label="Enter your question here:"), gr.components.Slider(minimum=0, maximum=2, default=.7, label="Temperature")],
+    outputs=[gr.components.Textbox(label="Reasoning Strategy"), gr.components.Textbox(label="Reasoning")],
+    title="Prompt Strategy Demo",
+    description="AI Agents Sandbox"
+)
 
 if __name__ == "__main__":
-    run_app()
-
+    iface.launch(server_name="0.0.0.0", server_port=7000)

src/reasoning/__init__.py

@@ -1,5 +1,5 @@
-from .react import ReactStrategy, default_react_config
-from .tree_of_thought import TreeOfThoughtStrategy, default_tot_config
-from .chain_of_thought import ChainOfThoughtStrategy, default_cot_confg
-from .reasoning_router import ReasoningRouter, default_reasoning_router_config
-from .reasoning_strategy import ReasoningStrategy, ReasoningConfig, default_reasoning_config
+from .react import ReactStrategy, get_react_config
+from .tree_of_thought import TreeOfThoughtStrategy, get_tot_config
+from .chain_of_thought import ChainOfThoughtStrategy, get_cot_confg
+from .reasoning_router import ReasoningRouter, get_reasoning_router_config
+from .reasoning_strategy import ReasoningStrategy, ReasoningConfig, get_reasoning_config

src/reasoning/chain_of_thought.py

@@ -2,10 +2,13 @@ from langchain import PromptTemplate, LLMChain
 import streamlit as st
 from .reasoning_strategy import ReasoningStrategy, ReasoningConfig
 from typing import Callable
+import pprint 
 
 class ChainOfThoughtStrategy(ReasoningStrategy):
     def __init__(self, config: ReasoningConfig, display: Callable):
         super().__init__(config=config, display=display)
+        print("Creating Reasoning Router with config: ")
+        pprint.pprint(vars(config))
 
     def run(self, question):
         print('Using Chain of Thought')
@@ -21,11 +24,12 @@ class ChainOfThoughtStrategy(ReasoningStrategy):
         response_cot = llm_chain.run(question)
         print(response_cot)
         self.display(response_cot)
+        return response_cot
 
-def default_cot_confg():
+def get_cot_confg(temperature: float = 0.7) -> ReasoningConfig:
     usage = """
     This problem is simple and the solution may be obtained by focusing on generating a coherent series 
     of reasoning steps that lead to the final answer. The approach provides interpretability, decomposes 
     multi-step problems into intermediate steps, and allows for additional computation allocation
     """
-    return ReasoningConfig(usage=usage)
+    return ReasoningConfig(usage=usage, temperature=temperature)

src/reasoning/react.py

@@ -3,12 +3,14 @@ from .reasoning_strategy import ReasoningStrategy, ReasoningConfig
 from langchain.docstore.wikipedia import Wikipedia
 from langchain.agents import initialize_agent, Tool, AgentExecutor
 from langchain.agents.react.base import DocstoreExplorer
-from typing import Callable
-
+from typing import Callable, Optional
+import pprint
 
 class ReactStrategy(ReasoningStrategy):
     def __init__(self, config: ReasoningConfig, display: Callable):
         super().__init__(config=config, display=display)
+        print("Creating reAct strategy with config: ",)
+        pprint.pprint(vars(config))
 
     def run(self, question) -> str:
         print('Using ReAct')
@@ -38,7 +40,7 @@ class ReactStrategy(ReasoningStrategy):
         self.display(response_react)
         return response_react
 
-def default_react_config() -> ReasoningConfig:
+def get_react_config(temperature: float = 0.7) -> ReasoningConfig:
     usage = """
     The solution for this problem requires searching for further information online, 
     generating reasoning traces and task-specific actions in an interleaved manner. 
@@ -47,4 +49,5 @@ def default_react_config() -> ReasoningConfig:
     maintain, and adjust high-level plans for acting, while also interacting with external 
     sources to incorporate additional information into reasoning 
     """
-    return ReasoningConfig(usage=usage)
+    return ReasoningConfig(usage=usage, temperature=temperature)
+    

src/reasoning/reasoning_router.py

@@ -1,9 +1,10 @@
 from langchain import PromptTemplate, LLMChain
-from .react import ReactStrategy, default_react_config
-from .tree_of_thought import TreeOfThoughtStrategy, default_tot_config
-from .chain_of_thought import ChainOfThoughtStrategy, default_cot_confg
+from .react import ReactStrategy, get_react_config
+from .tree_of_thought import TreeOfThoughtStrategy, get_tot_config
+from .chain_of_thought import ChainOfThoughtStrategy, get_cot_confg
 from .reasoning_strategy import ReasoningConfig
 from typing import Tuple, Callable, Optional
+import pprint
 import re
 import os
 
@@ -18,15 +19,18 @@ class ReasoningRouter:
         Returns:
             None
         """
+        print("Creating Reasoning Router with config: ",)
+        pprint.pprint(vars(config))
         self.api_key = api_key
         self.llm  = config.llm_class(temperature=config.temperature, max_tokens=config.max_tokens)
         self.question: str = question
         self.display: Callable = display
 
+
         self.strategies = {
-            1: ReactStrategy(default_react_config(), display=self.display),
-            2: TreeOfThoughtStrategy(default_tot_config(),display=self.display),
-            3: ChainOfThoughtStrategy(default_cot_confg(),display=self.display)
+            1: ReactStrategy(get_react_config(temperature=config.temperature), display=self.display),
+            2: TreeOfThoughtStrategy(get_tot_config(temperature=config.temperature),display=self.display),
+            3: ChainOfThoughtStrategy(get_cot_confg(temperature=config.temperature),display=self.display)
         }
         self.usage_block = f"""
 
@@ -66,7 +70,8 @@ class ReasoningRouter:
         Determines the appropriate reasoning strategy based on the user's question and executes it.
 
         Returns:
-            None
+            response : Reason the strategy was selected
+            strat_response : Response from the strategy 
         """
         
         prompt = PromptTemplate(template=self.template, input_variables=["question"])
@@ -85,6 +90,6 @@ class ReasoningRouter:
             
         return response, strat_resp
 
-def default_reasoning_router_config() -> ReasoningConfig:
+def get_reasoning_router_config(temperature: float = 0.6) -> ReasoningConfig:
     usage="This router should be used when determing the most effective strategy for a query requiring more complex, but general reasoning to derive"
-    return ReasoningConfig(temperature=0.6, max_tokens=3000, usage=usage)
+    return ReasoningConfig(temperature=temperature, max_tokens=3000, usage=usage)

src/reasoning/reasoning_strategy.py

@@ -31,6 +31,6 @@ class ReasoningStrategy:
     def run(self, question):
         raise NotImplementedError()
     
-def default_reasoning_config():
+def get_reasoning_config(temperature: float = 0.7) -> ReasoningConfig:
     usage = "This is the default reasoning model that should only be used as a last resort"
     return ReasoningConfig(usage=usage)

src/reasoning/tree_of_thought.py

@@ -2,10 +2,13 @@ from .reasoning_strategy import ReasoningStrategy
 from langchain import LLMChain, PromptTemplate
 from .reasoning_strategy import ReasoningStrategy, ReasoningConfig
 from typing import Callable
+import pprint
 
 class TreeOfThoughtStrategy(ReasoningStrategy):
     def __init__(self, config: ReasoningConfig, display: Callable):
         super().__init__(config=config, display=display)
+        print("Creating Reasoning Router with config: ",)
+        pprint.pprint(vars(config))
 
     def run(self, question)-> str:
         print('Using ToT')
@@ -34,11 +37,11 @@ class TreeOfThoughtStrategy(ReasoningStrategy):
         self.display(response_tot)
         return response_tot
 
-def default_tot_config():
+def get_tot_config(temperature: float = 0.7) -> ReasoningConfig:
     usage= """
     This problem is complex and the solution requires exploring multiple reasoning paths over thoughts.
       It treats the problem as a search over a tree structure, with each node representing a partial 
       solution and the branches corresponding to operators that modify the solution. It involves thought 
       decomposition, thought generation, state evaluation, and a search algorithm 
     """
-    return ReasoningConfig(usage=usage)
+    return ReasoningConfig(usage=usage, temperature=temperature)

src/streamlit_main.py

@@ -0,0 +1,30 @@
+from dotenv import load_dotenv, find_dotenv
+import os
+import streamlit as st
+from reasoning import ReasoningRouter, get_reasoning_router_config
+load_dotenv(find_dotenv())
+
+
+def run_app():
+    """
+    Runs the Streamlit application.
+
+    Returns:
+        None
+    """
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+
+    col1, col2 = st.columns([1, 3])
+    with col1:
+        st.text("AI Agents Sandbox")
+    with col2:
+        st.title("Prompt Strategy Demo")
+    question = st.text_area('Enter your question here:', height=200)
+    config = get_reasoning_router_config()
+    if question:
+        determiner = ReasoningRouter(api_key=openai_api_key, config=config, question=question,display=st.write)
+        determiner.determine_and_execute()
+
+if __name__ == "__main__":
+    run_app()
+