agentrun-mem0ai 0.0.11__py3-none-any.whl

agentrun_mem0/memory/setup.py

@@ -0,0 +1,56 @@
+import json
+import os
+import uuid
+
+# Set up the directory path
+VECTOR_ID = str(uuid.uuid4())
+home_dir = os.path.expanduser("~")
+mem0_dir = os.environ.get("MEM0_DIR") or os.path.join(home_dir, ".mem0")
+os.makedirs(mem0_dir, exist_ok=True)
+
+
+def setup_config():
+    config_path = os.path.join(mem0_dir, "config.json")
+    if not os.path.exists(config_path):
+        user_id = str(uuid.uuid4())
+        config = {"user_id": user_id}
+        with open(config_path, "w") as config_file:
+            json.dump(config, config_file, indent=4)
+
+
+def get_user_id():
+    config_path = os.path.join(mem0_dir, "config.json")
+    if not os.path.exists(config_path):
+        return "anonymous_user"
+
+    try:
+        with open(config_path, "r") as config_file:
+            config = json.load(config_file)
+            user_id = config.get("user_id")
+            return user_id
+    except Exception:
+        return "anonymous_user"
+
+
+def get_or_create_user_id(vector_store):
+    """Store user_id in vector store and return it."""
+    user_id = get_user_id()
+
+    # Try to get existing user_id from vector store
+    try:
+        existing = vector_store.get(vector_id=user_id)
+        if existing and hasattr(existing, "payload") and existing.payload and "user_id" in existing.payload:
+            return existing.payload["user_id"]
+    except Exception:
+        pass
+
+    # If we get here, we need to insert the user_id
+    try:
+        dims = getattr(vector_store, "embedding_model_dims", 1536)
+        vector_store.insert(
+            vectors=[[0.1] * dims], payloads=[{"user_id": user_id, "type": "user_identity"}], ids=[user_id]
+        )
+    except Exception:
+        pass
+
+    return user_id

agentrun_mem0/memory/storage.py

@@ -0,0 +1,218 @@
+import logging
+import sqlite3
+import threading
+import uuid
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SQLiteManager:
+    def __init__(self, db_path: str = ":memory:"):
+        self.db_path = db_path
+        self.connection = sqlite3.connect(self.db_path, check_same_thread=False)
+        self._lock = threading.Lock()
+        self._migrate_history_table()
+        self._create_history_table()
+
+    def _migrate_history_table(self) -> None:
+        """
+        If a pre-existing history table had the old group-chat columns,
+        rename it, create the new schema, copy the intersecting data, then
+        drop the old table.
+        """
+        with self._lock:
+            try:
+                # Start a transaction
+                self.connection.execute("BEGIN")
+                cur = self.connection.cursor()
+
+                cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='history'")
+                if cur.fetchone() is None:
+                    self.connection.execute("COMMIT")
+                    return  # nothing to migrate
+
+                cur.execute("PRAGMA table_info(history)")
+                old_cols = {row[1] for row in cur.fetchall()}
+
+                expected_cols = {
+                    "id",
+                    "memory_id",
+                    "old_memory",
+                    "new_memory",
+                    "event",
+                    "created_at",
+                    "updated_at",
+                    "is_deleted",
+                    "actor_id",
+                    "role",
+                }
+
+                if old_cols == expected_cols:
+                    self.connection.execute("COMMIT")
+                    return
+
+                logger.info("Migrating history table to new schema (no convo columns).")
+
+                # Clean up any existing history_old table from previous failed migration
+                cur.execute("DROP TABLE IF EXISTS history_old")
+
+                # Rename the current history table
+                cur.execute("ALTER TABLE history RENAME TO history_old")
+
+                # Create the new history table with updated schema
+                cur.execute(
+                    """
+                    CREATE TABLE history (
+                        id           TEXT PRIMARY KEY,
+                        memory_id    TEXT,
+                        old_memory   TEXT,
+                        new_memory   TEXT,
+                        event        TEXT,
+                        created_at   DATETIME,
+                        updated_at   DATETIME,
+                        is_deleted   INTEGER,
+                        actor_id     TEXT,
+                        role         TEXT
+                    )
+                """
+                )
+
+                # Copy data from old table to new table
+                intersecting = list(expected_cols & old_cols)
+                if intersecting:
+                    cols_csv = ", ".join(intersecting)
+                    cur.execute(f"INSERT INTO history ({cols_csv}) SELECT {cols_csv} FROM history_old")
+
+                # Drop the old table
+                cur.execute("DROP TABLE history_old")
+
+                # Commit the transaction
+                self.connection.execute("COMMIT")
+                logger.info("History table migration completed successfully.")
+
+            except Exception as e:
+                # Rollback the transaction on any error
+                self.connection.execute("ROLLBACK")
+                logger.error(f"History table migration failed: {e}")
+                raise
+
+    def _create_history_table(self) -> None:
+        with self._lock:
+            try:
+                self.connection.execute("BEGIN")
+                self.connection.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS history (
+                        id           TEXT PRIMARY KEY,
+                        memory_id    TEXT,
+                        old_memory   TEXT,
+                        new_memory   TEXT,
+                        event        TEXT,
+                        created_at   DATETIME,
+                        updated_at   DATETIME,
+                        is_deleted   INTEGER,
+                        actor_id     TEXT,
+                        role         TEXT
+                    )
+                """
+                )
+                self.connection.execute("COMMIT")
+            except Exception as e:
+                self.connection.execute("ROLLBACK")
+                logger.error(f"Failed to create history table: {e}")
+                raise
+
+    def add_history(
+        self,
+        memory_id: str,
+        old_memory: Optional[str],
+        new_memory: Optional[str],
+        event: str,
+        *,
+        created_at: Optional[str] = None,
+        updated_at: Optional[str] = None,
+        is_deleted: int = 0,
+        actor_id: Optional[str] = None,
+        role: Optional[str] = None,
+    ) -> None:
+        with self._lock:
+            try:
+                self.connection.execute("BEGIN")
+                self.connection.execute(
+                    """
+                    INSERT INTO history (
+                        id, memory_id, old_memory, new_memory, event,
+                        created_at, updated_at, is_deleted, actor_id, role
+                    )
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                    (
+                        str(uuid.uuid4()),
+                        memory_id,
+                        old_memory,
+                        new_memory,
+                        event,
+                        created_at,
+                        updated_at,
+                        is_deleted,
+                        actor_id,
+                        role,
+                    ),
+                )
+                self.connection.execute("COMMIT")
+            except Exception as e:
+                self.connection.execute("ROLLBACK")
+                logger.error(f"Failed to add history record: {e}")
+                raise
+
+    def get_history(self, memory_id: str) -> List[Dict[str, Any]]:
+        with self._lock:
+            cur = self.connection.execute(
+                """
+                SELECT id, memory_id, old_memory, new_memory, event,
+                       created_at, updated_at, is_deleted, actor_id, role
+                FROM history
+                WHERE memory_id = ?
+                ORDER BY created_at ASC, DATETIME(updated_at) ASC
+            """,
+                (memory_id,),
+            )
+            rows = cur.fetchall()
+
+        return [
+            {
+                "id": r[0],
+                "memory_id": r[1],
+                "old_memory": r[2],
+                "new_memory": r[3],
+                "event": r[4],
+                "created_at": r[5],
+                "updated_at": r[6],
+                "is_deleted": bool(r[7]),
+                "actor_id": r[8],
+                "role": r[9],
+            }
+            for r in rows
+        ]
+
+    def reset(self) -> None:
+        """Drop and recreate the history table."""
+        with self._lock:
+            try:
+                self.connection.execute("BEGIN")
+                self.connection.execute("DROP TABLE IF EXISTS history")
+                self.connection.execute("COMMIT")
+                self._create_history_table()
+            except Exception as e:
+                self.connection.execute("ROLLBACK")
+                logger.error(f"Failed to reset history table: {e}")
+                raise
+
+    def close(self) -> None:
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+
+    def __del__(self):
+        self.close()

agentrun_mem0/memory/telemetry.py

@@ -0,0 +1,90 @@
+import logging
+import os
+import platform
+import sys
+
+from posthog import Posthog
+
+import agentrun_mem0
+from agentrun_mem0.memory.setup import get_or_create_user_id
+
+MEM0_TELEMETRY = os.environ.get("MEM0_TELEMETRY", "False")
+PROJECT_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX"
+HOST = "https://us.i.posthog.com"
+
+if isinstance(MEM0_TELEMETRY, str):
+    MEM0_TELEMETRY = MEM0_TELEMETRY.lower() in ("true", "1", "yes")
+
+if not isinstance(MEM0_TELEMETRY, bool):
+    raise ValueError("MEM0_TELEMETRY must be a boolean value.")
+
+logging.getLogger("posthog").setLevel(logging.CRITICAL + 1)
+logging.getLogger("urllib3").setLevel(logging.CRITICAL + 1)
+
+
+class AnonymousTelemetry:
+    def __init__(self, vector_store=None):
+        self.posthog = Posthog(project_api_key=PROJECT_API_KEY, host=HOST)
+
+        self.user_id = get_or_create_user_id(vector_store)
+
+        if not MEM0_TELEMETRY:
+            self.posthog.disabled = True
+
+    def capture_event(self, event_name, properties=None, user_email=None):
+        if properties is None:
+            properties = {}
+        properties = {
+            "client_source": "python",
+            "client_version": agentrun_mem0.__version__,
+            "python_version": sys.version,
+            "os": sys.platform,
+            "os_version": platform.version(),
+            "os_release": platform.release(),
+            "processor": platform.processor(),
+            "machine": platform.machine(),
+            **properties,
+        }
+        distinct_id = self.user_id if user_email is None else user_email
+        self.posthog.capture(distinct_id=distinct_id, event=event_name, properties=properties)
+
+    def close(self):
+        self.posthog.shutdown()
+
+
+client_telemetry = AnonymousTelemetry()
+
+
+def capture_event(event_name, memory_instance, additional_data=None):
+    oss_telemetry = AnonymousTelemetry(
+        vector_store=memory_instance._telemetry_vector_store
+        if hasattr(memory_instance, "_telemetry_vector_store")
+        else None,
+    )
+
+    event_data = {
+        "collection": memory_instance.collection_name,
+        "vector_size": memory_instance.embedding_model.config.embedding_dims,
+        "history_store": "sqlite",
+        "graph_store": f"{memory_instance.graph.__class__.__module__}.{memory_instance.graph.__class__.__name__}"
+        if memory_instance.config.graph_store.config
+        else None,
+        "vector_store": f"{memory_instance.vector_store.__class__.__module__}.{memory_instance.vector_store.__class__.__name__}",
+        "llm": f"{memory_instance.llm.__class__.__module__}.{memory_instance.llm.__class__.__name__}",
+        "embedding_model": f"{memory_instance.embedding_model.__class__.__module__}.{memory_instance.embedding_model.__class__.__name__}",
+        "function": f"{memory_instance.__class__.__module__}.{memory_instance.__class__.__name__}.{memory_instance.api_version}",
+    }
+    if additional_data:
+        event_data.update(additional_data)
+
+    oss_telemetry.capture_event(event_name, event_data)
+
+
+def capture_client_event(event_name, instance, additional_data=None):
+    event_data = {
+        "function": f"{instance.__class__.__module__}.{instance.__class__.__name__}",
+    }
+    if additional_data:
+        event_data.update(additional_data)
+
+    client_telemetry.capture_event(event_name, event_data, instance.user_email)

agentrun_mem0/memory/utils.py

