fix: various breaking bugs with local LLM implementation and postgres docker.

memgpt/agent_store/db.py

@@ -1,6 +1,7 @@
 import base64
 import os
 import uuid
+from datetime import datetime
 from typing import Dict, Iterator, List, Optional
 
 import numpy as np
@@ -379,29 +380,33 @@ def list_data_sources(self):
             unique_data_sources = session.query(self.db_model.data_source).filter(*self.filters).distinct().all()
         return unique_data_sources
 
-    def query_date(self, start_date, end_date, offset=0, limit=None):
+    def query_date(self, start_date, end_date, limit=None, offset=0):
         filters = self.get_filters({})
         with self.session_maker() as session:
             query = (
                 session.query(self.db_model)
                 .filter(*filters)
                 .filter(self.db_model.created_at >= start_date)
                 .filter(self.db_model.created_at <= end_date)
+                .filter(self.db_model.role != "system")
+                .filter(self.db_model.role != "tool")
                 .offset(offset)
             )
             if limit:
                 query = query.limit(limit)
             results = query.all()
         return [result.to_record() for result in results]
 
-    def query_text(self, query, offset=0, limit=None):
+    def query_text(self, query, limit=None, offset=0):
         # todo: make fuzz https://stackoverflow.com/questions/42388956/create-a-full-text-search-index-with-sqlalchemy-on-postgresql/42390204#42390204
         filters = self.get_filters({})
         with self.session_maker() as session:
             query = (
                 session.query(self.db_model)
                 .filter(*filters)
                 .filter(func.lower(self.db_model.text).contains(func.lower(query)))
+                .filter(self.db_model.role != "system")
+                .filter(self.db_model.role != "tool")
                 .offset(offset)
             )
             if limit:
@@ -527,6 +532,30 @@ def update(self, record: RecordType):
             # Commit the changes to the database
             session.commit()
 
+    def str_to_datetime(self, str_date):
+        val = str_date.split("-")
+        _datetime = datetime(int(val[0]), int(val[1]), int(val[2]))
+        return _datetime
+
+    def query_date(self, start_date, end_date, limit=None, offset=0):
+        filters = self.get_filters({})
+        _start_date = self.str_to_datetime(start_date)
+        _end_date = self.str_to_datetime(end_date)
+        with self.session_maker() as session:
+            query = (
+                session.query(self.db_model)
+                .filter(*filters)
+                .filter(self.db_model.created_at >= _start_date)
+                .filter(self.db_model.created_at <= _end_date)
+                .filter(self.db_model.role != "system")
+                .filter(self.db_model.role != "tool")
+                .offset(offset)
+            )
+            if limit:
+                query = query.limit(limit)
+            results = query.all()
+        return [result.to_record() for result in results]
+
 
 class SQLLiteStorageConnector(SQLStorageConnector):
     def __init__(self, table_type: str, config: MemGPTConfig, user_id, agent_id=None):

memgpt/data_types.py

@@ -244,6 +244,11 @@ def dict_to_message(
                 tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
             )
 
+    def to_openai_dict_search_results(self, max_tool_id_length=TOOL_CALL_ID_MAX_LEN) -> dict:
+        result_json = self.to_openai_dict()
+        search_result_json = {"timestamp": self.created_at, "message": {"content": result_json["content"], "role": result_json["role"]}}
+        return search_result_json
+
     def to_openai_dict(self, max_tool_id_length=TOOL_CALL_ID_MAX_LEN) -> dict:
         """Go from Message class to ChatCompletion message object"""
 

memgpt/memory.py

@@ -327,12 +327,12 @@ def get_all(self, start=0, count=None):
 
     def text_search(self, query_string, count=None, start=None):
         results = self.storage.query_text(query_string, count, start)
-        results_json = [message.to_openai_dict() for message in results]
+        results_json = [message.to_openai_dict_search_results() for message in results]
         return results_json, len(results)
 
     def date_search(self, start_date, end_date, count=None, start=None):
         results = self.storage.query_date(start_date, end_date, count, start)
-        results_json = [message.to_openai_dict() for message in results]
+        results_json = [message.to_openai_dict_search_results() for message in results]
         return results_json, len(results)
 
     def __repr__(self) -> str: