init commit

.gitattributes

@@ -1,35 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/socrates-avatar.jpg filter=lfs diff=lfs merge=lfs -text
+assets/theatetus-avatar.png filter=lfs diff=lfs merge=lfs -text
+assets/agent-avatar.jpg filter=lfs diff=lfs merge=lfs -text
+assets/intro-trio.jpg filter=lfs diff=lfs merge=lfs -text
+assets/plato-avatar.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# 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
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# flask
+flask_session
+*.log
+datasets/
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .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
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__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
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+.streamlit/secrets.toml

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[theme]
+base="light"
+font="sans serif"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Runzhe Yang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -10,4 +10,33 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Socratiq
+
+Socratiq is an application that utilizes OpenAI's GPT model to simulate a Socratic dialogue. Inspired by the SocraticAI project by Princeton NLP, it aims to facilitate an interactive learning environment where the user can explore complex questions through an engaging, back-and-forth conversation.
+Many thanks to Runzhe Yang and Karthik Narasimhan for their insightful article https://princeton-nlp.github.io/SocraticAI/.
+
+## Features
+
+- **Interactive Dialogue**: Engage with the AI in a conversational format, where the AI plays the roles of Socrates, Theaetetus, and Plato, thus bringing a multi-perspective approach to problem-solving.
+
+- **Session Management**: The application maintains the state of your conversation across the session, allowing the dialogue to unfold naturally.
+
+- **User-friendly Interface**: Built with Streamlit, the application provides a clean and straightforward interface for user interactions.
+
+## Setup
+
+1. Clone the repository.
+2. Install the necessary dependencies using `pip install -r requirements.txt`.
+3. Run the app locally using `streamlit run app.py`.
+4. Put your OpenAI, Crawling and Metaphor API keys in .streamlit/secrets.toml file.
+
+## Usage
+
+After setting up the application, you can start asking questions to the AI. The AI, acting as Socrates, Theaetetus, and Plato, will collaboratively attempt to answer your questions, ask clarifying queries, or provide deeper insights.
+
+Please note that this is a conversational AI, and the quality of the responses will depend on the capabilities of the underlying GPT-3/GPT-4 models.
+
+## Limitations and Disclaimer
+
+While the application aims to provide informative and engaging dialogues, it's important to note that the AI's responses are generated based on pre-existing knowledge and may not always reflect the most current or accurate information. Always cross-check critical information with other sources.
+

agent.py

@@ -0,0 +1,30 @@
+from langchain.agents import OpenAIFunctionsAgent
+from langchain.schema import SystemMessage
+from langchain.agents import AgentExecutor
+from langchain.tools.base import ToolException
+
+
+class Agent:
+    def __init__(self, llm, tools, max_iterations=15):
+        for tool in tools:
+            def _handle_error(error: ToolException) -> str:
+                return (
+                        f"The following errors occurred during tool '{tool.name}' execution:"
+                        + error.args[0]
+                        + "Please try another tool."
+                )
+
+            tool.handle_tool_error = _handle_error
+        self._tools = tools
+        system_message = SystemMessage(
+            content="You are a web researcher who uses search engines to look up information.")
+        prompt = OpenAIFunctionsAgent.create_prompt(system_message=system_message)
+        agent = OpenAIFunctionsAgent(llm=llm, tools=tools, prompt=prompt)
+        self.agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=max_iterations)
+
+    def run(self, query):
+        try:
+            return self.agent_executor.run(query)
+        except Exception as e:
+            msg = f"Agent encounter an error.\n\n Error: {str(e)}"
+            return msg

app.py

@@ -0,0 +1,215 @@
+import streamlit as st
+from socratic import *
+from tool import get_tools
+from agent import Agent
+from common import get_llm
+import sys
+import time
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+# --- APPLICATION ---
+
+PAGE_TITLE: str = "Socratiq"
+PAGE_ICON: str = "🗨️"
+N_ROUND: int = 50
+
+st.set_page_config(page_title=PAGE_TITLE, page_icon=PAGE_ICON)
+
+open_api_key = st.secrets["OPENAI_API_KEY"]
+st.session_state.key = open_api_key
+
+
+def init_session() -> None:
+    tools = get_tools()
+    st.session_state.agent = Agent(get_llm(model_name='gpt-4', model_temperature=0, api_key=st.session_state.key),
+                                   tools)
+    st.session_state.socrates = SocraticGPT(role=SOCRATES, tools=st.session_state.agent._tools,
+                                            key=st.session_state.key, n_round=N_ROUND)
+    st.session_state.theaetetus = SocraticGPT(role=THEAETETUS, tools=st.session_state.agent._tools,
+                                              key=st.session_state.key, n_round=N_ROUND)
+    st.session_state.plato = SocraticGPT(role=PLATO, tools=st.session_state.agent._tools, key=st.session_state.key,
+                                         n_round=N_ROUND, model="gpt-4")
+    st.session_state.dialog_lead = None
+    st.session_state.dialog_follower = None
+    st.session_state.messages = []
+    st.session_state.question = None
+    st.session_state.user_input = None
+    st.session_state.in_progress = False
+    st.session_state.user_question = None
+
+
+def get_random_question():
+    return "What is the size of the Moon?"
+
+
+def show_intro_screen():
+    st.header("Socratiq")
+    st.image("./assets/intro-trio.jpg")
+    description = """\
+        You ask, 'What's the meaning of life?' and our trio of digital philosophers fetch real-time 
+        wisdom faster than you can say 'Immanuel Kant.' Whether you’re curious about science, or even the nuances of 
+        modern art, Soratiq has you covered. Your feedback shapes the conversation, making it an educational journey 
+        tailored just for you. So why settle for small talk? Dive into Soratiq today and elevate your discourse!
+    """
+    st.caption(description)
+    st.divider()
+
+    if st.session_state.question is None:
+        question = st.text_input(label='Paste your question. E.g. "What is the size of the moon?"',
+                                label_visibility='collapsed',
+                                placeholder='Paste your question. E.g. "What is the size of the moon?"')
+        col1, _, _, _, col2 = st.columns(5)
+        if col1.button(label="Ask Away!", help="Push the button and dive into the dialog around your question..."):
+            if not len(question) > 0:
+                st.warning(
+                    "Whoops! That question seems to be doing the vanishing act. Could you give it another shot? Magic words: 'Valid question, Please!' 🪄")
+        if len(question) > 0:
+            set_user_question(question)
+
+        if col2.button(label="QuestionRoll", help="The button generates a random question for the user to ponder or discuss. This should be a fun and engaging experience, sparking curiosity."):
+            question = get_random_question()
+            set_user_question(question)
+    else:
+        if st.session_state.question is not None:
+            st.subheader(f"*{st.session_state.question}*")
+        st.divider()
+
+
+
+def set_user_question(question):
+    st.session_state.question = question
+    st.session_state.socrates.set_question(question)
+    st.session_state.theaetetus.set_question(question)
+    st.session_state.plato.set_question(question)
+    st.experimental_rerun()
+
+
+if 'question' not in st.session_state:
+    init_session()
+
+def get_avatar(role):
+    if role == SOCRATES:
+        return "./assets/socrates-avatar.jpg"
+    elif role == THEAETETUS:
+        return "./assets/theatetus-avatar.png"
+    elif role == PLATO:
+        return "./assets/plato-avatar.jpg"
+    elif role == 'agent':
+        return "ai"
+    elif role == 'system':
+        return "./assets/agent-avatar.jpg"
+    elif role == 'user':
+        return "user"
+
+def get_role(role):
+    if role == 'agent':
+        return 'ai'
+    elif role == 'system':
+        return 'ai'
+    else:
+        return 'user'
+
+def show_chat() -> None:
+    if st.session_state.messages:
+        for message in st.session_state.messages:
+            role = message['role']
+            content = message['content']
+            with st.chat_message(get_role(role), avatar=get_avatar(role)):
+                if role == 'system':
+                    st.markdown("*" + content + "*")
+                else:
+                    st.markdown(content)
+
+
+def add_message(role, content):
+    st.session_state.messages.append({"role": role, "content": content})
+    with st.chat_message(get_role(role), avatar=get_avatar(role)):
+        st.markdown(content)
+
+
+def chat_input():
+    if st.session_state.user_question is not None:
+        prompt = st.chat_input("Share your wisdom...")
+        if prompt:
+            st.session_state.user_input = prompt
+    elif st.session_state.question is not None:
+        st.chat_input("...", disabled=True)
+
+def main() -> None:
+    show_intro_screen()
+    chat_input()
+    show_chat()
+
+    if st.session_state.question is not None and st.session_state.user_question is None:
+        if not st.session_state.in_progress:
+            st.session_state.in_progress = True
+            st.session_state.dialog_lead, st.session_state.dialog_follower = st.session_state.socrates, st.session_state.theaetetus
+            # add_message(st.session_state.dialog_lead.role,
+            #             f"""Hi {st.session_state.dialog_follower.role}, let's solve this problem together. Please feel free to correct me if I make any logical or mathematical mistakes.\n""")
+        else:
+            with st.spinner(f"{st.session_state.dialog_follower.role} is thinking..."):
+                rep = st.session_state.dialog_follower.get_response()
+            add_message(st.session_state.dialog_follower.role, f"{st.session_state.dialog_follower.role}: " + rep)
+            st.session_state.dialog_lead.update_history(rep)
+            st.session_state.plato.update_history(f"{st.session_state.dialog_follower.role}: " + rep)
+
+            # next round the opponent answers
+            st.session_state.dialog_lead, st.session_state.dialog_follower = st.session_state.dialog_follower, st.session_state.dialog_lead
+
+            answer = SocraticGPT.get_answer(rep)
+            user_question = SocraticGPT.get_user_question(rep)
+            agent_question = SocraticGPT.get_agent_question(rep)
+
+            if st.session_state.dialog_lead.role == st.session_state.theaetetus.role:
+                if user_question is None and agent_question is None and answer is None:
+                    with st.spinner(f"thinking critically..."):
+                        pr = st.session_state.plato.get_proofread()
+                    if pr:
+                        add_message(st.session_state.plato.role, f"{st.session_state.plato.role}: " + pr)
+                        st.session_state.socrates.add_proofread(pr)
+                        st.session_state.theaetetus.add_proofread(pr)
+                        user_question = SocraticGPT.get_user_question(pr) # Plato can suggest to use agent or get user feedback
+                        agent_question = SocraticGPT.get_agent_question(pr)
+
+            if agent_question:
+                with st.status(f"Consulting the agent: ''' {agent_question} '''"):
+                    agent_msg = st.session_state.agent.run(agent_question) # TODO: agent status callback or status polling in a loop
+                st.session_state.socrates.add_agent_feedback(agent_question, agent_msg)
+                st.session_state.theaetetus.add_agent_feedback(agent_question, agent_msg)
+                st.session_state.plato.add_agent_feedback(agent_question, agent_msg)
+                add_message('agent', f"Agent: {agent_msg}")
+
+            if user_question:
+                st.session_state.user_question = user_question
+                add_message('system', f'User feedback is required. The question: **"{" ".join(user_question)}"**')
+                st.experimental_rerun()
+
+            if answer:
+                st.session_state.user_question = f"Is that correct answer? - {answer}"
+                add_message('system', f"""User, are you agree with the answer? - **{" ".join(answer)}**""")
+                st.experimental_rerun()
+
+    if st.session_state.user_input is not None:
+        user_input = st.session_state.user_input
+        if st.session_state.user_question is not None:
+            user_question = st.session_state.user_question
+            st.session_state.socrates.add_user_feedback(user_question, user_input)
+            st.session_state.theaetetus.add_user_feedback(user_question, user_input)
+            st.session_state.plato.add_user_feedback(user_question, user_input)
+            st.session_state.user_question = None
+            add_message("user", f"{user_input}")
+
+        st.session_state.user_input = None
+
+    if st.session_state.question is not None and st.session_state.user_question is None:
+        time.sleep(1)
+        st.experimental_rerun()
+
+
+if __name__ == "__main__":
+    main()
+
+
+# TODO: publish/access dialog debug logs, so the user can dig into the details
+# TODO: possible answers to the question - like 'double check your answer' or 'make the answer sound like a pirate' etc

common.py

@@ -0,0 +1,10 @@
+from langchain.chat_models import ChatOpenAI
+from langchain.llms import OpenAI
+
+def get_llm(model_name, model_temperature, api_key, max_tokens=None):
+    if model_name == "text-davinci-003":
+        return OpenAI(temperature=model_temperature, model_name=model_name, max_tokens=max_tokens,
+                      openai_api_key=api_key)
+    else:
+        return ChatOpenAI(temperature=model_temperature, model_name=model_name, max_tokens=max_tokens,
+                          openai_api_key=api_key)

requirements.txt

@@ -0,0 +1,6 @@
+openai~=0.27.10
+streamlit~=1.26.0
+langchain~=0.0.285
+metaphor-python~=0.1.16
+wikipedia~=1.4.0
+crawlbase~=1.0.0

socratic.py

@@ -0,0 +1,156 @@
+from langchain.schema import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage
+)
+from common import get_llm
+import logging
+import re
+
+SOCRATES = "Socrates"
+THEAETETUS = "Theaetetus"
+PLATO = "Plato"
+class SocraticGPT:
+    def __init__(self, role, tools, key, n_round=10, model="gpt-3.5-turbo-16k"):
+        self.role = role
+        self.model = model
+        self.n_round = n_round
+        self.tools = tools
+        self.key = key
+
+        if self.role == SOCRATES:
+            self.other_role = THEAETETUS
+        elif self.role == THEAETETUS:
+            self.other_role = SOCRATES
+
+        self.history = []
+
+    def set_question(self, question):
+        instruction_prompt = \
+            f"""
+            {SOCRATES} and {THEAETETUS} are two advanced AI assistants to solve challenging problems. {SOCRATES} and {THEAETETUS} will engage in multi-round dialogue to solve the problem together. There also another participant {PLATO}, who is acting like a proofreader providing valuable advices. {SOCRATES} and {THEAETETUS} have to listen and follow the advice. 
+            Their discussion should follow a structured problem-solving approach, such as formalizing the problem, developing high-level strategies for solving the problem, using Agents if necessary, reusing sub-problem solutions where possible, critically evaluating each other's reasoning, avoiding arithmetic and logical errors, and effectively communicating their ideas.  
+            
+            They are permitted to consult with the user if they encounter any uncertainties or difficulties. Any responses from user will be provided in the following round. If the main question is not clear they have to seek advise from the user.
+            To ask the user use following phrase: <user>insert your question</user>. 
+            
+            There is an agent available for usage. agent is also an advanced AI, which can perform a comprehensive web search, information extration from web urls and navigate the Internet. The request to agent must mention your goal and what you want to achieve. Request must contain all the required information. The agent does not know about you dialog or memory of the previous requests, it only performs requested actions. To avoid rate limits, try to break down the request into smaller parts to gather the necessary information.
+            To call the agent use following phrase: <agent>insert your request</agent>.  
+
+            Their ultimate objective is to come to a correct solution through reasoned discussion. To present their final answer, they should adhere to the following guidelines:
+            - State the problem they were asked to solve.
+            - Present any assumptions they made in their reasoning.
+            - Detail the logical steps they took to arrive at their final answer.
+            - Use the agent to perform specific operations.
+            - Asses critically your way of thinking. Apply critical thinking.
+            - Conclude with a final statement that directly answers the problem.
+
+            Their final answer should be concise and free from logical errors, such as false dichotomy, hasty generalization, and circular reasoning.
+            Immediately provide the answer if nobody has objections to the solution. If they encounter any issues with the validity of their answer, they should re-evaluate their reasoning and calculations. Before providing the final answer, every participant has to accept the solution or reject it with a clear explaination. Do not provide the answer if someone has reasonable objections to it. 
+            The final answer should begin with the phrase: <answer>insert your answer</answer>.  
+
+            The dialog must be formatted using Markdown.
+            
+            The problem statement is as follows: ''' {question} '''.
+            """
+
+        # print(instruction_prompt)
+
+        if self.role == SOCRATES:
+            self.history.append(SystemMessage(
+                content=instruction_prompt + f"\nNow, suppose that you are {self.role}. Please discuss the problem with {self.other_role}!"))
+            self.history.append(AIMessage(
+                content=f"Hi {THEAETETUS}, let's solve this problem together. Please feel free to correct me if I make any mistakes."
+            ))
+        elif self.role == THEAETETUS:
+            self.history.append(SystemMessage(
+                content=instruction_prompt + f"\nNow, suppose that you are {self.role}. Please discuss the problem with {self.other_role}!"))
+            self.history.append(HumanMessage(
+                content=f"Hi {THEAETETUS}, let's solve this problem together. Please feel free to correct me if I make any mistakes."
+            ))
+        elif self.role == PLATO:
+            self.history.append(SystemMessage(
+                content=instruction_prompt + f"\nNow as a proofreader, {PLATO}, your task is to read through the dialogue between {SOCRATES} and {THEAETETUS} and identify any errors they made."))
+            self.history.append(HumanMessage(
+                content=f"{SOCRATES}: Hi {THEAETETUS}, let's solve this problem together. Please feel free to correct me if I make any mistakes."
+            ))
+
+    def get_response(self, temperature=0):
+        msg = self._call_llm(self.history, temperature)
+        logging.debug(f"response: {self.role} : {msg}")
+        self.history.append(AIMessage(content=msg))
+        return msg
+
+    def get_proofread(self, temperature=0, history_depth=7):
+        pf_template = HumanMessage(
+            content=f""" \
+                        The above is the conversation between {SOCRATES} and {THEAETETUS} and the agent. They were likely to have made multiple mistakes or not follow guidelines or try inefficient way to solve the problem or incorrectly use the agent. 
+                        Asses critically the dialog above. Also asses critically the agent's answers. Explain your reasoning step by step. Be concise. Start your answer with "NO" if you have no reasonable suggestions for improvements, do not say "NO" otherwise.
+                    """
+        )
+        # OpenAI token rate limiting prevent the model from answering - we are limiting the history
+        history = [self.history[0]] + self.history[-history_depth:] if len(self.history) > history_depth else self.history
+        msg = self._call_llm(history + [pf_template], temperature)
+        logging.debug(f"proofread: {self.role} : {msg}")
+        if msg[:2] in ["NO", "No", "no"]:
+            return None
+        else:
+            pattern = r'^YES\s*\n*'
+            msg = re.sub(pattern, '', msg)
+            self.history.append(AIMessage(content=f"Message from a proofreader {PLATO}: {msg}"))
+            return msg
+
+    def _call_llm(self, messages, temperature=0):
+        try:
+            llm = get_llm(model_name=self.model, model_temperature=temperature, api_key=self.key)
+            response = llm(messages)
+            msg = response.content
+        except Exception as e:
+            if "maximum context length" in str(e):
+                # Handle the maximum context length error here
+                msg = "The context length exceeds my limit... "
+            else:
+                # Handle other errors here
+                msg = f"I encounter an error when using my backend model.\n\n Error: {str(e)}"
+        return msg
+
+    def update_history(self, message):
+        self.history.append(HumanMessage(content=message))
+
+    def add_agent_feedback(self, question, answer):
+        self.history.append(AIMessage(content=f"Agents's feedback to \"{question}\" is \"{answer}\""))
+
+    def add_user_feedback(self, question, answer):
+        self.history.append(SystemMessage(content=f"User's feedback to \"{question}\" is \"{answer}\""))
+
+    def add_proofread(self, proofread):
+        self.history.append(SystemMessage(content=f"{PLATO}: Message from a proofreader: {proofread}"))
+
+    @staticmethod
+    def get_question(text, pattern):
+        matches = re.findall(pattern, text, re.DOTALL)
+
+        if len(matches) == 0:
+            return None
+
+        return matches
+
+    def get_user_question(text):
+        pattern = r"<user>(.*?)</user>"
+        return SocraticGPT.get_question(text, pattern)
+
+    @staticmethod
+    def get_agent_question(text):
+        pattern = r"<agent>(.*?)</agent>"
+        return SocraticGPT.get_question(text, pattern)
+
+    @staticmethod
+    def get_answer(text):
+        pattern = r"<answer>(.*?)</answer>"
+        return SocraticGPT.get_question(text, pattern)
+
+
+
+
+
+

