agent/skills/roleplayer/instructions.md

@@ -63,15 +63,6 @@ Jika user memperkenalkan diri dalam format `!start ... !end` (contoh: "Aku John"
 2. **Jika ketemu** — Sambut natural.
 3. **Jika tidak** — Tawarkan store, lalu simpan dengan `users_store`.
 
-### Memory Context Loading
-Setelah identitas user terkonfirmasi (baik melalui `[User Context]` otomatis maupun setelah proses `users_store`/`users_filter` manual), lakukan langkah berikut untuk menjaga kontinuitas cerita:
-
-1. **Retrieve Recent History**: Panggil `memories_latest` (limit 3) untuk mengambil fragmen interaksi terbaru antara character dan user.
-2. **Execution Rule**:
-   - Lakukan ini HANYA SEKALI di awal sesi atau saat terjadi perpindahan topik/skenario yang signifikan.
-   - JANGAN memanggil `memories_latest` di setiap giliran respon. Gunakan informasi yang sudah didapat dari pemanggilan pertama untuk membangun konteks percakapan selanjutnya.
-3. **Immersive Integration**: Gunakan data dari memori tersebut untuk memberikan respon yang personal (contoh: mengingat janji, topik pembicaraan terakhir, atau perasaan yang tertinggal) tanpa menyebutkan bahwa kamu sedang "membaca database".
-
 ## Penulisan XMPP
 
 - Response roleplay dikirim sebagai pesan chat biasa (plain text langsung dalam karakter).

hendrik.py

@@ -40,7 +40,6 @@ tools_definition = [
     gadget.tools_mapping( schema = ragroleplay.schema_memories_store,   handler = ragroleplay.memories_store   ),
     gadget.tools_mapping( schema = ragroleplay.schema_memories_filter, handler = ragroleplay.memories_filter ),
     gadget.tools_mapping( schema = ragroleplay.schema_memories_summarize, handler = ragroleplay.memories_summarize ),
-    gadget.tools_mapping( schema = ragroleplay.schema_memories_latest,    handler = ragroleplay.memories_latest    ),
     gadget.tools_mapping( schema = ragroleplay.schema_memories_update,  handler = ragroleplay.memories_update  ),
     gadget.tools_mapping( schema = ragroleplay.schema_memories_delete,  handler = ragroleplay.memories_delete  ),
     gadget.tools_mapping( schema = ragroleplay.schema_worlds_store,    handler = ragroleplay.worlds_store    ),

lib/ragroleplay.py

@@ -23,6 +23,7 @@ def create_table(db_path, vector_size):
         pyarrow.field('timestamp',          pyarrow.timestamp('ms'),                       metadata={'description': 'When record created'}),
         pyarrow.field('character',          pyarrow.string(),                              metadata={'description': 'Active Character'}),
         pyarrow.field('user',               pyarrow.string(),                              metadata={'description': 'Active User'}),
+        pyarrow.field('relative_time',      pyarrow.string(),                              metadata={'description': 'Explaining when it happen'}),
         pyarrow.field('event',              pyarrow.string(),                              metadata={'description': 'What event'}),
         pyarrow.field('category',           pyarrow.string(),                              metadata={'description': 'Event category'}),
         pyarrow.field('detail',             pyarrow.string(),                              metadata={'description': 'Event detail'}),
@@ -145,7 +146,7 @@ def users_filter(db_path, query_name=None, unique_id=None, persona_keyword=None,
             filters.append(f"persona LIKE '%{persona_keyword}%'")
             
         query = " AND ".join(filters)
-        results = table.search().where(query).to_list() if query else table.search().to_list()
+        results = table.search().where(query).to_list() if query else table.to_list()
         
         del table
         del db
@@ -190,8 +191,7 @@ def users_update(db_path, model_url, model_name, user_id, **updates):
         if needs_reembed:
             record['vector_fullname'] = embed_text(model_url, model_name, record['fullname'])
         
-        table.delete(f"id = X'{_uuid(record['id']).hex}'")
-        table.add([record])
+        table.upsert([record])
         
         del table
         del db
@@ -201,12 +201,12 @@ def users_update(db_path, model_url, model_name, user_id, **updates):
         print(f"Error updating user: {e}")
         return False
 
-def memories_store(db_path, model_url, model_name, character, user, event, category, detail, physical, emotional):
+def memories_store(db_path, model_url, model_name, character, user, relative_time, event, category, detail, physical, emotional):
     try:
         db            = lancedb.connect(db_path)
         table         = db.open_table("knowledge_memories")
         
-        context_text  = f"Event: {event}\nDetail: {detail}\nCategory: {category}"
+        context_text  = f"Event: {event}\nDetail: {detail}\nCategory: {category}\nTime: {relative_time}"
         vector        = embed_text(model_url, model_name, context_text)
         
         record        = {
@@ -214,6 +214,7 @@ def memories_store(db_path, model_url, model_name, character, user, event, categ
             "timestamp": datetime.now(),
             "character": character,
             "user": user,
+            "relative_time": relative_time,
             "event": event,
             "category": category,
             "detail": detail,
@@ -246,7 +247,7 @@ def memories_filter(db_path, category=None, character=None, user=None):
         if filters:
             query = " AND ".join(filters)
         
-        results  = table.search().where(query).to_list() if query else table.search().to_list()
+        results  = table.search().where(query).to_list() if query else table.to_list()
         
         del table
         del db
@@ -256,25 +257,6 @@ def memories_filter(db_path, category=None, character=None, user=None):
         print(f"Error filtering memories: {e}")
         return []
 
-def memories_latest(db_path, character, user, limit=3):
-    try:
-        db = lancedb.connect(db_path)
-        table = db.open_table("knowledge_memories")
-        query = f"character = '{character}' AND user = '{user}'"
-        results = table.search().where(query).to_list()
-
-        results.sort(key=lambda x: x['timestamp'], reverse=True)
-        final_results = results[:limit]
-
-        del table
-        del db
-        gc.collect()
-        return final_results
-    except Exception as e:
-        print(f"Error getting latest memories: {e}")
-        return []
-
-
 def memories_summarize(db_path, prompt_text, model_url, model_name, search_limit=5):
     try:
         db       = lancedb.connect(db_path)
@@ -321,7 +303,7 @@ def memories_update(db_path, model_url, model_name, memory_id, **updates):
             return False
             
         record           = current_record[0]
-        affected_fields  = ['event', 'detail', 'category']
+        affected_fields  = ['event', 'detail', 'category', 'relative_time']
         needs_reembed    = any(field in updates for field in affected_fields)
         
         for key, value in updates.items():
@@ -329,11 +311,10 @@ def memories_update(db_path, model_url, model_name, memory_id, **updates):
                 record[key] = value
         
         if needs_reembed:
-            context_text = f"Event: {record['event']}\nDetail: {record['detail']}\nCategory: {record['category']}"
+            context_text = f"Event: {record['event']}\nDetail: {record['detail']}\nCategory: {record['category']}\nTime: {record['relative_time']}"
             record['vector_context'] = embed_text(model_url, model_name, context_text)
         
-        table.delete(f"id = X'{_uuid(record['id']).hex}'")
-        table.add([record])
+        table.upsert([record])
         del table
         del db
         gc.collect()
@@ -366,7 +347,7 @@ def objects_filter(db_path, keyword=None, object_id=None):
         query = ""
         if object_id: query = f"id = X'{_uuid(object_id).hex}'"
         elif keyword: query = f"keyword = '{keyword}'"
-        results = table.search().where(query).to_list() if query else table.search().to_list()
+        results = table.search().where(query).to_list() if query else table.to_list()
         del table; del db; gc.collect()
         return results
     except Exception as e: return []
@@ -383,8 +364,7 @@ def objects_update(db_path, model_url, model_name, object_id, **updates):
             if k in record: record[k] = v
         if needs_reembed:
             record['vector_context'] = embed_text(model_url, model_name, f"Keyword: {record['keyword']}\nWhen: {record['when']}\nName: {record['name']}")
-        table.delete(f"id = X'{_uuid(record['id']).hex}'")
-        table.add([record])
+        table.upsert([record])
         del table; del db; gc.collect()
         return True
     except Exception as e: return False
@@ -422,7 +402,7 @@ def outfits_filter(db_path, keyword=None, outfit_id=None):
         query = ""
         if outfit_id: query = f"id = X'{_uuid(outfit_id).hex}'"
         elif keyword: query = f"keyword = '{keyword}'"
-        results = table.search().where(query).to_list() if query else table.search().to_list()
+        results = table.search().where(query).to_list() if query else table.to_list()
         del table; del db; gc.collect()
         return results
     except Exception as e: return []
@@ -439,8 +419,7 @@ def outfits_update(db_path, model_url, model_name, outfit_id, **updates):
             if k in record: record[k] = v
         if needs_reembed:
             record['vector_context'] = embed_text(model_url, model_name, f"Keyword: {record['keyword']}\nWhen: {record['when']}")
-        table.delete(f"id = X'{_uuid(record['id']).hex}'")
-        table.add([record])
+        table.upsert([record])
         del table; del db; gc.collect()
         return True
     except Exception as e: return False
@@ -478,7 +457,7 @@ def todos_filter(db_path, keyword=None, todo_id=None):
         query = ""
         if todo_id: query = f"id = X'{_uuid(todo_id).hex}'"
         elif keyword: query = f"keyword = '{keyword}'"
-        results = table.search().where(query).to_list() if query else table.search().to_list()
+        results = table.search().where(query).to_list() if query else table.to_list()
         del table; del db; gc.collect()
         return results
     except Exception as e: return []
@@ -495,8 +474,7 @@ def todos_update(db_path, model_url, model_name, todo_id, **updates):
             if k in record: record[k] = v
         if needs_reembed:
             record['vector_context'] = embed_text(model_url, model_name, f"Keyword: {record['keyword']}\nWhen: {record['when']}")
-        table.delete(f"id = X'{_uuid(record['id']).hex}'")
-        table.add([record])
+        table.upsert([record])
         del table; del db; gc.collect()
         return True
     except Exception as e: return False
@@ -536,7 +514,7 @@ def worlds_filter(db_path, category=None, location=None, world_id=None):
         if category: filters.append(f"category = '{category}'")
         if location: filters.append(f"location = '{location}'")
         query = " AND ".join(filters)
-        results = table.search().where(query).to_list() if query else table.search().to_list()
+        results = table.search().where(query).to_list() if query else table.to_list()
         del table; del db; gc.collect()
         return results
     except Exception as e: return []
@@ -553,8 +531,7 @@ def worlds_update(db_path, model_url, model_name, world_id, **updates):
             if k in record: record[k] = v
         if needs_reembed:
             record['vector_context'] = embed_text(model_url, model_name, f"Category: {record['category']}\nLocation: {record['location']}\nDescription: {record['description']}")
-        table.delete(f"id = X'{_uuid(record['id']).hex}'")
-        table.add([record])
+        table.upsert([record])
         del table; del db; gc.collect()
         return True
     except Exception as e: return False

services/telegram_client.py

@@ -246,7 +246,7 @@ class TelegramClient:
 
         if final_content is not None:
             if is_roleplay:
-                my_name = personality.PERSONALITY.name
+                my_name = PERSONALITY.name
                 if config.TELEGRAM_SELECTIVE_RESPONSE:
                     recent_msgs = []
                     for msg in session.messages[-6:]:

tools/ragroleplay.py

@@ -110,13 +110,14 @@ schema_memories_store = {
             "properties": {
                 "character": {"type": "string", "description": "The active character name"},
                 "user": {"type": "string", "description": "The active user name"},
+                "relative_time": {"type": "string", "description": "Description of when the event happened (e.g., '2 hours ago', 'yesterday')"},
                 "event": {"type": "string", "description": "Brief summary of the event"},
                 "category": {"type": "string", "description": "Category of the memory (e.g., 'Emotional', 'Physical', 'Relationship')"},
                 "detail": {"type": "string", "description": "Detailed description of the event"},
                 "physical": {"type": "string", "description": "Physical state of the character during the event"},
                 "emotional": {"type": "string", "description": "Emotional state of the character during the event"}
             },
-            "required": ["character", "user", "event", "category", "detail", "physical", "emotional"]
+            "required": ["character", "user", "relative_time", "event", "category", "detail", "physical", "emotional"]
         }
     }
 }
@@ -153,23 +154,6 @@ schema_memories_summarize = {
     }
 }
 
-schema_memories_latest = {
-    "type": "function",
-    "function": {
-        "name": "memories_latest",
-        "description": "Retrieve the most recent memories between a specific user and character.",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "character": {"type": "string", "description": "The name of the character"},
-                "user": {"type": "string", "description": "The name of the user"},
-                "limit": {"type": "integer", "description": "Number of recent memories to retrieve", "default": 3}
-            },
-            "required": ["character", "user"]
-        }
-    }
-}
-
 schema_memories_update = {
     "type": "function",
     "function": {
@@ -179,6 +163,7 @@ schema_memories_update = {
             "type": "object",
             "properties": {
                 "memory_id": {"type": "string", "description": "The unique ID of the memory to update"},
+                "relative_time": {"type": "string", "description": "Updated relative time"},
                 "event": {"type": "string", "description": "Updated event summary"},
                 "category": {"type": "string", "description": "Updated category"},
                 "detail": {"type": "string", "description": "Updated detail"},
@@ -497,6 +482,7 @@ def memories_check(prompt_text, search_limit):
         for i, row in enumerate(results, 1):
             mem_info = (
                 f"Memori #{i}\n"
+                f"Kapan: {row['relative_time']}\n"
                 f"Kejadian: {row['event']}\n"
                 f"Detail: {row['detail']}\n"
                 f"Kondisi Fisik: {row['physical']}\n"
@@ -515,7 +501,7 @@ def memories_check(prompt_text, search_limit):
     except Exception as e:
         return f"Error searching memories: {str(e)}"
 
-def memories_store(character, user, event, category, detail, physical, emotional):
+def memories_store(character, user, relative_time, event, category, detail, physical, emotional):
     try:
         success = ragroleplay_lib.memories_store(
             config.ragroleplay_db_path, 
@@ -523,6 +509,7 @@ def memories_store(character, user, event, category, detail, physical, emotional
             config.ragroleplay_model_name, 
             character, 
             user, 
+            relative_time, 
             event, 
             category, 
             detail, 
@@ -547,6 +534,7 @@ def memories_filter(category=None, character=None, user=None):
         for i, row in enumerate(results, 1):
             mem_info = (
                 f"Memori #{i}\n"
+                f"Kapan: {row['relative_time']}\n"
                 f"Kejadian: {row['event']}\n"
                 f"Detail: {row['detail']}\n"
                 f"Kategori: {row['category']}\n"
@@ -570,27 +558,6 @@ def memories_summarize(prompt_text, search_limit=5):
     except Exception as e:
         return f"Error summarizing memories: {str(e)}"
 
-def memories_latest(character, user, limit=3):
-    try:
-        results = ragroleplay_lib.memories_latest(config.ragroleplay_db_path, character, user, limit)
-        if not results:
-            return f"Tidak ada memori terbaru yang ditemukan antara {user} dan {character}."
-
-        output = []
-        output.append(f"Ditemukan {len(results)} memori terbaru antara {user} dan {character}:\n")
-        for i, row in enumerate(results, 1):
-            mem_info = (
-                f"Memori #{i} (Timestamp: {row['timestamp']})\n"
-                f"Kejadian: {row['event']}\n"
-                f"Detail: {row['detail']}\n"
-                f"Kategori: {row['category']}\n"
-            )
-            output.append(mem_info)
-
-        return "\n".join(output)
-    except Exception as e:
-        return f"Error retrieving latest memories: {str(e)}"
-
 def memories_update(memory_id, **updates):
     try:
         success = ragroleplay_lib.memories_update(