mem0ai-azure-mysql 0.1.115__py3-none-any.whl

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()

mem0/memory/telemetry.py

@@ -0,0 +1,90 @@
+import logging
+import os
+import platform
+import sys
+
+from posthog import Posthog
+
+import mem0
+from mem0.memory.setup import get_or_create_user_id
+
+MEM0_TELEMETRY = os.environ.get("MEM0_TELEMETRY", "True")
+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": 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)

mem0/memory/utils.py

@@ -0,0 +1,133 @@
+import hashlib
+import re
+
+from mem0.configs.prompts import FACT_RETRIEVAL_PROMPT
+
+
+def get_fact_retrieval_messages(message):
+    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())
+    return match.group(1).strip() if match else content.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

mem0/proxy/main.py

@@ -0,0 +1,194 @@
+import logging
+import subprocess
+import sys
+import threading
+from typing import List, Optional, Union
+
+import httpx
+
+import mem0
+
+try:
+    import litellm
+except ImportError:
+    user_input = input("The 'litellm' library is required. Install it now? [y/N]: ")
+    if user_input.lower() == "y":
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "litellm"])
+            import litellm
+        except subprocess.CalledProcessError:
+            print("Failed to install 'litellm'. Please install it manually using 'pip install litellm'.")
+            sys.exit(1)
+    else:
+        raise ImportError("The required 'litellm' library is not installed.")
+        sys.exit(1)
+
+from mem0 import Memory, MemoryClient
+from mem0.configs.prompts import MEMORY_ANSWER_PROMPT
+from mem0.memory.telemetry import capture_client_event, capture_event
+
+logger = logging.getLogger(__name__)
+
+
+class Mem0:
+    def __init__(
+        self,
+        config: Optional[dict] = None,
+        api_key: Optional[str] = None,
+        host: Optional[str] = None,
+    ):
+        if api_key:
+            self.mem0_client = MemoryClient(api_key, host)
+        else:
+            self.mem0_client = Memory.from_config(config) if config else Memory()
+
+        self.chat = Chat(self.mem0_client)
+
+
+class Chat:
+    def __init__(self, mem0_client):
+        self.completions = Completions(mem0_client)
+
+
+class Completions:
+    def __init__(self, mem0_client):
+        self.mem0_client = mem0_client
+
+    def create(
+        self,
+        model: str,
+        messages: List = [],
+        # Mem0 arguments
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        metadata: Optional[dict] = None,
+        filters: Optional[dict] = None,
+        limit: Optional[int] = 10,
+        # LLM arguments
+        timeout: Optional[Union[float, str, httpx.Timeout]] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        n: Optional[int] = None,
+        stream: Optional[bool] = None,
+        stream_options: Optional[dict] = None,
+        stop=None,
+        max_tokens: Optional[int] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        logit_bias: Optional[dict] = None,
+        user: Optional[str] = None,
+        # openai v1.0+ new params
+        response_format: Optional[dict] = None,
+        seed: Optional[int] = None,
+        tools: Optional[List] = None,
+        tool_choice: Optional[Union[str, dict]] = None,
+        logprobs: Optional[bool] = None,
+        top_logprobs: Optional[int] = None,
+        parallel_tool_calls: Optional[bool] = None,
+        deployment_id=None,
+        extra_headers: Optional[dict] = None,
+        # soon to be deprecated params by OpenAI
+        functions: Optional[List] = None,
+        function_call: Optional[str] = None,
+        # set api_base, api_version, api_key
+        base_url: Optional[str] = None,
+        api_version: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model_list: Optional[list] = None,  # pass in a list of api_base,keys, etc.
+    ):
+        if not any([user_id, agent_id, run_id]):
+            raise ValueError("One of user_id, agent_id, run_id must be provided")
+
+        if not litellm.supports_function_calling(model):
+            raise ValueError(
+                f"Model '{model}' does not support function calling. Please use a model that supports function calling."
+            )
+
+        prepared_messages = self._prepare_messages(messages)
+        if prepared_messages[-1]["role"] == "user":
+            self._async_add_to_memory(messages, user_id, agent_id, run_id, metadata, filters)
+            relevant_memories = self._fetch_relevant_memories(messages, user_id, agent_id, run_id, filters, limit)
+            logger.debug(f"Retrieved {len(relevant_memories)} relevant memories")
+            prepared_messages[-1]["content"] = self._format_query_with_memories(messages, relevant_memories)
+
+        response = litellm.completion(
+            model=model,
+            messages=prepared_messages,
+            temperature=temperature,
+            top_p=top_p,
+            n=n,
+            timeout=timeout,
+            stream=stream,
+            stream_options=stream_options,
+            stop=stop,
+            max_tokens=max_tokens,
+            presence_penalty=presence_penalty,
+            frequency_penalty=frequency_penalty,
+            logit_bias=logit_bias,
+            user=user,
+            response_format=response_format,
+            seed=seed,
+            tools=tools,
+            tool_choice=tool_choice,
+            logprobs=logprobs,
+            top_logprobs=top_logprobs,
+            parallel_tool_calls=parallel_tool_calls,
+            deployment_id=deployment_id,
+            extra_headers=extra_headers,
+            functions=functions,
+            function_call=function_call,
+            base_url=base_url,
+            api_version=api_version,
+            api_key=api_key,
+            model_list=model_list,
+        )
+        if isinstance(self.mem0_client, Memory):
+            capture_event("mem0.chat.create", self.mem0_client)
+        else:
+            capture_client_event("mem0.chat.create", self.mem0_client)
+        return response
+
+    def _prepare_messages(self, messages: List[dict]) -> List[dict]:
+        if not messages or messages[0]["role"] != "system":
+            return [{"role": "system", "content": MEMORY_ANSWER_PROMPT}] + messages
+        return messages
+
+    def _async_add_to_memory(self, messages, user_id, agent_id, run_id, metadata, filters):
+        def add_task():
+            logger.debug("Adding to memory asynchronously")
+            self.mem0_client.add(
+                messages=messages,
+                user_id=user_id,
+                agent_id=agent_id,
+                run_id=run_id,
+                metadata=metadata,
+                filters=filters,
+            )
+
+        threading.Thread(target=add_task, daemon=True).start()
+
+    def _fetch_relevant_memories(self, messages, user_id, agent_id, run_id, filters, limit):
+        # Currently, only pass the last 6 messages to the search API to prevent long query
+        message_input = [f"{message['role']}: {message['content']}" for message in messages][-6:]
+        # TODO: Make it better by summarizing the past conversation
+        return self.mem0_client.search(
+            query="\n".join(message_input),
+            user_id=user_id,
+            agent_id=agent_id,
+            run_id=run_id,
+            filters=filters,
+            limit=limit,
+        )
+
+    def _format_query_with_memories(self, messages, relevant_memories):
+        # Check if self.mem0_client is an instance of Memory or MemoryClient
+
+        entities = []
+        if isinstance(self.mem0_client, mem0.memory.main.Memory):
+            memories_text = "\n".join(memory["memory"] for memory in relevant_memories["results"])
+            if relevant_memories.get("relations"):
+                entities = [entity for entity in relevant_memories["relations"]]
+        elif isinstance(self.mem0_client, mem0.client.main.MemoryClient):
+            memories_text = "\n".join(memory["memory"] for memory in relevant_memories)
+        return f"- Relevant Memories/Facts: {memories_text}\n\n- Entities: {entities}\n\n- User Question: {messages[-1]['content']}"