tool.py

@@ -0,0 +1,76 @@
+from metaphor_python import Metaphor
+from langchain.agents import tool
+from typing import List, Optional
+from langchain.tools.base import ToolException
+from langchain.tools import WikipediaQueryRun
+from langchain.utilities import WikipediaAPIWrapper
+from crawlbase import CrawlingAPI
+import streamlit as st
+
+
+client = Metaphor(api_key=st.secrets["METAPHOR_API_KEY"])
+
+@tool
+def search(query: str, num_results: Optional[int] = None, include_domains: Optional[List[str]] = None, exclude_domains: Optional[List[str]] = None):
+    """Call search engine with a query """
+    try:
+        result = client.search(query, use_autoprompt=True, num_results=num_results, include_domains=include_domains, exclude_domains=exclude_domains)
+        if "I'm sorry" in result.autoprompt_string:
+            raise Exception(result.autoprompt_string)
+        return result
+    except Exception as e:
+        raise ToolException(e.args[0])
+
+
+@tool
+def get_contents(ids: List[str]):
+    """Get contents of a webpage. May return an empty content, it means you have to use another tool to get the content.
+
+    The ids passed in should be a list of ids as fetched from `search`.
+    """
+    try:
+        return client.get_contents(ids)
+    except Exception as e:
+        raise ToolException(e.args[0])
+
+
+@tool
+def find_similar(url: str, num_results: Optional[int] = None, include_domains: Optional[List[str]] = None, exclude_domains: Optional[List[str]] = None):
+    """Get search results similar to a given URL.
+
+    The url passed in should be a URL returned from `search`
+    """
+    try:
+        return client.find_similar(url, num_results=num_results, include_domains=include_domains, exclude_domains=exclude_domains)
+    except Exception as e:
+        raise ToolException(e.args[0])
+
+
+crawling_api_key = st.secrets["CRAWLING_API_KEY"]
+api = CrawlingAPI({'token': crawling_api_key})
+
+
+@tool
+def scrape_page(url: str):
+    """Get content of a given URL to process by an agent. in a json format like: dict_keys(['alert', 'title', 'favicon', 'meta', 'content', 'canonical', 'images', 'grouped_images', 'og_images', 'links'])
+    """
+    response = api.get(url, options={'format': 'json', 'autoparse': 'true', 'scroll': 'true'})
+    content = response['json']
+    return content
+
+
+#TODO: list attibutes to return directly like content_type=['alert', 'title', 'favicon', 'meta', 'content', 'canonical', 'images', 'grouped_images', 'og_images', 'links']]
+@tool(return_direct=True)
+def scrape_page_and_return_the_content_directly(url: str):
+    """Use this tool to directly get content of a given URL without processing it. in a json format like: dict_keys(['alert', 'title', 'favicon', 'meta', 'content', 'canonical', 'images', 'grouped_images', 'og_images', 'links'])
+    """
+    response = api.get(url, options={'format': 'json', 'autoparse': 'true', 'scroll': 'true'})
+    content = response['json']
+    return content
+
+
+def get_tools():
+    wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+    wikipedia.description = wikipedia.description + " Prioritise this tool if you want to learn about facts."
+    return [scrape_page, search, get_contents, find_similar, wikipedia, scrape_page_and_return_the_content_directly]
+    # return [scrape_page]