updating readme, some llm functions and the observation mode to be more of a data mode

Author: cagostino

README.md

@@ -4,6 +4,15 @@ Welcome to npcsh, the shell for interacting with NPCs (LLM-powered AI agents). n
 
 Additionally, npcsh introduces a new paradigm of programming for LLMs: npcsh allows users to set up NPC profiles (a la npc_profile.npc) where a user sets the primary directive of the NPC, the tools they want the NPC to use, and other properties of the NPC. NPCs can interact with each other and their primary directives and properties make these relationships explicit through jinja references.
 
+## Dependencies
+- ollama
+- python >3.10
+
+The default model is currently phi3. The user can change the model by setting the environment variable `NPCSH_MODEL` to the desired model name and to change the provider by setting the environment variable `NPCSH_PROVIDER` to the desired provider name.
+
+The provider must be one of ['ollama', 'openai', 'anthropic'] and the model must be one available from those providers.
+
+
 ## compilation
 
 Each NPC can be compiled to accomplish their primary directive and then any issues faced will be recorded and associated with the NPC so that it can reference it later through vector search. In any of the modes where a user requests input from an NPC, the NPC will include RAG search results before carrying out the request.
@@ -35,15 +44,17 @@ The LLM or specific NPC will take the user's request and try to write a command
 Use the Command NPC by typing ```/cmd <command>```. Chat with the Command NPC in spool mode by typing ```/spool cmd```.
 Use the Command NPC in the profiles of other NPCs by referencing it  like ```{{cmd}}```.
 
-### observation mode
+### Data NPC
+
+Users can create schemas for recording observations and for exploring and analyzing data.
 
