Initial Commit

.envtemplate

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+HUGGINGFACE_API_TOKEN=

.gitignore

@@ -0,0 +1,90 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+dist/
+eggs/
+*.egg-info/
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.coverage
+.tox/
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.9
+
+WORKDIR /app
+RUN pip install streamlit
+COPY requirements.txt requirements.txt
+RUN pip install -r requirements.txt
+
+
+COPY . .
+
+WORKDIR /app/src
+
+ENV PATH="/root/.local/bin:${PATH}"
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "main.py", ]

docker-compose.yml

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

requirements.txt

@@ -0,0 +1,5 @@
+langchain
+streamlit
+python-dotenv
+openai
+wikipedia

src/main.py

@@ -0,0 +1,31 @@
+from dotenv import load_dotenv, find_dotenv
+import os
+import streamlit as st
+from reasoning import ReasoningRouter, default_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")
+
+    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()
+
+if __name__ == "__main__":
+    run_app()
+

src/reasoning/__init__.py

@@ -0,0 +1,5 @@
+from .react import ReactStrategy
+from .tree_of_thought import TreeOfThoughtStrategy
+from .chain_of_thought import ChainOfThoughtStrategy
+from .reasoning_router import ReasoningRouter, default_reasoning_router_config
+from .reasoning_strategy import ReasoningStrategy, ReasoningConfig

src/reasoning/chain_of_thought.py

@@ -0,0 +1,31 @@
+from langchain import PromptTemplate, LLMChain
+import streamlit as st
+from .reasoning_strategy import ReasoningStrategy, ReasoningConfig
+from typing import Callable
+
+class ChainOfThoughtStrategy(ReasoningStrategy):
+    def __init__(self, config: ReasoningConfig, display: Callable):
+        super().__init__(config=config, display=display)
+
+    def run(self, question):
+        print('Using Chain of Thought')
+        self.display("Using 'Chain of Thought'")
+
+        template_cot = """You are asked a question and rather than simply guessing the right answer break down the solution into a series of staps
+    The question is {question}
+
+    Write out your step by step reasoning and after considering all of the facts and applying this reasoning write out your final answer
+    """
+        prompt = PromptTemplate(template=template_cot, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=self.llm)
+        response_cot = llm_chain.run(question)
+        print(response_cot)
+        self.display(response_cot)
+
+def default_cot_confg():
+    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)

src/reasoning/react.py

@@ -0,0 +1,50 @@
+from langchain.agents import initialize_agent, Tool, AgentExecutor
+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
+
+
+class ReactStrategy(ReasoningStrategy):
+    def __init__(self, config: ReasoningConfig, display: Callable):
+        super().__init__(config=config, display=display)
+
+    def run(self, question) -> str:
+        print('Using ReAct')
+        self.display("Using 'ReAct' - (Reasoning and Action)")
+
+        docstore = DocstoreExplorer(Wikipedia())
+        tools = [
+            Tool(
+                name="Search",
+                func=docstore.search,
+                description="Search for a term in the docstore.",
+            ),
+            Tool(
+                name="Lookup",
+                func=docstore.lookup,
+                description="Lookup a term in the docstore.",
+            )
+        ]
+        react = initialize_agent(tools, self.llm, agent="react-docstore", verbose=True)
+        agent_executor = AgentExecutor.from_agent_and_tools(
+            agent=react.agent,
+            tools=tools,
+            verbose=True,
+        )
+        response_react = agent_executor.run(question)
+        print(response_react)
+        self.display(response_react)
+        return response_react
+
+def default_react_config() -> ReasoningConfig:
+    usage = """
+    The solution for this problem requires searching for further information online, 
+    generating reasoning traces and task-specific actions in an interleaved manner. 
+    Starting with incomplete information this technique will prompt for the need to get 
+    additional helpful information at each step. It allows for dynamic reasoning to create, 
+    maintain, and adjust high-level plans for acting, while also interacting with external 
+    sources to incorporate additional information into reasoning 
+    """
+    return ReasoningConfig(usage=usage)

src/reasoning/reasoning_router.py

