Initial commit

.gitattributes

@@ -0,0 +1,34 @@
+*.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
+*.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

.github/README.md

@@ -0,0 +1 @@
+../README-main.md

.github/workflows/sync-to-hf.yaml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://omkarenator:$HF_TOKEN@huggingface.co/spaces/AutoLLM/AutoAgents main

.gitignore

@@ -0,0 +1,28 @@
+# 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
+.DS_Store

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 AutoLLM
+
+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-main.md

@@ -0,0 +1,103 @@
+# AutoAgents
+
+<p align="center"><img src="https://raw.githubusercontent.com/AutoLLM/AutoAgents/assets/images/logo.png?raw=true" width=400/></p>
+
+Unlock complex question answering in LLMs with enhanced chain-of-thought reasoning and information-seeking capabilities.
+
+## 👉	Overview
+
+The purpose of this project is to extend LLMs ability to answer more complex questions through chain-of-thought reasoning and information-seeking actions.
+
+We are excited to release the initial version of AutoAgents, a proof-of-concept on what can be achieved with only well-written prompts. This is the initial step towards our first big milestone, releasing and open-sourcing the AutoAgents 7B model!
+ 
+Come try out our [Huggingface Space](https://huggingface.co/spaces/AutoLLM/AutoAgents)!
+
+
+
+## 🤖 The AutoAgents Project
+
+This project demonstrates LLMs capability to execute a complex user goal: understand a user's goal, generate a plan, use proper tools, and deliver a final result.
+
+For simplicity, our first attempt starts with a Web Search Agent.
+
+
+
+## 💫 How it works:
+
+<p align="left"><img src="https://raw.githubusercontent.com/AutoLLM/AutoAgents/assets/images/agent.png" width=830/></p>
+
+
+
+## 📔 Examples
+
+Ask your AutoAgent to do what a real person would do using the internet:
+
+For example:
+
+*1. Recommend a kid friendly movie that is playing at a theater near Sunnyvale. Give me the showtimes and a link to purchase the tickets*
+
+*2. What is the average age of the past three president when they took office*
+
+*3. What is the mortgage rate right now and how does that compare to the past two years*
+
+
+
+## 💁 Roadmap
+
+* ~~HuggingFace Space demo using OpenAI models~~ [LINK](https://huggingface.co/spaces/AutoLLM/AutoAgents)
+* AutoAgents [7B] Model
+  * Initial Release:
+    * Finetune and release a 7B parameter fine-tuned search model
+* AutoAgents Dataset
+  * A high-quality dataset for a diverse set of search scenarios (why quality and diversity?<sup>[1](https://arxiv.org/abs/2305.11206)</sup>)
+* Reduce Model Inference Overhead
+* Affordance Modeling <sup>[2](https://en.wikipedia.org/wiki/Affordance)</sup>
+* Extend Support to Additional Tools
+* Customizable Document Search set (e.g. personal documents)
+* Support Multi-turn Dialogue
+* Advanced Flow Control in Plan Execution
+
+We are actively developing a few interesting things, check back here or follow us on [Twitter](https://twitter.com/AutoLLM) for any new development.
+ 
+If you are interested in any other problems, feel free to shoot us an issue.
+
+
+
+## 🧭 How to use this repo?
+
+This repo contains the entire code to run the search agent from your local browser. All you need is an OpenAI API key to begin.
+
+To run the search agent locally:
+
+1. Clone the repo and change the directory
+
+  ```bash
+  git clone https://github.com/AutoLLM/AutoAgents.git
+  cd AutoAgents
+  ```
+
+2. Install the dependencies
+
+  ```bash
+  pip install -r requirements.txt
+  ```
+
+3. Install the `autoagents` package
+
+  ```bash
+  pip install -e .
+  ```
+
+4. Make sure you have your OpenAI API key set as an environment variable. Alternatively, you can also feed it through the input text-box on the sidebar.
+
+  ```bash
+  export OPENAI_API_KEY=sk-xxxxxx
+  ```
+
+5. Run the Streamlit app
+
+  ```bash
+  streamlit run autoagents/spaces/app.py
+  ```
+
+This should open a browser window where you can type your search query.

README.md

@@ -0,0 +1,13 @@
+---
+title: AutoAgents
+emoji: 🐢
+colorFrom: green
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.21.0
+python_version: 3.10.11
+app_file: autoagents/spaces/app.py
+pinned: true
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

autoagents/agents/search.py

@@ -0,0 +1,267 @@
+from typing import List, Union, Any, Optional, Dict
+import uuid
+import re
+from datetime import date
+import asyncio
+from collections import defaultdict
+import os
+
+from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser
+from langchain.prompts import StringPromptTemplate
+from langchain import LLMChain
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import AgentAction, AgentFinish
+from langchain.callbacks import get_openai_callback
+from langchain.callbacks.base import AsyncCallbackHandler
+from langchain.callbacks.manager import AsyncCallbackManager
+
+
+from autoagents.tools.tools import search_tool, note_tool, rewrite_search_query
+from autoagents.utils.logger import InteractionsLogger
+from autoagents.utils.utils import OpenAICred
+
+
+# Set up the base template
+template = """
+We are working together to satisfy the user's original goal step-by-step. Play to your strengths as an LLM.
+Make sure the plan is achievable using the
+available tools. You SHOULD directly produce a `Final Answer:` when you
+think you have good-enough information to achieve the Goal. The final answer should be descriptive should be descriptive, encompassing all relevant details..
+Today is {today}.
+
+## Goal:
+{input}
+
+If you require assistance or additional information, you should use *only* one of the following tools:
+{tools}.
+
+## Output format
+You MUST produce Output in the following format:
+
+Thought: you should always think about what to do when you think you have not achieved the Goal.
+Reasoning: reasoning
+Plan:
+- short bulleted
+- list that conveys
+- next-step plan
+Action: the action to take, should be ONE OF {tool_names}
+Action Input: the input to the Action
+Observation: the result of the Action
+... (this Thought/Reasoning/Plan/Action/Action Input/Observation can repeat N
+times until there is a Final Answer)
+Final Answer: the final answer to achieve the original Goal which can be the
+only output or when you have no Action to do next.
+
+## History
+{agent_scratchpad}
+
+Do not repeat any past actions in History, because you will not get additional information.
+If the last action is search, then you should use notepad to keep critical information.
+If you have gathered all information in your plannings to satisfy the user's original goal, then respond immediately as the Final Answer.
+"""
+
+
+# Set up a prompt template
+class CustomPromptTemplate(StringPromptTemplate):
+    # The template to use
+    template: str
+    # The list of tools available
+    tools: List[Tool]
+    ialogger: InteractionsLogger
+
+    def format(self, **kwargs) -> str:
+        # Get the intermediate steps (AgentAction, Observation tuples)
+        # Format them in a particular way
+        intermediate_steps = kwargs.pop("intermediate_steps")
+        outputs = ""
+        # Set the agent_scratchpad variable to that value
+        for action, observation in intermediate_steps[:-1]:
+            outputs += f"{action.log}\n"
+        if len(intermediate_steps) > 0:
+            action, observation = intermediate_steps[-1]
+            # self.ialogger.add_system({"action": action, "observation": observation})
+            if action.tool not in ("Search", "Notepad"):
+                raise Exception("Invalid tool requested by the model.")
+            if action.tool == "Notepad":
+                outputs += f"{action.log}\n"
+                outputs += f"Observation: {observation}\n"
+            elif action.tool == "Search":
+                current = "".join([f"{d}" for d in observation])
+                outputs += f"{action.log}\n"
+                outputs += f"Observation: {current}\n"
+
+            # Parse the output ofr the last step for the reasoning and plan
+            regex = r"Thought\s*\d*\s*:(.*?)\n(.*)"
+            match = re.search(regex, action.log, re.DOTALL)
+            thoughts = match.group(1).strip() if match else ""
+
+            regex = r"Reasoning\s*\d*\s*:(.*?)\n(.*)"
+            match = re.search(regex, action.log, re.DOTALL)
+            reasoning = match.group(1).strip() if match else ""
+
+            regex = r"Plan\s*\d*\s*:(.*?)\nAction(.*)"
+            match = re.search(regex, action.log, re.DOTALL)
+            plans = match.group(1).strip() if match else ""
+            self.ialogger.add_structured_data({"output":{"thoughts": thoughts,
+                                                         "reasoning": reasoning,
+                                                         "plans": plans,
+                                                         "action": action.tool,
+                                                         "action_input": action.tool_input,
+                                                         "raw_output":action.log},
+                                                         "observation": observation})
+        kwargs["agent_scratchpad"] = outputs
+        # Create a tools variable from the list of tools provided
+        kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
+        # Create a list of tool names for the tools provided
+        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
+        kwargs["today"] = date.today()
+        final_prompt = self.template.format(**kwargs)
+        self.ialogger.add_system({"value": final_prompt})
+        return final_prompt
+
+
+class CustomOutputParser(AgentOutputParser):
+    class Config:
+        arbitrary_types_allowed = True
+    ialogger: InteractionsLogger
+    cred: OpenAICred
+    new_action_input: Optional[str]
+
+    action_history = defaultdict(set)
+
+    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
+        self.ialogger.add_ai(llm_output)
+        # Check if agent should finish
+        if "Final Answer:" in llm_output:
+            final_answer = llm_output.split("Final Answer:")[-1].strip()
+            self.ialogger.add_structured_data({"output": {"action": "Final Answer",
+                                                          "action_input": final_answer,
+                                                          "raw_output": llm_output}})
+            return AgentFinish(
+                # Return values is generally always a dictionary with a single `output` key
+                # It is not recommended to try anything else at the moment :)
+                return_values={"output": final_answer},
+                log=llm_output,
+            )
+        # Parse out the action and action input
+        regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        match = re.search(regex, llm_output, re.DOTALL)
+        if not match:
+            raise ValueError(f"Could not parse LLM output: `{llm_output}`")
+        action = match.group(1).strip()
+        action_input = match.group(2).strip().strip('"')
+
+        if action_input in self.action_history[action]:
+            new_action_input = rewrite_search_query(action_input,
+                                                    self.action_history[action],
+                                                    cred)
+            self.ialogger.add_message({"query_rewrite": True})
+            self.new_action_input = new_action_input
+            self.action_history[action].add(new_action_input)
+            return AgentAction(tool=action, tool_input=new_action_input, log=llm_output)
+        else:
+            # Return the action and action input
+            self.action_history[action].add(action_input)
+            return AgentAction(tool=action, tool_input=action_input, log=llm_output)
+
+
+class ActionRunner:
+    def __init__(self,
+                 outputq,
+                 cred: OpenAICred,
+                 model_name: str,
+                 persist_logs: bool = False):
+        self.ialogger = InteractionsLogger(name=f"{uuid.uuid4().hex[:6]}", persist=persist_logs)
+        tools = [search_tool, note_tool]
+        prompt = CustomPromptTemplate(
+                template=template,
+                tools=tools,
+                input_variables=["input", "intermediate_steps"],
+                ialogger=self.ialogger)
+
+        output_parser = CustomOutputParser(ialogger=self.ialogger, cred=cred)
+
+        class MyCustomHandler(AsyncCallbackHandler):
+            def __init__(self):
+                pass
+
+            async def on_chain_end(self, outputs, **kwargs) -> None:
+                if "text" in outputs:
+                    await outputq.put(outputs["text"])
+
+            async def on_agent_action(
+                    self,
+                    action: AgentAction,
+                    *,
+                    run_id: uuid.UUID,
+                    parent_run_id: Optional[uuid.UUID] = None,
+                    **kwargs: Any,
+                    ) -> None:
+                if (new_action_input := output_parser.new_action_input):
+                    # Notify users
+                    await outputq.put(RuntimeWarning(f"Action Input Rewritten: {new_action_input}"))
+                    output_parser.new_action_input = None
+
+            async def on_tool_start(
+                    self,
+                    serialized: Dict[str, Any],
+                    input_str: str,
+                    *,
+                    run_id: uuid.UUID,
+                    parent_run_id: Optional[uuid.UUID] = None,
+                    **kwargs: Any,
+                    ) -> None:
+                pass
+
+            async def on_tool_end(
+                    self,
+                    output: str,
+                    *,
+                    run_id: uuid.UUID,
+                    parent_run_id: Optional[uuid.UUID] = None,
+                    **kwargs: Any,
+                    ) -> None:
+                await outputq.put(output)
+
+        handler = MyCustomHandler()
+
+        llm = ChatOpenAI(openai_api_key=cred.key,
+                         openai_organization=cred.org,
+                         temperature=0,
+                         model_name=model_name)
+        llm_chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler])
+        tool_names = [tool.name for tool in tools]
+        for tool in tools:
+            tool.callbacks = [handler]
+
+        agent = LLMSingleActionAgent(
+            llm_chain=llm_chain,
+            output_parser=output_parser,
+            stop=["\nObservation:"],
+            allowed_tools=tool_names
+        )
+        callback_manager = AsyncCallbackManager([handler])
+
+        # Finally create the Executor
+        self.agent_executor = AgentExecutor.from_agent_and_tools(agent=agent,
+                                                                 tools=tools,
+                                                                 verbose=False,
+                                                                 callback_manager=callback_manager)
+
+    async def run(self, goal: str, outputq):
+        self.ialogger.set_goal(goal)
+        try:
+            with get_openai_callback() as cb:
+                output = await self.agent_executor.arun(goal)
+                self.ialogger.add_cost({"total_tokens": cb.total_tokens,
+                                        "prompt_tokens": cb.prompt_tokens,
+                                        "completion_tokens": cb.completion_tokens,
+                                        "total_cost": cb.total_cost,
+                                        "successful_requests": cb.successful_requests})
+            self.ialogger.save()
+        except Exception as e:
+            self.ialogger.add_message({"error": str(e)})
+            self.ialogger.save()
+            await outputq.put(e)
+            return
+        return output

autoagents/spaces/app.py

@@ -0,0 +1,145 @@
+import os
+import asyncio
+import random
+from datetime import date, datetime, timezone, timedelta
+from ast import literal_eval
+
+import streamlit as st
+import openai
+
+from autoagents.utils.constants import MAIN_HEADER, MAIN_CAPTION, SAMPLE_QUESTIONS
+from autoagents.agents.search import ActionRunner
+from autoagents.utils.utils import OpenAICred
+
+async def run():
+    output_acc = ""
+    st.session_state["random"] = random.randint(0, 99)
+    if "task" not in st.session_state:
+        st.session_state.task = None
+    if "model_name" not in st.session_state:
+        st.session_state.model_name = "gpt-3.5-turbo"
+
+    st.set_page_config(
+        page_title="Search Agent",
+        page_icon="🤖",
+        layout="wide",
+        initial_sidebar_state="expanded",
+    )
+
+    st.title(MAIN_HEADER)
+    st.caption(MAIN_CAPTION)
+
+    with st.form("my_form", clear_on_submit=False):
+        st.markdown("<style> .inter { white-space: pre-line; } </style>", unsafe_allow_html=True)
+        user_input = st.text_input(
+            "You: ",
+            key="input",
+            placeholder="Ask me anything ...",
+            label_visibility="hidden",
+        )
+
+        submitted = st.form_submit_button(
+            "Search", help="Hit to submit the search query."
+        )
+
+        # Ask the user to enter their OpenAI API key
+        if (api_key := st.sidebar.text_input("OpenAI api-key", type="password")):
+            cred = OpenAICred(api_key, None)
+        else:
+            cred = OpenAICred(os.getenv("OPENAI_API_KEY"),
+                              os.getenv("OPENAI_API_ORG"))
+        with st.sidebar:
+            model_dict = {
+                "gpt-3.5-turbo": "GPT-3.5-turbo",
+                "gpt-4": "GPT-4 (Better but slower)",
+            }
+            st.radio(
+                "OpenAI model",
+                model_dict.keys(),
+                key="model_name",
+                format_func=lambda x: model_dict[x],
+            )
+
+            time_zone = str(datetime.now(timezone(timedelta(0))).astimezone().tzinfo)
+            st.markdown(f"**The system time zone is {time_zone} and the date is {date.today()}**")
+
+            st.markdown("**Example Queries:**")
+            for q in SAMPLE_QUESTIONS:
+                st.markdown(f"*{q}*")
+
+        if not cred.key:
+            st.warning(
+                "API key required to try this app. The API key is not stored in any form. [This](https://help.openai.com/en/articles/4936850-where-do-i-find-my-secret-api-key) might help."
+            )
+        else:
+            outputq = asyncio.Queue()
+            runner = ActionRunner(
+                    outputq,
+                    cred=cred,
+                    model_name=st.session_state.model_name,
+                    persist_logs=True,
+                    )  # log to HF-dataset
+
+            async def cleanup(e):
+                st.error(e)
+                await st.session_state.task
+                st.session_state.task = None
+                st.stop()
+
+            placeholder = st.empty()
+
+            if user_input and submitted:
+                if st.session_state.task is not None:
+                    with placeholder.container():
+                        st.session_state.task.cancel()
+                        st.warning("Previous search aborted", icon="⚠️")
+
+                st.session_state.task = asyncio.create_task(
+                    runner.run(user_input, outputq)
+                )
+                iterations = 0
+                with st.expander("Search Results", expanded=True):
+                    while True:
+                        with st.spinner("Wait for it..."):
+                            output = await outputq.get()
+                            placeholder.empty()
+                            if isinstance(output, Exception):
+                                if isinstance(output, openai.error.AuthenticationError):
+                                    await cleanup(f"AuthenticationError: Invalid OpenAI API key.")
+                                elif isinstance(output, openai.error.OpenAIError):
+                                    await cleanup(output)
+                                elif isinstance(output, RuntimeWarning):
+                                    st.warning(output)
+                                    continue
+                                else:
+                                    await cleanup("Something went wrong. Please try searching again.")
+                                return
+                            try:
+                                output_fmt = literal_eval(output)
+                                st.json(output_fmt, expanded=False)
+                                st.write("---")
+                                iterations += 1
+                            except:
+                                output_acc += "\n" + output
+                                st.markdown(f"<div class=\"inter\"> {output} </div>",
+                                            unsafe_allow_html=True)
+                            if iterations >= runner.agent_executor.max_iterations:
+                                await cleanup(
+                                    f"Maximum iterations ({iterations}) exceeded. You can try running the search again or try a variation of the query."
+                                )
+                                return
+                            if "Final Answer:" in output:
+                                break
+                # Found the answer
+                final_answer = await st.session_state.task
+                final_answer = final_answer.replace("$", "\$")
+                # st.success accepts md
+                st.success(final_answer, icon="✅")
+                st.balloons()
+                st.session_state.task = None
+                st.stop()
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    loop.set_debug(enabled=False)
+    loop.run_until_complete(run())

autoagents/tools/tools.py

@@ -0,0 +1,70 @@
+import os
+
+from duckpy import Client
+from langchain import PromptTemplate, OpenAI, LLMChain
+from langchain.agents import Tool
+from langchain.chat_models import ChatOpenAI
+
+from autoagents.utils.utils import OpenAICred
+
+
+MAX_SEARCH_RESULTS = 20  # Number of search results to observe at a time
+
+search_description = """ Useful for when you need to ask with search. Use direct language and be
+EXPLICIT in what you want to search.
+
+## Examples of incorrect use
+1.  Action: Search
+    Action Input: "[name of bagel shop] menu"
+
+The Action Input cannot be None or empty.
+"""
+
+notepad_description = """ Useful for when you need to note-down specific
+information for later reference. Please provide full information you want to
+note-down in the Action Input and all future prompts will remember it.
+This is the mandatory tool after using the search tool.
+Using Notepad does not always lead to a final answer.
+
+## Exampels of using notepad tool
+Action: Notepad
+Action Input: the information you want to note-down
+"""
+
+async def ddg(query: str):
+    if query is None or query.lower().strip().strip('"') == "none" or query.lower().strip().strip('"') == "null":
+        x = "The action input field is empty. Please provide a search query."
+        return [x]
+    else:
+        client = Client()
+        return client.search(query)[:MAX_SEARCH_RESULTS]
+
+
+async def notepad(x: str) -> str:
+    return f"{[x]}"
+
+
+search_tool = Tool(name="Search",
+                   func=lambda x: x,
+                   coroutine=ddg,
+                   description=search_description)
+
+note_tool = Tool(name="Notepad",
+                   func=lambda x: x,
+                   coroutine=notepad,
+                   description=notepad_description)
+
+
+def rewrite_search_query(q: str, search_history, cred: OpenAICred) -> str:
+    history_string = '\n'.join(search_history)
+    template ="""We are using the Search tool.
+                 # Previous queries:
+                 {history_string}. \n\n Rewrite query {action_input} to be
+                 different from the previous ones."""
+    llm = ChatOpenAI(temperature=0,
+                     openai_api_key=cred.key,
+                     openai_organization=cred.org)
+    prompt = PromptTemplate(template=template,
+                            input_variables=["action_input", "history_string"])
+    llm_chain = LLMChain(prompt=prompt, llm=llm)
+    return llm_chain.predict(action_input=q, history_string=history_string)

autoagents/utils/constants.py

@@ -0,0 +1,21 @@
+MAIN_HEADER = "Web Search Agent"
+
+MAIN_CAPTION = """This is a proof-of-concept search agent that reasons, plans,
+and executes web searches to collect information on your behalf.  It aims to
+resolve your question by breaking it down into step-by-step subtasks. All the
+intermediate results will be presented.
+
+*DISCLAIMER*: We are collecting search queries, so please refrain from
+providing any personal information. If you wish to avoid this, you can run the
+app locally by following the instructions on our
+[Github](https://github.com/AutoLLM/AutoAgents)."""
+
+SAMPLE_QUESTIONS = [
+    "Recommend me a movie in theater now to watch with kids.",
+    "Who is the most recent NBA MVP? Which team does he play for? What are his career stats?",
+    "Who is the head coach of AC Milan now? How long has he been coaching the team?",
+    "What is the mortgage rate right now and how does that compare to the past two years?",
+    "What is the weather like in San Francisco today? What about tomorrow?",
+    "When and where is the upcoming concert for Taylor Swift? Share a link to purchase tickets.",
+    "Find me recent studies focusing on hallucination in large language models. Provide the link to each study found.",
+]

autoagents/utils/logger.py

@@ -0,0 +1,60 @@
+import os
+import json
+from typing import Dict, Any
+import uuid
+from datetime import datetime
+import pytz
+
+import huggingface_hub
+from huggingface_hub import Repository
+
+
+class InteractionsLogger:
+    def __init__(self, name: str, persist=False):
+        self.persist = persist
+        self.counter = 0
+        self.name = name  # unique id
+        HF_TOKEN = os.environ.get("HF_TOKEN")
+        HF_DATASET_REPO_URL = os.environ.get("HF_DATASET_REPO_URL")
+        if (HF_TOKEN is not None) and (HF_DATASET_REPO_URL is not None):
+            self.repo = Repository(
+                local_dir="data", clone_from=HF_DATASET_REPO_URL, use_auth_token=HF_TOKEN
+            )
+        else:
+            self.persist = False
+
+    def set_goal(self, goal: str):
+        # Initialize two variables for saving two files (self.messages for
+        # training and self.structure_data for later use)
+        self.messages = [{"goal": goal}]
+        self.structured_data = {"goal": goal}
+
+    def add_system(self, more: Dict):
+        self.convos = [{"from": "system"} | more]
+
+    def add_ai(self, msg: str):
+        self.convos.append({"from": "ai", "value": msg})
+        self.messages.append({"id": f"{self.name}_{self.counter}", "conversations": self.convos})
+        self.counter += 1
+
+    def add_structured_data(self, data: Dict[str, Any]):
+        self.structured_data.update({f"turn_{self.counter}": data})
+
+    def add_message(self, data: Dict[str, Any]):
+        self.structured_data.update(data)
+
+    def save(self):
+        # add current datetime
+        self.add_message({"datetime": datetime.now(pytz.utc).strftime("%m/%d/%Y %H:%M:%S %Z%z")})
+        if self.persist:
+            # TODO: want to add retry in a loop?
+            self.repo.git_pull()
+            fname = uuid.uuid4().hex[:16]
+            with open(f"./data/{fname}.json", "w") as f:
+                json.dump(self.messages, f, indent=2)
+            with open(f"./data/{fname}.clean.json", "w") as f:
+                json.dump(self.structured_data, f, indent=2)
+            commit_url = self.repo.push_to_hub()
+
+    def add_cost(self, cost):
+        self.messages.append({"metrics": cost})

autoagents/utils/utils.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class OpenAICred:
+    key: str
+    org: Optional[str]

requirements.txt

@@ -0,0 +1,5 @@
+openai>=0.27.7
+langchain>=0.0.193
+duckpy
+huggingface_hub
+pytz

setup.py

@@ -0,0 +1,7 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='autoagents',
+    version='0.1.0',
+    packages=find_packages(include=['autoagents', 'autoagents.*'])
+)

test.py

@@ -0,0 +1,52 @@
+import os
+import asyncio
+from autoagents.agents.search import ActionRunner
+from langchain.callbacks import get_openai_callback
+from pprint import pprint
+import pdb
+from ast import literal_eval
+from multiprocessing import Pool, TimeoutError
+
+async def work(user_input):
+    outputq = asyncio.Queue()
+
+    API_O = os.getenv("OPENAI_API_KEY")
+    runner = ActionRunner(outputq, api_key=API_O, model_name="gpt-3.5-turbo")
+    task = asyncio.create_task(runner.run(user_input, outputq))
+
+    while True:
+        output = await outputq.get()
+        if isinstance(output, Exception):
+            print(output)
+            return
+        try:
+            pprint(literal_eval(output))
+        except:
+            print(output)
+        print("-----------------------------------------------------------")
+        if "Final Answer:" in output:
+            break
+    await task
+
+Q = [
+     "list 5 cities and their current populations where Paramore is playing this year.",
+     "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?",
+     "How many watermelons can fit in a Tesla Model S?",
+     "Recommend me some laptops suitable for UI designers under $2000. Please include brand and price."
+     "Build me a vacation plan for Rome and Milan this summer for seven days. Include place to visit and hotels to stay. ",
+     "What is the sum of ages of the wives of Barack Obama and Donald Trump?",
+     "Who is the most recent NBA MVP? Which team does he play for? What is his season stats?",
+     "What were the scores for the last three games for the Los Angeles Lakers? Provide the dates and opposing teams.",
+     "Which team won in women's volleyball in the Summer Olympics that was held in London?",
+     "Provide a summary of the latest COVID-19 research paper published. Include the title, authors and abstract.",
+     "What is the top grossing movie in theatres this week? Provide the movie title, director, and a brief synopsis of the movie's plot. Attach a review for this movie.",
+     "Recommend a bagel shop near the Strip district in Pittsburgh that offer vegan food",
+     "Who are some top researchers in the field of machine learning systems nowadays?"
+     ]
+
+def main(q):
+    asyncio.run(work(q))
+
+if __name__ == "__main__":
+    with Pool(processes=10) as pool:
+        print(pool.map(main, Q))