@@ -0,0 +1,208 @@
+import hashlib
+import re
+
+from agentrun_mem0.configs.prompts import (
+    FACT_RETRIEVAL_PROMPT,
+    USER_MEMORY_EXTRACTION_PROMPT,
+    AGENT_MEMORY_EXTRACTION_PROMPT,
+)
+
+
+def get_fact_retrieval_messages(message, is_agent_memory=False):
+    """Get fact retrieval messages based on the memory type.
+    
+    Args:
+        message: The message content to extract facts from
+        is_agent_memory: If True, use agent memory extraction prompt, else use user memory extraction prompt
+        
+    Returns:
+        tuple: (system_prompt, user_prompt)
+    """
+    if is_agent_memory:
+        return AGENT_MEMORY_EXTRACTION_PROMPT, f"Input:\n{message}"
+    else:
+        return USER_MEMORY_EXTRACTION_PROMPT, f"Input:\n{message}"
+
+
+def get_fact_retrieval_messages_legacy(message):
+    """Legacy function for backward compatibility."""
+    return FACT_RETRIEVAL_PROMPT, f"Input:\n{message}"
+
+
+def parse_messages(messages):
+    response = ""
+    for msg in messages:
+        if msg["role"] == "system":
+            response += f"system: {msg['content']}\n"
+        if msg["role"] == "user":
+            response += f"user: {msg['content']}\n"
+        if msg["role"] == "assistant":
+            response += f"assistant: {msg['content']}\n"
+    return response
+
+
+def format_entities(entities):
+    if not entities:
+        return ""
+
+    formatted_lines = []
+    for entity in entities:
+        simplified = f"{entity['source']} -- {entity['relationship']} -- {entity['destination']}"
+        formatted_lines.append(simplified)
+
+    return "\n".join(formatted_lines)
+
+
+def remove_code_blocks(content: str) -> str:
+    """
+    Removes enclosing code block markers ```[language] and ``` from a given string.
+
+    Remarks:
+    - The function uses a regex pattern to match code blocks that may start with ``` followed by an optional language tag (letters or numbers) and end with ```.
+    - If a code block is detected, it returns only the inner content, stripping out the markers.
+    - If no code block markers are found, the original content is returned as-is.
+    """
+    pattern = r"^```[a-zA-Z0-9]*\n([\s\S]*?)\n```$"
+    match = re.match(pattern, content.strip())
+    match_res=match.group(1).strip() if match else content.strip()
+    return re.sub(r"<think>.*?</think>", "", match_res, flags=re.DOTALL).strip()
+
+
+
+def extract_json(text):
+    """
+    Extracts JSON content from a string, removing enclosing triple backticks and optional 'json' tag if present.
+    If no code block is found, returns the text as-is.
+    """
+    text = text.strip()
+    match = re.search(r"```(?:json)?\s*(.*?)\s*```", text, re.DOTALL)
+    if match:
+        json_str = match.group(1)
+    else:
+        json_str = text  # assume it's raw JSON
+    return json_str
+
+
+def get_image_description(image_obj, llm, vision_details):
+    """
+    Get the description of the image
+    """
+
+    if isinstance(image_obj, str):
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "A user is providing an image. Provide a high level description of the image and do not include any additional text.",
+                    },
+                    {"type": "image_url", "image_url": {"url": image_obj, "detail": vision_details}},
+                ],
+            },
+        ]
+    else:
+        messages = [image_obj]
+
+    response = llm.generate_response(messages=messages)
+    return response
+
+
+def parse_vision_messages(messages, llm=None, vision_details="auto"):
+    """
+    Parse the vision messages from the messages
+    """
+    returned_messages = []
+    for msg in messages:
+        if msg["role"] == "system":
+            returned_messages.append(msg)
+            continue
+
+        # Handle message content
+        if isinstance(msg["content"], list):
+            # Multiple image URLs in content
+            description = get_image_description(msg, llm, vision_details)
+            returned_messages.append({"role": msg["role"], "content": description})
+        elif isinstance(msg["content"], dict) and msg["content"].get("type") == "image_url":
+            # Single image content
+            image_url = msg["content"]["image_url"]["url"]
+            try:
+                description = get_image_description(image_url, llm, vision_details)
+                returned_messages.append({"role": msg["role"], "content": description})
+            except Exception:
+                raise Exception(f"Error while downloading {image_url}.")
+        else:
+            # Regular text content
+            returned_messages.append(msg)
+
+    return returned_messages
+
+
+def process_telemetry_filters(filters):
+    """
+    Process the telemetry filters
+    """
+    if filters is None:
+        return {}
+
+    encoded_ids = {}
+    if "user_id" in filters:
+        encoded_ids["user_id"] = hashlib.md5(filters["user_id"].encode()).hexdigest()
+    if "agent_id" in filters:
+        encoded_ids["agent_id"] = hashlib.md5(filters["agent_id"].encode()).hexdigest()
+    if "run_id" in filters:
+        encoded_ids["run_id"] = hashlib.md5(filters["run_id"].encode()).hexdigest()
+
+    return list(filters.keys()), encoded_ids
+
+
+def sanitize_relationship_for_cypher(relationship) -> str:
+    """Sanitize relationship text for Cypher queries by replacing problematic characters."""
+    char_map = {
+        "...": "_ellipsis_",
+        "…": "_ellipsis_",
+        "。": "_period_",
+        "，": "_comma_",
+        "；": "_semicolon_",
+        "：": "_colon_",
+        "！": "_exclamation_",
+        "？": "_question_",
+        "（": "_lparen_",
+        "）": "_rparen_",
+        "【": "_lbracket_",
+        "】": "_rbracket_",
+        "《": "_langle_",
+        "》": "_rangle_",
+        "'": "_apostrophe_",
+        '"': "_quote_",
+        "\\": "_backslash_",
+        "/": "_slash_",
+        "|": "_pipe_",
+        "&": "_ampersand_",
+        "=": "_equals_",
+        "+": "_plus_",
+        "*": "_asterisk_",
+        "^": "_caret_",
+        "%": "_percent_",
+        "$": "_dollar_",
+        "#": "_hash_",
+        "@": "_at_",
+        "!": "_bang_",
+        "?": "_question_",
+        "(": "_lparen_",
+        ")": "_rparen_",
+        "[": "_lbracket_",
+        "]": "_rbracket_",
+        "{": "_lbrace_",
+        "}": "_rbrace_",
+        "<": "_langle_",
+        ">": "_rangle_",
+    }
+
+    # Apply replacements and clean up
+    sanitized = relationship
+    for old, new in char_map.items():
+        sanitized = sanitized.replace(old, new)
+
+    return re.sub(r"_+", "_", sanitized).strip("_")
+