Upload 13 files

app.py

@@ -0,0 +1,85 @@
+import os
+import streamlit as st
+from constants import (
+    EMBEDDING_MODEL_NAME,
+    EMBEDDING_SIZE, 
+    TODO_CHAIN_MODEL_NAME,
+    BABY_AGI_MODEL_NAME
+)
+from src.agent import run_agent
+
+st.set_page_config(page_title='AI Agent with Google Search APIs', initial_sidebar_state="auto", menu_items=None)
+st.title("AI Agent with Google Search APIs")
+
+tab1, tab2 = st.tabs(["Agent Interface", "About the App"])
+
+with tab1:
+
+    st.sidebar.title("Enter Your API Keys 🗝️")
+    open_api_key = st.sidebar.text_input(
+        "Open API Key", 
+        value=st.session_state.get('open_api_key', ''),
+        help="Get your API key from https://openai.com/",
+        type='password'
+    )
+    os.environ["OPENAI_API_KEY"] = open_api_key
+    serp_api_key = st.sidebar.text_input(
+        "Serp API Key", 
+        value=st.session_state.get('serp_api_key', ''),
+        help="Get your API key from https://serpapi.com/",
+        type='password'
+    )
+    os.environ["SERPAPI_API_KEY"] = serp_api_key
+
+
+    st.session_state['open_api_key'] = open_api_key
+    st.session_state['serp_api_key'] = serp_api_key
+
+    with st.sidebar.expander('Advanced Settings ⚙️', expanded=False):
+        st.subheader('Advanced Settings ⚙️')
+        num_iterations = st.number_input(
+            label='Max Iterations',
+            value=5,
+            min_value=2,
+            max_value=20,
+            step=1
+        )
+        baby_agi_model = st.text_input('OpenAI Model', BABY_AGI_MODEL_NAME, help='See model options here: https://platform.openai.com/docs/models/overview')
+        todo_chaining_model = st.text_input('OpenAI TODO Model', TODO_CHAIN_MODEL_NAME, help='See model options here: https://platform.openai.com/docs/models/overview')   
+        embedding_model = st.text_input('OpenAI Embedding Model', EMBEDDING_MODEL_NAME, help='See model options here: https://platform.openai.com/docs/guides/embeddings/what-are-embeddings')
+        # embedding_size = st.text_input('Embedding Model Size', EMBEDDING_SIZE, help='See model options here: https://platform.openai.com/docs/guides/embeddings/what-are-embeddings')
+
+
+    user_input = st.text_input(
+        "What do you want me to do?", 
+        key="input"
+    )
+
+    if st.button('Run Agent'):
+        if user_input != "" and (open_api_key == '' or serp_api_key == ''):
+            st.error("Please enter your API keys in the sidebar")
+        elif user_input != "":
+            run_agent(
+                user_input=user_input,
+                num_iterations=num_iterations,
+                baby_agi_model=baby_agi_model,
+                todo_chaining_model=todo_chaining_model,
+                embedding_model=embedding_model,
+                # embedding_size=embedding_size
+            )
+        
+            # Download the file using Streamlit's download_button() function
+            st.download_button(
+                label='Download Results',
+                data=open('output.txt', 'rb').read(),
+                file_name='output.txt',
+                mime='text/plain'
+            )
+with tab2:
+    st.markdown("## Demo Video")
+    st.video('https://youtu.be/mluNKqgBLaI')
+    st.markdown("## About the Application")
+    st.markdown("In the fast-paced world of technology, staying organized and efficiently managing tasks can be a daunting challenge. To address this, a groundbreaking AI-driven task management system called AI Agent has emerged, built with Python and powered by OpenAI. With its integration of advanced vector databases like Chroma and Weaviate, AI Agent offers a seamless solution for generating, prioritizing, and executing tasks with remarkable efficiency.")
+    st.markdown("At its core, AI Agent operates in an unending loop, constantly pulling tasks from a list, executing them, enhancing the outcomes, and generating new tasks based on the objective and the outcome of the previous task. This unique workflow can be broken down into four pivotal steps: Task Execution, Result Enrichment, Task Creation, and Task Prioritization. ")
+    st.markdown("One of the key strengths of AI Agent lies in its simplicity and ease of comprehension. Users can quickly grasp the system's functionalities and build upon them to customize the AI Agent to suit their specific needs. The well-documented Python codebase and clear API integration allow developers to integrate AI Agent seamlessly into existing workflows, enhancing productivity and streamlining task management processes.")
+    st.markdown("With its AI-driven approach, AI Agent not only offers enhanced task management but also provides a foundation for building intelligent systems and automating processes. By employing the power of OpenAI and advanced vector databases, AI Agent represents a significant milestone in the realm of task management, revolutionizing the way individuals and organizations approach their daily workflows.")

