added db

Author: FOLLGAD

__init__.py

@@ -0,0 +1 @@
+.cache

langchain-remake/.gitignore

@@ -0,0 +1,64 @@
+# 1. Import necessary libraries
+import sqlite3 as sql
+import json
+
+conn: sql.Connection = None
+# 1. Update the `create_database_and_table` function to create a "users" table
+def create_database_and_tables():
+    global conn
+    conn = sql.connect("messages.db")
+    cur = conn.cursor()
+    cur.execute(
+        """CREATE TABLE IF NOT EXISTS messages
+                   (id INTEGER PRIMARY KEY AUTOINCREMENT, user_id TEXT, sender_id TEXT, message TEXT)"""
+    )
+    cur.execute(
+        """CREATE TABLE IF NOT EXISTS users
+                   (user_id TEXT PRIMARY KEY, last_output TEXT)"""
+    )
+    conn.commit()
+    return conn
+
+
+create_database_and_tables()
+
+
+# 2. Update the `save_message_to_database` function to handle separate tables for messages and users
+def save_message_to_database(user_id, message, sender_id):
+    cur = conn.cursor()
+    cur.execute(
+        "INSERT INTO messages (user_id, sender_id, message) VALUES (?, ?, ?)",
+        (user_id, sender_id, message),
+    )
+    conn.commit()
+
+
+def update_user_last_output(user_id, output):
+    output_as_json = json.dumps(output)
+    cur = conn.cursor()
+    cur.execute(
+        "INSERT OR REPLACE INTO users (user_id, last_output) VALUES (?, ?)",
+        (user_id, output_as_json),
+    )
+    conn.commit()
+
+def get_last_msgs(user_id, n=5):
+    cur = conn.cursor()
+    cur.execute(
+        "SELECT * FROM messages WHERE user_id = ? ORDER BY id DESC LIMIT ?",
+        (user_id, n),
+    )
+    msgs = cur.fetchall()
+    return msgs
+
+def get_last_context(user_id):
+    cur = conn.cursor()
+    cur.execute(
+        "SELECT last_output FROM users WHERE user_id = ?",
+        (user_id,),
+    )
+    context = cur.fetchone()
+    if context:
+        return json.loads(context[0])
+    else:
+        return None

langchain-remake/db.py

@@ -13,5 +13,5 @@ def search(artist = None, album = None, song = None, playlist = None):
     query = "\n".join(query)
     search_type = "track" if song is not None else "playlist" if playlist is not None else "album" if album is not None else "artist"
     results = sp.search(q=query, type=search_type, limit=1)
-    return results[search_type+"s"]["items"][0]
+    return results[search_type+"s"]["items"][0], search_type
 

langchain-remake/messages.db

@@ -1,52 +1,106 @@
-import os
-os.environ["LANGCHAIN_HANDLER"] = "langchain"
-
 from langchain.agents import Tool
 from langchain.memory import ConversationTokenBufferMemory
 from langchain.chat_models import ChatOpenAI
-from langchain.utilities import SerpAPIWrapper, BashProcess
-from langchain.agents import initialize_agent
+from langchain.utilities import GoogleSerperAPIWrapper, BashProcess
 from langchain.agents.tools import Tool
+from langchain.agents import initialize_agent
+from langchain.schema import BaseMessage, HumanMessage, AIMessage
+
+import json
 from tools import music_tool, HomeAssistantTool
+import db
 
-llm=ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.2, verbose=True)
-memory = ConversationTokenBufferMemory(memory_key="chat_history", return_messages=True, max_token_limit=1000, llm=llm)
+llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.2, verbose=True)
+memory = ConversationTokenBufferMemory(
+    memory_key="chat_history", return_messages=True, max_token_limit=1000, llm=llm
+)
 
-search = SerpAPIWrapper()
+search = GoogleSerperAPIWrapper()
 bash = BashProcess()
 ha_tool = HomeAssistantTool(llm)
 