@@ -0,0 +1,82 @@
+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 .reasoning_strategy import ReasoningConfig
+from typing import Tuple, Callable
+import re
+import os
+
+class ReasoningRouter:
+    def __init__(self, api_key: str, config: ReasoningConfig, question:str, display: Callable):
+        """
+        Initializes a ReasoningRouter instance.
+
+        Args:
+            question (str): The user's question.
+
+        Returns:
+            None
+        """
+        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)
+        }
+        self.usage_block = f"""
+
+        1. {self.strategies[1].usage} [1].
+        2. {self.strategies[2].usage} [2].
+        3. {self.strategies[3].usage} [3].
+
+        """
+        self.template = """
+    Consider the following problem or puzzle: {question}. Based on the characteristics of the problem,
+      identify the most suitable approach among the three techniques described below. consider each carefully 
+      in the context of the question, write out the likelihood of success of each, and then select the most 
+      appropriate approach:""" + self.usage_block + """
+        Based on the characteristics of the given problem or puzzle, select the technique that aligns most closely with the nature of the problem. It is important to first provide the number of the technique that best solves the problem, followed by a period. Then you may provide your reason why you have chosen this technique. 
+
+    The number of the selected technique is...
+    """
+
+    @staticmethod
+    def find_first_integer(text):
+        match = re.search(r'\d+', text)
+        if match:
+            return int(match.group())
+        else:
+            return None
+
+    def determine_and_execute(self) -> Tuple[str, str]:
+        """
+        Determines the appropriate reasoning strategy based on the user's question and executes it.
+
+        Returns:
+            None
+        """
+        
+        prompt = PromptTemplate(template=self.template, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=self.llm)
+
+        response = llm_chain.run(self.question)
+        print(response)
+        self.display(response)
+        n = self.find_first_integer(response)
+
+        if n in self.strategies:
+            strat_resp = self.strategies[n].run(self.question)
+        else:
+            strat_resp = (f"Strategy number {n} is not recognized.")
+            print(strat_resp)
+            
+        return response, strat_resp
+
+def default_reasoning_router_config() -> 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)

src/reasoning/reasoning_strategy.py

@@ -0,0 +1,37 @@
+from langchain.llms import OpenAI
+from pydantic import BaseModel
+from langchain.llms.base import BaseLLM
+from typing import Type, Callable
+import streamlit as st
+import os 
+
+
+
+class ReasoningConfig(BaseModel):
+    """
+    A class representing a reasoning strategy for answering questions.
+
+    Args:
+        config (ReasoningConfig): The configuration for the reasoning strategy.
+        display (Callable): A function for displaying output.
+
+    Attributes:
+        llm (BaseLLM): The language model used for reasoning.
+        display (Callable): The function for displaying output.
+    """
+    temperature: float = 0.7
+    max_tokens: int = 1500
+    llm_class: Type[BaseLLM] = OpenAI
+    usage: str
+
+class ReasoningStrategy:
+    def __init__(self, config: ReasoningConfig, display: Callable):
+        self.llm = config.llm_class(temperature=config.temperature, max_tokens=config.max_tokens) # ign
+        self.display = display
+        self.usage = config.usage
+    def run(self, question):
+        raise NotImplementedError()
+    
+def default_reasoning_config():
+    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

@@ -0,0 +1,44 @@
+from .reasoning_strategy import ReasoningStrategy
+from langchain import LLMChain, PromptTemplate
+from .reasoning_strategy import ReasoningStrategy, ReasoningConfig
+from typing import Callable
+
+class TreeOfThoughtStrategy(ReasoningStrategy):
+    def __init__(self, config: ReasoningConfig, display: Callable):
+        super().__init__(config=config, display=display)
+
+    def run(self, question)-> str:
+        print('Using ToT')
+        self.display("Using 'Tree of Thoughts'")
+
+        template_tot = """Imagine three different experts are answering this question.
+    They will brainstorm the answer step by step reasoning carefully and taking all facts into consideration
+    All experts will write down 1 step of their thinking,
+    then share it with the group.
+    They will each critique their response, and the all the responses of others
+    They will check their answer based on science and the laws of physics
+    Then all experts will go on to the next step and write down this step of their thinking.
+    They will keep going through steps until they reach their conclusion taking into account the thoughts of the other experts
+    If at any time they realise that there is a flaw in their logic they will backtrack to where that flaw occurred 
+    If any expert realises they're wrong at any point then they acknowledges this and start another train of thought
+    Each expert will assign a likelihood of their current assertion being correct
+    Continue until the experts agree on the single most likely answer and write out that answer along with any commentary to support that answer
+    The question is {question}
+
+    The experts reasoning, along with their final answer is...
+    """
+        prompt = PromptTemplate(template=template_tot, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=self.llm)
+        response_tot = llm_chain.run(question)
+        print(response_tot)
+        self.display(response_tot)
+        return response_tot
+
+def default_tot_config():
+    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)