132 smart memory management

.env.template

@@ -0,0 +1,34 @@
+# Supabase SQL
+SUPABASE_URL=
+SUPABASE_API_KEY=
+SUPABASE_READ_ONLY=
+SUPABASE_JWT_SECRET=
+
+MATERIALS_SUPABASE_TABLE=uiuc_chatbot
+NEW_NEW_NEWNEW_MATERIALS_SUPABASE_TABLE=documents
+
+# QDRANT
+QDRANT_COLLECTION_NAME=uiuc-chatbot
+DEV_QDRANT_COLLECTION_NAME=dev
+QDRANT_URL=
+QDRANT_API_KEY=
+
+REFACTORED_MATERIALS_SUPABASE_TABLE=
+
+# AWS
+S3_BUCKET_NAME=uiuc-chatbot
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+
+OPENAI_API_KEY=
+
+NOMIC_API_KEY=
+LINTRULE_SECRET=
+
+# Github Agent
+GITHUB_APP_ID=<OptionalForGithubApps>
+GITHUB_APP_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
+
+-----END RSA PRIVATE KEY-----"
+
+NUMEXPR_MAX_THREADS=2

.github/workflows/rules.yml

@@ -1,25 +0,0 @@
-name: Rules Check
-
-on:
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  rules:
-    runs-on: ubuntu-latest
-    environment: lintrule
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 2 # this part is important!
-
-      - name: Install Lint Rules
-        run: |
-          curl -fsSL https://www.lintrule.com/install.sh | bash
-
-      - name: Run Lint Rules Check
-        run: |
-          rules check --secret "${{ secrets.LINTRULE_SECRET }}"

.github/workflows/yapf-format.yml

@@ -3,21 +3,23 @@ name: Format code
 on:
   push:
     branches: [ main ]
+  pull_request:
+    branches: [ main ]
 
 jobs:
   format:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - name: pip install yapf
+        run: pip install yapf
       - name: Format code with yapf
-        run: |
-          pip install yapf
-          yapf --in-place --recursive --parallel --style='{based_on_style: google, column_limit: 140, indent_width: 2}' --exclude '*.env' .
+        run: yapf --in-place --recursive --parallel --style='{based_on_style: google, column_limit: 140, indent_width: 2}' --exclude '*.env' .
       - name: Commit changes
         uses: EndBug/add-and-commit@v4
         with:
           author_name: ${{ github.actor }}
           author_email: ${{ github.actor }}@users.noreply.github.com
-          message: "Format code with Yapf & custom options"
+          message: "Format code"
           add: "."
-          branch: ${{ github.ref }}
+          branch: ${{ github.ref }}

.gitignore

@@ -1,7 +1,7 @@
 # don't sync coursera docs
 coursera-dl/
 *parsed.json
-*wandb*
+wandb
 *.ipynb
 *.pem
 
@@ -166,3 +166,22 @@ pip-selfcheck.json
 
 # End of https://www.toptal.com/developers/gitignore/api/python
 .aider*
+
+# IDEA/Webstorm project files
+*.idea/
+*.iml
+
+#VSCode metadata
+.vscode
+.venv*
+*.env
+*.env.template
+venv*
+
+# Mac files
+.DS_Store
+
+# npm
+node_modules
+
+.rules

README.md