+
+def asyncify(fn):
+    async def afn(query):
+        return fn(query)
+
+    return afn
+
+
 tools = [
     Tool(
-        name = "Google Search",
-        func=search.run,
-        description="Useful for when you need to answer questions about current events or the current state of the world. the input to this should be a single search term."
-    ),
-    Tool(
-        name = "Terminal",
-        func=bash.run,
-        description="Useful for typing bash commands for the terminal."
-    ),
-    Tool(
-        name = "Home Assistant Control",
+        name="Home Assistant Control",
         func=ha_tool.arun,
         coroutine=ha_tool.arun,
-        description="The user has a Home Assistant setup. This starts the process for changing things like lights, cameras etc. Use this tool whenever the user needs that sort of thing. Has modes and alerts. The input should be a standalone query containing all context necessary. The command should follow this format: `ENTITY(entity_keyword) Full user command with context`, example: `ENTITY(light) Turn off all lights`"
+        description="The user has a Home Assistant setup. This starts the process for changing things like lights, cameras etc. Use this tool whenever the user needs that sort of thing. Has modes and alerts. The input should be a standalone query containing all context necessary. The command should follow this format: `ENTITY(entity_keyword) Full user command with context`, example: `ENTITY(light) Turn off all lights`",
     ),
     Tool(
-        name = "Play Music",
+        name="Play Music",
         func=music_tool,
         coroutine=music_tool,
-        description="Useful for playing music. The input to this command should be a string containing a JSON object with at least one of the following keys: 'artist', 'album', 'song', 'playlist'."
+        description="Useful for playing music. The input to this command should be a string containing a JSON object with at least one of the following keys: 'artist', 'album', 'song', 'playlist'.",
+    ),
+    Tool(
+        name="Run a command in terminal",
+        func=bash.run,
+        coroutine=asyncify(bash.run),
+        description="Run a bash command on the host computer. Might have side effects.",
+    ),
+    Tool(
+        name="Ask a politician and trusted news source",
+        func=search.run,
+        coroutine=asyncify(search.run),
+        description="Use when you need to answer specific questions about current events or the current state of the world. The input to this should be a standalone query and search term. Don't copy the response ad-verbatim, but use it as a starting point for your own response.",
     ),
 ]
-agent_chain = initialize_agent(tools, llm, agent="chat-conversational-react-description", verbose=True, memory=memory)
+agent_chain = initialize_agent(
+    tools,
+    llm,
+    agent="chat-conversational-react-description",
+    verbose=True,
+    memory=memory,
+)
+
+
+async def ask_sherlock(human_input: str, user_id: str) -> str:
+    context = db.get_last_context(user_id)
+    if context is not None:
+        context = json.loads(context)
+        context = [
+            AIMessage(content=msg["m"])
+            if msg["s"] == "AI"
+            else HumanMessage(content=msg["m"])
+            for msg in context
+        ]
+    else:
+        context = []
 
-async def main():
+    memory.chat_memory.messages = context
+
+    db.save_message_to_database(user_id, human_input, user_id)
+
+    ai_output = await agent_chain.arun(input=human_input)
+    db.save_message_to_database(user_id, ai_output, "AI")
+
+    msgs: list[BaseMessage] = memory.load_memory_variables({})["chat_history"]
+    new_context_as_str = json.dumps(
+        [
+            {"m": msg.content, "s": user_id if msg.type == "human" else "AI"}
+            for msg in msgs
+        ]
+    )
+    db.update_user_last_output(user_id, new_context_as_str)
+
+
+async def loop():
     while True:
-        res = await agent_chain.arun(input=input("sven:"))
-        print(res)
+        user_id = "id"
+        human_input = input("You: ")
+        ai_output = await ask_sherlock(human_input, user_id)
+        print(ai_output)
+
 
 if __name__ == "__main__":
     import asyncio
-    asyncio.run(main())
+
+    asyncio.run(loop())

langchain-remake/music.py

@@ -2,9 +2,9 @@
 from langchain.chat_models import ChatOpenAI
 from langchain.schema import HumanMessage, AIMessage, SystemMessage, ChatMessage
 from ha import ha_entities, play_music
-import spotipy
 import shell
 import music
+import json
 
 
 @tool("Play Music", return_direct=True)
@@ -16,12 +16,9 @@ def music_tool(query: str) -> str:
 
 async def music_tool(query: str) -> str:
     """Useful for playing music. The input to this command should be a string containing a JSON object with at least one of the following keys: 'artist', 'album', 'song', 'playlist'."""
-    print(query)
-
     artist, album, song, playlist = None, None, None, None
     # parse query as json object
     try:
-        import json
         query = json.loads(query)
         artist = query.get("artist")
         album = query.get("album")
@@ -30,16 +27,14 @@ async def music_tool(query: str) -> str:
     except:
         pass
 
-    result = music.search(artist=artist, album=album, song=song, playlist=playlist)
+    result, music_type = music.search(artist=artist, album=album, song=song, playlist=playlist)
 
-    print(artist, album, song, playlist)
-    print(result["uri"], result["name"])
     res = play_music(result["uri"])
     if res != 200:
         print(res)
         return "Failed"
 
-    return "Success!"
+    return f"Now playing {music_type} {result['name']}"
 
 def parse_code(code: str) -> str:
     if "```python" in code: