Decouple components from interface, adds tabs

Dockerfile

@@ -8,11 +8,11 @@ RUN pip install -r requirements.txt
 
 COPY . .
 
-WORKDIR /app/src
+WORKDIR /app/
 
 ENV PATH="/root/.local/bin:${PATH}"
 
 EXPOSE 8501
 EXPOSE 7000
 
-CMD python main.py
+CMD python server.py

README.MD

@@ -4,7 +4,7 @@ Heavily inspired by examples and code across the AI Open Source community but wi
 
 ## UI
 Front end for templates currently uses streamlit, however display for each agent example will be heavily decoupled from deployment avenue. 
-Strategies for jupyter, streamlit, and react will be prioritized in general at this time. 
+Strategies for jupyter, gradio, and react will be prioritized in general at this time. 
 
 ## Modules
 

{src → modules}/reasoning/__init__.py

@@ -1,5 +1,6 @@
-from .react import ReactStrategy, get_react_config
+from .re_act import ReActStrategy, get_re_act_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
+from .reasoning_strategy import ReasoningStrategy, ReasoningConfig, get_reasoning_config
+from .component import create_reasoning_router_ui

modules/reasoning/component.py

@@ -0,0 +1,32 @@
+from modules.reasoning.reasoning_router import ReasoningRouter, get_reasoning_router_config
+import gradio as gr
+import os 
+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
+
+examples = [["""Bob is in the living room.
+He walks to the kitchen, carrying a cup.
+He puts a ball in the cup and carries the cup to the bedroom.
+He turns the cup upside down, then walks to the garden.
+He puts the cup down in the garden, then walks to the garage.
+Where is the ball?""", 0.6], ["Given the task of building a house in the middle of a river, what are three strategies I could use to mitigate risk of flooding?", 0.6 ]]
+
+def create_reasoning_router_ui(cache_examples=False):  
+    with gr.Row():
+        question = gr.Textbox(label="Enter your question here:")
+        temperature = gr.Slider(minimum=0, maximum=2, default=.7, label="Temperature")
+    with gr.Column():
+        reasoning_strategy = gr.Textbox(label="Reasoning Strategy")
+        reasoning = gr.Textbox(label="Reasoning")
+    
+    generate_button = gr.Button(label="Generate")
+    generate_button.click(determine_and_execute, outputs=[reasoning_strategy, reasoning], inputs=[question, temperature])
+    gr.Examples(examples=examples, fn=determine_and_execute, cache_examples=cache_examples, inputs=[question, temperature], outputs=[reasoning_strategy, reasoning])
+

src/reasoning/react.py → modules/reasoning/re_act.py

@@ -6,7 +6,7 @@ from langchain.agents.react.base import DocstoreExplorer
 from typing import Callable, Optional
 import pprint
 
-class ReactStrategy(ReasoningStrategy):
+class ReActStrategy(ReasoningStrategy):
     def __init__(self, config: ReasoningConfig, display: Callable):
         super().__init__(config=config, display=display)
         print("Creating reAct strategy with config: ",)
@@ -29,18 +29,18 @@ class ReactStrategy(ReasoningStrategy):
                 description="Lookup a term in the docstore.",
             )
         ]
-        react = initialize_agent(tools, self.llm, agent="react-docstore", verbose=True)
+        re_act = initialize_agent(tools, self.llm, agent="react-docstore", verbose=True)
         agent_executor = AgentExecutor.from_agent_and_tools(
-            agent=react.agent,
+            agent=re_act.agent,
             tools=tools,
             verbose=True,
         )
-        response_react = agent_executor.run(question)
-        print(response_react)
-        self.display(response_react)
-        return response_react
+        response_re_act = agent_executor.run(question)
+        print(response_re_act)
+        self.display(response_re_act)
+        return response_re_act
 
-def get_react_config(temperature: float = 0.7) -> ReasoningConfig:
+def get_re_act_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. 

{src → modules}/reasoning/reasoning_router.py

@@ -1,5 +1,5 @@
 from langchain import PromptTemplate, LLMChain
-from .react import ReactStrategy, get_react_config
+from .re_act import ReActStrategy, get_re_act_config
 from .tree_of_thought import TreeOfThoughtStrategy, get_tot_config
 from .chain_of_thought import ChainOfThoughtStrategy, get_cot_confg
 from .reasoning_strategy import ReasoningConfig
@@ -28,7 +28,7 @@ class ReasoningRouter:
 
 
         self.strategies = {
-            1: ReactStrategy(get_react_config(temperature=config.temperature), display=self.display),
+            1: ReActStrategy(get_re_act_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)
         }

server.py

@@ -0,0 +1,24 @@
+from dotenv import load_dotenv, find_dotenv
+import os
+import gradio as gr
+from modules.reasoning.component import create_reasoning_router_ui
+load_dotenv(find_dotenv())
+
+openai_api_key = os.getenv("OPENAI_API_KEY")
+
+
+
+def create_interface():
+    title: str = "Prompt Strategy Demo"
+    description: str = "AI Agents Sandbox"
+    with gr.Blocks(analytics_enabled=False, capture_session=True, title=title, description=description) as interface:
+        with gr.Tab("Reasoning Router"):
+            create_reasoning_router_ui()
+        with gr.Tab("Knowledge Domains"):
+            gr.Label("Knowledge Domains")
+    interface.queue()
+    interface.launch(server_name="0.0.0.0", server_port=7000)
+
+
+if __name__ == "__main__":
+    create_interface()

src/main.py

@@ -1,26 +0,0 @@
-from dotenv import load_dotenv, find_dotenv
-import os
-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 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
-
-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__":
-    iface.launch(server_name="0.0.0.0", server_port=7000)

src/streamlit_main.py

@@ -1,30 +0,0 @@
-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()
-