@@ -13,8 +13,22 @@ Automatic [API Reference](https://uiuc-chatbot.github.io/ai-ta-backend/reference
 
 ## 📣 Development
 
-- Install Python requirements `pip install -r requirements.txt`
-- Start the server for development (with live reloads) `cd ai_ta_backend` then `flask --app ai_ta_backend.main:app --debug run --port 8000`
+1. Rename `.env.template` to `.env` and fill in the required variables
+2. Install Python requirements `pip install -r requirements.txt`
+3. Start the server for development (with live reloads) `cd ai_ta_backend` then `flask --app ai_ta_backend.main:app --debug run --port 8000`
 
 The docs are auto-built and deployed to [our docs website](https://uiuc-chatbot.github.io/ai-ta-backend/) on every push. Or you can build the docs locally when writing:
 - `mkdocs serve`
+
+
+### Course metadata structure
+```
+'text': doc.page_content,
+'readable_filename': doc.metadata['readable_filename'],
+'course_name ': doc.metadata['course_name'],
+'s3_path': doc.metadata['s3_path'],
+'pagenumber': doc.metadata['pagenumber_or_timestamp'], # this is the recent breaking change!! 
+# OPTIONAL properties
+'url': doc.metadata.get('url'), # wouldn't this error out?
+'base_url': doc.metadata.get('base_url'),
+```

ai_ta_backend/agents/customcallbacks.py

@@ -0,0 +1,151 @@
+from typing import Dict, Union, Any, List
+import os
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.schema import AgentAction, AgentFinish
+from langchain.agents import AgentType, initialize_agent, load_tools
+from langchain.callbacks import tracing_enabled
+from langchain.llms import OpenAI
+from langchain import hub
+from ai_ta_backend.agents.utils import SupabaseDB, get_langsmith_id
+import marvin
+from marvin import ai_model
+from pydantic import BaseModel, Field
+
+from dotenv import load_dotenv
+load_dotenv(override=True, dotenv_path='.env')
+
+marvin.settings.openai.api_key = os.getenv('OPENAI_API_KEY')
+@ai_model
+class AgentActionParser(BaseModel):
+    log: str = Field(..., description="clean logs information from input, without new line breaks and markdowns")
+    action: str = Field(..., description="parse action field from logs")
+    action_input: str = Field(..., description="parse action input from logs")
+    action_output: str = Field(..., description="parse action output from logs")
+    tool: str = Field(..., description="any tool information from input")
+    tool_input: str = Field(..., description="any tool input")
+    tool_output: str = Field(..., description="parse tool output")
+
+class CustomCallbackHandler(BaseCallbackHandler):
+    """A callback handler that stores the LLM's context and action in memory."""
+    def __init__(self, run_id=None, image_name=None):
+        if run_id:
+            self.langsmith_run_id = run_id
+        else:
+            self.langsmith_run_id = get_langsmith_id()
+
+        if image_name:
+            self.image_name = image_name
+        else:
+            self.image_name = ''
+
+        self.tool_in_progress = {"status": False, "name": ""}
+        self.db = SupabaseDB(table_name="docker_images", image_name=self.image_name)
+
+
+    def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs: Any) -> Any:
+        """Callback for when a tool starts.
+        Set tool_in_progress to True and store the tool's name in memory."""
+        self.tool_in_progress['status'] = True
+        self.tool_in_progress['name'] = serialized['name']
+
+        if self.db.is_exists_image():
+            data = self.db.fetch_field_from_db("on_tool_start")
+            if data:
+                data.append(serialized)
+                response = self.db.update_field_in_db("on_tool_start", data)
+            else:
+                response = self.db.update_field_in_db("on_tool_start", [serialized])
+        else:
+            response = self.db.upsert_field_in_db("on_tool_start", [serialized])
+
+
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> Any:
+        """Callback for when a tool ends.
+        Use this to store the tool's output in a database. Use tool start parameters to identify the tool."""
+        if self.tool_in_progress['status']:
+            tool_name = self.tool_in_progress['name']
+            output = {"name": tool_name, "output": output}
+            # reset tool_in_progress
+            self.tool_in_progress['status'] = False
+            self.tool_in_progress['name'] = ''
+
+        if self.db.is_exists_image():
+            data = self.db.fetch_field_from_db("on_tool_end")
+            if data is not None or len(data) > 0:
+                data.append(output)
+                response = self.db.update_field_in_db("on_tool_end", data)
+            else:
+                response = self.db.update_field_in_db("on_tool_end", [output])
+        else:
+            response = self.db.upsert_field_in_db("on_tool_end", [output])
+
+
+    def on_tool_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
+        """Run when LLM errors."""
+        pass
+
+    def on_llm_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
+        """Run when LLM errors."""
+        pass
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run when LLM predicts an action. Parse the action and store it in a database."""
+        action_data = {"action": action.tool, "action_input" : action.tool_input}
+        # action = action.dict()
+        # parsed_action = AgentActionParser(action)
+        # action_data = {"log": parsed_action.log, "action": parsed_action.action, "action_input": parsed_action.action_input,
+        #                "action_output": parsed_action.action_output, "tool": parsed_action.tool,
+        #                "tool_input": parsed_action.tool_input, "tool_output": parsed_action.tool_output}
+
+        if self.db.is_exists_image():
+            data = self.db.fetch_field_from_db("on_agent_action")
+            if data is not None:
+                data.append(action_data)
+                response = self.db.update_field_in_db("on_agent_action", data)
+            else:
+                response = self.db.update_field_in_db("on_agent_action", [action_data])
+        else:
+            response = self.db.upsert_field_in_db("on_agent_action", [action_data])
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
+        """Run when LLM finishes. Store the finish in a database."""
+        finish = finish.dict()
+        finish_output = finish["return_values"]["output"]
+
+        if self.db.is_exists_image():
+            data = self.db.fetch_field_from_db("on_agent_finish")
+            if data is not None:
+                data.append(finish_output)
+                response = self.db.update_field_in_db("on_agent_finish", data)
+            else:
+                response = self.db.update_field_in_db("on_agent_finish", [finish_output])
+        else:
+            response = self.db.upsert_field_in_db("on_agent_finish", [finish_output])
+
+
+    # def agent_output():
+    # TODO
+    # missing agent output in db
+
+
+    def on_chain_start(self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any) -> Any:
+        """Callback for when a chain starts."""
+        pass
+
+
+
+if __name__ == "__main__":
+    # for testing
+    handler1 = CustomCallbackHandler()
+
+    memory_prompt = hub.pull("kastanday/memory_manager_agent")
+
+    llm = OpenAI(temperature=0, streaming=True)
+    tools = load_tools(["llm-math"], llm=llm)
+    agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
+
+    # Callbacks for handler1 will be issued by every object involved in the
+    # Agent execution (llm, llmchain, tool, agent executor)
+    agent.run("What is 2 raised to the 0.235 power?", callbacks=[handler1])

ai_ta_backend/agents/github_agent.py

@@ -117,3 +117,4 @@ def bot_runner_with_retries(self, bot: AgentExecutor, run_instruction, run_id_in
 
 if __name__ == "__main__":
   print("No code.")
+