feature(#23): Implement autogpt with langchain

Brain/src/rising_plugin/llm/autogpt_llm.py

@@ -0,0 +1,130 @@
+"""autogpt plugin with langchain"""
+
+from langchain.experimental import AutoGPT
+from langchain.chat_models import ChatOpenAI
+from langchain.experimental.autonomous_agents.autogpt.prompt_generator import (
+    FINISH_NAME,
+)
+from langchain.utilities import SerpAPIWrapper
+from langchain.agents import Tool
+from langchain.tools.file_management.write import WriteFileTool
+from langchain.tools.file_management.read import ReadFileTool
+from langchain.vectorstores import FAISS
+from langchain.docstore import InMemoryDocstore
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.schema import (
+    AIMessage,
+    Document,
+    HumanMessage,
+    SystemMessage,
+)
+from typing import List
+
+from marshmallow import ValidationError
+
+import faiss
+
+
+class AutoGPTLLM:
+    """autogpt run method to get the expected result"""
+
+    def run(self, agent: AutoGPT, goals: List[str]) -> str:
+        user_input = (
+            "Determine which next command to use, "
+            "and respond using the format specified above:"
+        )
+        # Interaction Loop
+        loop_count = 0
+        while True:
+            # Discontinue if continuous limit is reached
+            loop_count += 1
+
+            # Send message to AI, get response
+            assistant_reply = agent.chain.run(
+                goals=goals,
+                messages=agent.full_message_history,
+                memory=agent.memory,
+                user_input=user_input,
+            )
+
+            # Print Assistant thoughts
+            print(assistant_reply)
+            agent.full_message_history.append(HumanMessage(content=user_input))
+            agent.full_message_history.append(AIMessage(content=assistant_reply))
+
+            # Get command name and arguments
+            action = agent.output_parser.parse(assistant_reply)
+            tools = {t.name: t for t in agent.tools}
+            if action.name == FINISH_NAME:
+                return action.args["response"]
+            if action.name in tools:
+                tool = tools[action.name]
+                try:
+                    observation = tool.run(action.args)
+                except ValidationError as e:
+                    observation = (
+                        f"Validation Error in args: {str(e)}, args: {action.args}"
+                    )
+                except Exception as e:
+                    observation = (
+                        f"Error: {str(e)}, {type(e).__name__}, args: {action.args}"
+                    )
+                result = f"Command {tool.name} returned: {observation}"
+            elif action.name == "ERROR":
+                result = f"Error: {action.args}. "
+            else:
+                result = (
+                    f"Unknown command '{action.name}'. "
+                    f"Please refer to the 'COMMANDS' list for available "
+                    f"commands and only respond in the specified JSON format."
+                )
+
+            memory_to_add = (
+                f"Assistant Reply: {assistant_reply} " f"\nResult: {result} "
+            )
+            if agent.feedback_tool is not None:
+                feedback = f"\n{agent.feedback_tool.run('Input: ')}"
+                if feedback in {"q", "stop"}:
+                    print("EXITING")
+                    return "EXITING"
+                memory_to_add += feedback
+
+            agent.memory.add_documents([Document(page_content=memory_to_add)])
+            agent.full_message_history.append(SystemMessage(content=result))
+
+    """function to manage auto-task achievement
+    ex: query = write a weather report for SF today
+    """
+
+    def ask_task(self, query: str):
+        search = SerpAPIWrapper()
+        tools = [
+            Tool(
+                name="search",
+                func=search.run,
+                description="useful for when you need to answer questions about current events. You should ask targeted questions",
+            ),
+            WriteFileTool(),
+            ReadFileTool(),
+        ]
+
+        # Define your embedding model
+        embeddings_model = OpenAIEmbeddings()
+        # Initialize the vectorstore as empty
+
+        embedding_size = 1536
+        index = faiss.IndexFlatL2(embedding_size)
+        vectorstore = FAISS(
+            embeddings_model.embed_query, index, InMemoryDocstore({}), {}
+        )
+
+        agent = AutoGPT.from_llm_and_tools(
+            ai_name="Tom",
+            ai_role="Assistant",
+            tools=tools,
+            llm=ChatOpenAI(temperature=0),
+            memory=vectorstore.as_retriever(),
+        )
+        # Set verbose to be true
+        agent.chain.verbose = True
+        self.run(agent, [query])