constants.py

@@ -0,0 +1,4 @@
+EMBEDDING_MODEL_NAME = "text-embedding-ada-002"
+EMBEDDING_SIZE = 1536
+TODO_CHAIN_MODEL_NAME = "gpt-3.5-turbo"
+BABY_AGI_MODEL_NAME = "gpt-3.5-turbo"

output.txt

@@ -0,0 +1,16 @@
+TODO list for the objective "List 10 things that happened in AI in 2023 so far. Put it in a table with links to the sources":
+1. Research and gather information on the latest developments in AI in 2023.
+2. Create a table with 10 rows and 3 columns: "Event", "Date", and "Source".
+3. Begin filling in the table with the 10 most significant events in AI in 2023 so far.
+4. For each event, include the date it occurred and a link to a reputable source that reported on it.
+5. Double-check all sources to ensure they are reliable and up-to-date.
+6. Edit and format the table to make it easy to read and visually appealing.
+7. Review the table to ensure all events are accurately represented and all sources are properly cited.
+8. Share the table with relevant stakeholders, such as colleagues or clients, as needed.
+9. Update the table as new events occur throughout the year.
+10. Continuously monitor developments in AI to ensure the table remains relevant and up-to-date.
+
+1. OpenAI releases GPT-4, the most advanced language model to date. 2. Google announces major updates to its AI-powered search algorithm. 3. Amazon introduces new AI-powered features to its Alexa virtual assistant. 4. IBM launches a new AI-powered cybersecurity platform. 5. Tesla unveils a new self-driving car system. 6. Facebook faces criticism over its use of AI algorithms. 7. Microsoft acquires a leading AI startup. 8. AI-powered medical diagnosis tools show promising results. 9. Google's DeepMind achieves a major breakthrough in protein folding prediction. 10. The use of AI in hiring practices comes under scrutiny.
+
+The plan includes researching existing methods and best practices, consulting with AI experts, developing a framework based on their recommendations, testing and refining the framework, and implementing and monitoring its effectiveness.
+

requirements.txt

@@ -0,0 +1,88 @@
+aiohttp==3.8.4
+aiosignal==1.3.1
+altair==4.2.2
+appnope==0.1.3
+asttokens==2.2.1
+async-timeout==4.0.2
+attrs==23.1.0
+backcall==0.2.0
+blinker==1.6.2
+cachetools==5.3.0
+certifi==2022.12.7
+charset-normalizer==3.1.0
+click==8.1.3
+dataclasses-json==0.5.7
+decorator==5.1.1
+entrypoints==0.4
+executing==1.2.0
+faiss-cpu==1.7.3
+frozenlist==1.3.3
+gitdb==4.0.10
+GitPython==3.1.31
+google-search-results==2.4.2
+idna==3.4
+importlib-metadata==6.6.0
+ipdb==0.13.13
+ipython==8.12.0
+jedi==0.18.2
+Jinja2==3.1.2
+jsonschema==4.17.3
+langchain==0.0.147
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+marshmallow==3.19.0
+marshmallow-enum==1.5.1
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+multidict==6.0.4
+mypy-extensions==1.0.0
+numexpr==2.8.4
+numpy==1.24.2
+openai==0.27.4
+openapi-schema-pydantic==1.2.4
+packaging==23.1
+pandas==1.5.3
+parso==0.8.3
+pexpect==4.8.0
+pickleshare==0.7.5
+Pillow==9.5.0
+prompt-toolkit==3.0.38
+protobuf==3.20.3
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyarrow==11.0.0
+pydantic==1.10.7
+pydeck==0.8.1b0
+Pygments==2.15.1
+Pympler==1.0.1
+pyrsistent==0.19.3
+python-dateutil==2.8.2
+python-decouple==3.8
+pytz==2023.3
+pytz-deprecation-shim==0.1.0.post0
+PyYAML==6.0
+regex==2023.3.23
+requests==2.28.2
+rich==13.3.4
+six==1.16.0
+smmap==5.0.0
+SQLAlchemy==1.4.47
+stack-data==0.6.2
+streamlit==1.21.0
+tenacity==8.2.2
+tiktoken==0.3.3
+toml==0.10.2
+tomli==2.0.1
+toolz==0.12.0
+tornado==6.3.1
+tqdm==4.65.0
+traitlets==5.9.0
+typing-inspect==0.8.0
+typing_extensions==4.5.0
+tzdata==2023.3
+tzlocal==4.3
+urllib3==1.26.15
+validators==0.20.0
+wcwidth==0.2.6
+yarl==1.9.1
+zipp==3.15.0

src/agent.py

@@ -0,0 +1,81 @@
+from typing import Optional
+from langchain.embeddings import OpenAIEmbeddings
+from langchain import LLMChain, PromptTemplate
+from langchain.vectorstores import FAISS
+from langchain.docstore import InMemoryDocstore
+from src.baby_agi import BabyAGI
+from langchain.agents import ZeroShotAgent, Tool
+from langchain import OpenAI, SerpAPIWrapper, LLMChain
+from constants import (
+    EMBEDDING_MODEL_NAME,
+    EMBEDDING_SIZE, 
+    TODO_CHAIN_MODEL_NAME,
+    BABY_AGI_MODEL_NAME
+)
+
+
+def run_agent(
+        user_input, 
+        num_iterations,
+        baby_agi_model=BABY_AGI_MODEL_NAME,
+        todo_chaining_model=TODO_CHAIN_MODEL_NAME,
+        embedding_model=EMBEDDING_MODEL_NAME
+    ):
+
+    # Define your embedding model
+    embeddings_model = OpenAIEmbeddings(model=embedding_model)
+    # Initialize the vectorstore as empty
+    import faiss
+
+    embedding_size = EMBEDDING_SIZE
+    index = faiss.IndexFlatL2(embedding_size)
+    vectorstore = FAISS(embeddings_model.embed_query, index, InMemoryDocstore({}), {})
+
+    todo_prompt = PromptTemplate.from_template(
+        "You are a planner who is an expert at coming up with a todo list for a given objective. Come up with a todo list for this objective: {objective}"
+    )
+    todo_chain = LLMChain(
+        llm=OpenAI(temperature=0, model_name=todo_chaining_model), 
+        prompt=todo_prompt
+    )
+    search = SerpAPIWrapper()
+    tools = [
+        Tool(
+            name="Search",
+            func=search.run,
+            description="useful for when you need to answer questions about current events",
+        ),
+        Tool(
+            name="TODO",
+            func=todo_chain.run,
+            description="useful for when you need to come up with todo lists. Input: an objective to create a todo list for. Output: a todo list for that objective. Please be very clear what the objective is!",
+        ),
+    ]
+
+    prefix = """You are an AI who performs one task based on the following objective: {objective}. Take into account these previously completed tasks: {context}."""
+    suffix = """Question: {task}
+    {agent_scratchpad}"""
+
+    prompt = ZeroShotAgent.create_prompt(
+        tools,
+        prefix=prefix,
+        suffix=suffix,
+        input_variables=["objective", "task", "context", "agent_scratchpad"],
+    )
+
+    OBJECTIVE = user_input
+    llm = OpenAI(temperature=0, model_name=baby_agi_model)
+    # Logging of LLMChains
+    verbose = False
+    # If None, will keep on going forever. Customize the number of loops you want it to go through.
+    max_iterations: Optional[int] = num_iterations
+    baby_agi = BabyAGI.from_llm(
+        prompt=prompt,
+        tools=tools,
+        llm=llm, 
+        vectorstore=vectorstore, 
+        verbose=verbose, 
+        max_iterations=max_iterations
+    )
+    if (user_input):
+        baby_agi({"objective": OBJECTIVE})

src/baby_agi.py

@@ -0,0 +1,221 @@
+from langchain.vectorstores.base import VectorStore
+from pydantic import BaseModel, Field
+from langchain.chains.base import Chain
+from collections import deque
+from typing import Dict, List, Optional, Any
+from langchain.agents import ZeroShotAgent, AgentExecutor
+from src.task_creation_chain import TaskCreationChain
+from src.task_prio_chain import TaskPrioritizationChain
+import streamlit as st
+from langchain import LLMChain
+from langchain.llms import BaseLLM
+
+# -----------------helpers
+
+def get_next_task(
+    task_creation_chain: LLMChain,
+    result: Dict,
+    task_description: str,
+    task_list: List[str],
+    objective: str,
+) -> List[Dict]:
+    """Get the next task."""
+    incomplete_tasks = ", ".join(task_list)
+    response = task_creation_chain.run(
+        result=result,
+        task_description=task_description,
+        incomplete_tasks=incomplete_tasks,
+        objective=objective,
+    )
+    new_tasks = response.split("\n")
+    return [{"task_name": task_name} for task_name in new_tasks if task_name.strip()]
+
+def prioritize_tasks(
+    task_prioritization_chain: LLMChain,
+    this_task_id: int,
+    task_list: List[Dict],
+    objective: str,
+) -> List[Dict]:
+    """Prioritize tasks."""
+    task_names = [t["task_name"] for t in task_list]
+    next_task_id = int(this_task_id) + 1
+    response = task_prioritization_chain.run(
+        task_names=task_names, next_task_id=next_task_id, objective=objective
+    )
+    new_tasks = response.split("\n")
+    prioritized_task_list = []
+    for task_string in new_tasks:
+        if not task_string.strip():
+            continue
+        task_parts = task_string.strip().split(".", 1)
+        if len(task_parts) == 2:
+            task_id = task_parts[0].strip()
+            task_name = task_parts[1].strip()
+            prioritized_task_list.append({"task_id": task_id, "task_name": task_name})
+    return prioritized_task_list
+
+def _get_top_tasks(vectorstore, query: str, k: int) -> List[str]:
+    """Get the top k tasks based on the query."""
+    results = vectorstore.similarity_search_with_score(query, k=k)
+    if not results:
+        return []
+    sorted_results, _ = zip(*sorted(results, key=lambda x: x[1], reverse=True))
+    return [str(item.metadata["task"]) for item in sorted_results]
+
+
+def execute_task(
+    vectorstore, execution_chain: LLMChain, objective: str, task: str, k: int = 5
+) -> str:
+    """Execute a task."""
+    context = _get_top_tasks(vectorstore, query=objective, k=k)
+    return execution_chain.run(objective=objective, context=context, task=task)
+
+
+# ---------------Class-------------
+
+
+class BabyAGI(Chain, BaseModel):
+    """Controller model for the BabyAGI agent."""
+
+    task_list: deque = Field(default_factory=deque)
+    task_creation_chain: TaskCreationChain = Field(...)
+    task_prioritization_chain: TaskPrioritizationChain = Field(...)
+    execution_chain: AgentExecutor = Field(...)
+    task_id_counter: int = Field(1)
+    vectorstore: VectorStore = Field(init=False)
+    max_iterations: Optional[int] = None
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        arbitrary_types_allowed = True
+
+    def add_task(self, task: Dict):
+        self.task_list.append(task)
+
+    def print_task_list(self):
+        print("\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m\033[0m")
+        if len(self.task_list) > 1:
+            st.write('**Task List:** \n')
+        for t in self.task_list:
+            print(str(t["task_id"]) + ": " + t["task_name"])
+            if len(self.task_list) > 1:
+                st.write(str(t["task_id"]) + ": " + t["task_name"])
+
+    def print_next_task(self, task: Dict):
+        print("\033[92m\033[1m" + "\n*****NEXT TASK*****\n" + "\033[0m\033[0m")
+        print(str(task["task_name"]))
+        return (str(task["task_name"]))
+
+    def print_task_result(self, result: str):
+        print("\033[93m\033[1m" + "\n*****TASK RESULT*****\n" + "\033[0m\033[0m")
+        return(result)
+
+    @property
+    def input_keys(self) -> List[str]:
+        return ["objective"]
+
+    @property
+    def output_keys(self) -> List[str]:
+        return []
+    
+    def _call(_self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        result_list = []
+        """Run the agent."""
+        objective = inputs["objective"]
+        first_task = inputs.get("first_task", f"Make a todo list to accomplish the objective: {objective}")
+        _self.add_task({"task_id": 1, "task_name": first_task})
+        num_iters = 0
+        while True:
+            if _self.task_list:
+                _self.print_task_list()
+
+                # Step 1: Pull the first task
+                task = _self.task_list.popleft()
+                _self.print_next_task(task)
+                st.write('**Next Task:** \n')
+                st.write(_self.print_next_task(task))
+
+                # Step 2: Execute the task
+                result = execute_task(
+                    _self.vectorstore, _self.execution_chain, objective, task["task_name"]
+                )
+                this_task_id = int(task["task_id"])
+                _self.print_task_result(result)
+                st.write('**Result from Task:** \n')
+                st.write(_self.print_task_result(result))
+                result_list.append(result)
+
+                # Step 3: Store the result in Pinecone
+                result_id = f"result_{task['task_id']}"
+                _self.vectorstore.add_texts(
+                    texts=[result],
+                    metadatas=[{"task": task["task_name"]}],
+                    ids=[result_id],
+                )
+
+                # Step 4: Create new tasks and reprioritize task list
+                new_tasks = get_next_task(
+                    _self.task_creation_chain,
+                    result,
+                    task["task_name"],
+                    [t["task_name"] for t in _self.task_list],
+                    objective,
+                )
+                for new_task in new_tasks:
+                    _self.task_id_counter += 1
+                    new_task.update({"task_id": _self.task_id_counter})
+                    _self.add_task(new_task)
+                _self.task_list = deque(
+                    prioritize_tasks(
+                        _self.task_prioritization_chain,
+                        this_task_id,
+                        list(_self.task_list),
+                        objective,
+                    )
+                )
+            num_iters += 1
+            if _self.max_iterations is not None and num_iters == _self.max_iterations:
+                print(
+                    "\033[91m\033[1m" + "\n*****TASK ENDING*****\n" + "\033[0m\033[0m"
+                )
+                st.success('Task Completed!', icon="✅")
+                break
+
+        # Create a temporary file to hold the text
+        with open('output.txt', 'w') as f:
+            for item in result_list:
+                f.write(item)
+                f.write("\n\n")
+
+        return {}
+
+    @classmethod
+    def from_llm(
+        cls, 
+        prompt: str,
+        tools: list,
+        llm: BaseLLM, 
+        vectorstore: VectorStore, 
+        verbose: bool = False, 
+        **kwargs
+    ) -> "BabyAGI":
+        """Initialize the BabyAGI Controller."""
+        task_creation_chain = TaskCreationChain.from_llm(llm, verbose=verbose)
+        task_prioritization_chain = TaskPrioritizationChain.from_llm(
+            llm, verbose=verbose
+        )
+        llm_chain = LLMChain(llm=llm, prompt=prompt)
+        tool_names = [tool.name for tool in tools]
+        agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)
+        agent_executor = AgentExecutor.from_agent_and_tools(
+            agent=agent, tools=tools, verbose=True
+        )
+        return cls(
+            task_creation_chain=task_creation_chain,
+            task_prioritization_chain=task_prioritization_chain,
+            execution_chain=agent_executor,
+            vectorstore=vectorstore,
+            **kwargs,
+        )
+    