-Users can create schemas for recording observations. The idea here is to more easily facilitate the recording of data for individuals in essentially any realm (e.g. recipe testing, one's own blood pressure or  weight, books read, movies watched, daily mood, etc.) without needing to use a tangled web of applications to do so. Observations can be referenced by the generic npcsh LLM shell or by specific NPCs.
-Use the Observation NPC by typing ```/obs <observation>```.
+The Data NPC will asily facilitate the recording of data for individuals in essentially any realm (e.g. recipe testing, one's own blood pressure or  weight, books read, movies watched, daily mood, etc.) without needing to use a tangled web of applications to do so. Observations can be referenced by the generic npcsh LLM shell or by specific NPCs.
+Use the Observation NPC by typing ```/data <observation>```.
 Chat with the Observation NPC in spool mode by typing ```/spool obs```.
-Use the Observation NPC in the profiles of other NPCs by referencing it like ```{{obs}}```.
+Use the Observation NPC in the profiles of other NPCs by referencing it like ```{{obs}}```. Exit by typing ```/dq```.
 
 
-### question mode
+### Question NPC
 
 The user can submit a 1-shot question to a general LLM or to a specific NPC.
 Use it like

npcsh/llm_funcs.py

@@ -3,12 +3,15 @@
 import os
 import json
 import ollama
+import sqlite3
 
-def get_ollama_conversion(messages, model):
-    # print(messages)
+npcsh_model = os.environ.get("NPCSH_MODEL", "phi3")
+npcsh_provider = os.environ.get("NPCSH_PROVIDER", "ollama")
 
+
+def get_ollama_conversation(messages, model):
     response = ollama.chat(model=model, messages=messages)
-    messages.append(response["message"])
+    messages.append(response)
     # print(response["message"])
     return messages
 
@@ -62,7 +65,7 @@ def get_claude_response(prompt, model, format=None):
     pass
 
 
-def get_llm_response(prompt, provider="ollama", model="phi3", **kwargs):
+def get_llm_response(prompt, provider=npcsh_provider, model=npcsh_model, **kwargs):
     if provider == "ollama":
         return get_ollama_response(prompt, model, **kwargs)
     elif provider == "openai":
@@ -73,6 +76,80 @@ def get_llm_response(prompt, provider="ollama", model="phi3", **kwargs):
         return "Error: Invalid provider specified."
 
 
+def execute_data_operations(query, command_history):
+    location = os.getcwd()
+    prompt = f"""
+    A user submitted this query: {query}
+    You need to generate a script using python, R, or SQL that will accomplish the user's intent.
+    
+    Respond ONLY with the procedure that should be executed.
+
+    Here are some examples:
+    {{"data_operation": "<sql query>", 'engine': 'SQL'}}
+    {{'data_operation': '<python script>', 'engine': 'PYTHON'}}
+    {{'data_operation': '<r script>', 'engine': 'R'}} 
+
+    You must reply with only ONE output.
+    """
+
+    response = get_llm_response(prompt, format="json")
+    output = response
+    command_history.add(query, [], json.dumps(output), location)
+    print(response)
+
+    if response["engine"] == "SQL":
+        db_path = os.path.expanduser("~/.npcsh_history.db")
+        query = response["data_operation"]
+        try:
+            print(f"Executing query in SQLite database: {query}")
+            with sqlite3.connect(db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(query)
+                result = cursor.fetchall()
+                for row in result:
+                    print(row)
+        except sqlite3.Error as e:
+            print(f"SQLite error: {e}")
+        except Exception as e:
+            print(f"Error executing query: {e}")
+    elif response["engine"] == "PYTHON":
+        engine = "python"
+        script = response["data_operation"]
+        try:
+            result = subprocess.run(
+                f"echo '{script}' | {engine}",
+                shell=True,
+                text=True,
+                capture_output=True,
+            )
+            if result.returncode == 0:
+                print(result.stdout)
+            else:
+                print(f"Error executing script: {result.stderr}")
+        except Exception as e:
+            print(f"Error executing script: {e}")
+    elif response["engine"] == "R":
+        engine = "Rscript"
+        script = response["data_operation"]
+        try:
+            result = subprocess.run(
+                f"echo '{script}' | {engine}",
+                shell=True,
+                text=True,
+                capture_output=True,
+            )
+            if result.returncode == 0:
+                print(result.stdout)
+            else:
+                print(f"Error executing script: {result.stderr}")
+        except Exception as e:
+            print(f"Error executing script: {e}")
+    else:
+        print("Error: Invalid engine specified.")
+
+    return response
+
+
 def execute_llm_command(command, command_history):
     max_attempts = 5
     attempt = 0

npcsh/modes.py

@@ -1,7 +1,11 @@
 # modes.py
 import os
 import subprocess
-from .llm_funcs import get_ollama_conversion
+from .llm_funcs import (
+    get_ollama_conversation,
+    get_llm_response,
+    execute_data_operations,
+)
 import sqlite3
 
 
@@ -83,36 +87,60 @@ def save_note(note, command_history):
 # enter_notes_mode()
 
 
+def initial_table_print(cursor):
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name != 'command_history'"
+    )
+    tables = cursor.fetchall()
+
+    print("\nAvailable tables:")
+    for i, table in enumerate(tables, 1):
+        print(f"{i}. {table[0]}")
+
+
 def enter_observation_mode(command_history):
     conn = command_history.conn
     cursor = command_history.cursor
 
-    print("Entering observation mode. Type '/obsq' or '/oq' to exit.")
-
+    print("Entering observation mode. Type '/dq' or to exit.")
+    n_times = 0
     while True:
         # Show available tables
-        cursor.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name != 'command_history'"
-        )
-        tables = cursor.fetchall()
+        if n_times == 0:
+            initial_table_print(cursor)
+
+            user_query = input(
+                """
+Enter a plain-text request or one using the dataframe manipulation framework of your choice. 
+    You can also have the data NPC ingest data into your database by pointing it to the right files.
+data>"""
+            )
 
-        print("\nAvailable tables:")
-        for i, table in enumerate(tables, 1):
-            print(f"{i}. {table[0]}")
-        print("n. Create new table")
-        print("d. Delete a table")
-        print("q. Exit observation mode")
+        else:
+            user_query = input(
+                """
+data>"""
+            )
+        print(user_query)
 
-        choice = input("Choose an option: ").strip().lower()
+        response = execute_data_operations(user_query, command_history)
 
-        if choice == "q" or choice == "/obsq" or choice == "/oq":
-            break
-        elif choice == "n":
-            create_new_table(cursor, conn)
-        elif choice == "d":
-            delete_table(cursor, conn)
-        elif choice.isdigit() and 1 <= int(choice) <= len(tables):
-            add_observation(cursor, conn, tables[int(choice) - 1][0])
+        answer_prompt = f"""
+
+        Here is an input from the user:
+        {user_query}
+        Here is some useful data relevant to the query:
+        {response}
+
+        Now write a query to write a final response to be delivered to the user.
+
+        Your answer must be in the format:
+        {{"response": "Your response here."}}
+
+        """
+        final_response = get_llm_response(answer_prompt, format="json")
+        print(final_response["response"])
+        n_times += 1
 
     conn.close()
     print("Exiting observation mode.")
@@ -140,7 +168,7 @@ def enter_spool_mode(command_history, inherit_last=0, model="llama3.1"):
             spool_context.append({"role": "user", "content": user_input})
 
             # Process the spool context with LLM
-            spool_context = get_ollama_conversion(spool_context, model=model)
+            spool_context = get_ollama_conversation(spool_context, model=model)
 
             command_history.add(
                 user_input, ["spool"], spool_context[-1]["content"], os.getcwd()

npcsh/npcsh.py

@@ -61,7 +61,7 @@ def execute_command(command, command_history, db_path, npc_compiler):
             output = enter_whisper_mode()
         elif command_name == "notes":
             output = enter_notes_mode(command_history)
-        elif command_name == "obs":
+        elif command_name == "data":
             print(db_path)
             output = enter_observation_mode(command_history)
         elif command_name == "cmd" or command_name == "command":
@@ -87,6 +87,9 @@ def execute_command(command, command_history, db_path, npc_compiler):
 def setup_readline():
     readline.set_history_length(1000)
     readline.parse_and_bind("set editing-mode vi")
+    readline.parse_and_bind('"\e[A": history-search-backward')
+    readline.parse_and_bind('"\e[B": history-search-forward')
+
     readline.parse_and_bind('"\C-r": reverse-search-history')
 
 

setup.py

@@ -2,20 +2,14 @@
 
 setup(
     name="npcsh",
-    version="0.1.0",
+    version="0.1.1",
     packages=find_packages(exclude=["tests*"]),
-    install_requires=[
-        'jinja2',
-        'pandas', 
-        'ollama',
-        'requests',
-        'PyYAML'
-    ],
+    install_requires=["jinja2", "pandas", "ollama", "requests", "PyYAML"],
     entry_points={
-        'console_scripts': [
-            'npcsh=npcsh.npcsh:main',
+        "console_scripts": [
+            "npcsh=npcsh.npcsh:main",
         ],
-    },    
+    },
     author="Christopher Agostino",
     author_email="cjp.agostino@example.com",
     description="A way to use npcsh",
@@ -27,4 +21,4 @@
         "License :: OSI Approved :: MIT License",
     ],
     python_requires=">=3.10",
-)
+)