src/task_creation_chain.py

@@ -0,0 +1,30 @@
+from langchain.llms import BaseLLM
+from langchain import LLMChain, PromptTemplate
+
+
+class TaskCreationChain(LLMChain):
+    """Chain to generates tasks."""
+
+    @classmethod
+    def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
+        """Get the response parser."""
+        task_creation_template = (
+            "You are an task creation AI that uses the result of an execution agent"
+            " to create new tasks with the following objective: {objective},"
+            " The last completed task has the result: {result}."
+            " This result was based on this task description: {task_description}."
+            " These are incomplete tasks: {incomplete_tasks}."
+            " Based on the result, create new tasks to be completed"
+            " by the AI system that do not overlap with incomplete tasks."
+            " Return the tasks as an array."
+        )
+        prompt = PromptTemplate(
+            template=task_creation_template,
+            input_variables=[
+                "result",
+                "task_description",
+                "incomplete_tasks",
+                "objective",
+            ],
+        )
+        return cls(prompt=prompt, llm=llm, verbose=verbose)

src/task_prio_chain.py

@@ -0,0 +1,23 @@
+from langchain.llms import BaseLLM
+from langchain import LLMChain, PromptTemplate
+
+class TaskPrioritizationChain(LLMChain):
+    """Chain to prioritize tasks."""
+
+    @classmethod
+    def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
+        """Get the response parser."""
+        task_prioritization_template = (
+            "You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing"
+            " the following tasks: {task_names}."
+            " Consider the ultimate objective of your team: {objective}."
+            " Do not remove any tasks. Return the result as a numbered list, like:"
+            " #. First task"
+            " #. Second task"
+            " Start the task list with number {next_task_id}."
+        )
+        prompt = PromptTemplate(
+            template=task_prioritization_template,
+            input_variables=["task_names", "next_task_id", "objective"],
+        )
+        return cls(prompt=prompt, llm=llm, verbose=verbose)