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

mem0/configs/vector_stores/opensearch.py

@@ -0,0 +1,41 @@
+from typing import Any, Dict, Optional, Type, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class OpenSearchConfig(BaseModel):
+    collection_name: str = Field("mem0", description="Name of the index")
+    host: str = Field("localhost", description="OpenSearch host")
+    port: int = Field(9200, description="OpenSearch port")
+    user: Optional[str] = Field(None, description="Username for authentication")
+    password: Optional[str] = Field(None, description="Password for authentication")
+    api_key: Optional[str] = Field(None, description="API key for authentication (if applicable)")
+    embedding_model_dims: int = Field(1536, description="Dimension of the embedding vector")
+    verify_certs: bool = Field(False, description="Verify SSL certificates (default False for OpenSearch)")
+    use_ssl: bool = Field(False, description="Use SSL for connection (default False for OpenSearch)")
+    http_auth: Optional[object] = Field(None, description="HTTP authentication method / AWS SigV4")
+    connection_class: Optional[Union[str, Type]] = Field(
+        "RequestsHttpConnection", description="Connection class for OpenSearch"
+    )
+    pool_maxsize: int = Field(20, description="Maximum number of connections in the pool")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_auth(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        # Check if host is provided
+        if not values.get("host"):
+            raise ValueError("Host must be provided for OpenSearch")
+
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Allowed fields: {', '.join(allowed_fields)}"
+            )
+        return values

mem0/configs/vector_stores/pgvector.py

@@ -0,0 +1,37 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class PGVectorConfig(BaseModel):
+    dbname: str = Field("postgres", description="Default name for the database")
+    collection_name: str = Field("mem0", description="Default name for the collection")
+    embedding_model_dims: Optional[int] = Field(1536, description="Dimensions of the embedding model")
+    user: Optional[str] = Field(None, description="Database user")
+    password: Optional[str] = Field(None, description="Database password")
+    host: Optional[str] = Field(None, description="Database host. Default is localhost")
+    port: Optional[int] = Field(None, description="Database port. Default is 1536")
+    diskann: Optional[bool] = Field(True, description="Use diskann for approximate nearest neighbors search")
+    hnsw: Optional[bool] = Field(False, description="Use hnsw for faster search")
+
+    @model_validator(mode="before")
+    def check_auth_and_connection(cls, values):
+        user, password = values.get("user"), values.get("password")
+        host, port = values.get("host"), values.get("port")
+        if not user and not password:
+            raise ValueError("Both 'user' and 'password' must be provided.")
+        if not host and not port:
+            raise ValueError("Both 'host' and 'port' must be provided.")
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values

mem0/configs/vector_stores/pinecone.py

@@ -0,0 +1,56 @@
+import os
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class PineconeConfig(BaseModel):
+    """Configuration for Pinecone vector database."""
+
+    collection_name: str = Field("mem0", description="Name of the index/collection")
+    embedding_model_dims: int = Field(1536, description="Dimensions of the embedding model")
+    client: Optional[Any] = Field(None, description="Existing Pinecone client instance")
+    api_key: Optional[str] = Field(None, description="API key for Pinecone")
+    environment: Optional[str] = Field(None, description="Pinecone environment")
+    serverless_config: Optional[Dict[str, Any]] = Field(None, description="Configuration for serverless deployment")
+    pod_config: Optional[Dict[str, Any]] = Field(None, description="Configuration for pod-based deployment")
+    hybrid_search: bool = Field(False, description="Whether to enable hybrid search")
+    metric: str = Field("cosine", description="Distance metric for vector similarity")
+    batch_size: int = Field(100, description="Batch size for operations")
+    extra_params: Optional[Dict[str, Any]] = Field(None, description="Additional parameters for Pinecone client")
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_api_key_or_client(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        api_key, client = values.get("api_key"), values.get("client")
+        if not api_key and not client and "PINECONE_API_KEY" not in os.environ:
+            raise ValueError(
+                "Either 'api_key' or 'client' must be provided, or PINECONE_API_KEY environment variable must be set."
+            )
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_pod_or_serverless(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        pod_config, serverless_config = values.get("pod_config"), values.get("serverless_config")
+        if pod_config and serverless_config:
+            raise ValueError(
+                "Both 'pod_config' and 'serverless_config' cannot be specified. Choose one deployment option."
+            )
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }

mem0/configs/vector_stores/qdrant.py

@@ -0,0 +1,49 @@
+from typing import Any, ClassVar, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class QdrantConfig(BaseModel):
+    from qdrant_client import QdrantClient
+
+    QdrantClient: ClassVar[type] = QdrantClient
+
+    collection_name: str = Field("mem0", description="Name of the collection")
+    embedding_model_dims: Optional[int] = Field(1536, description="Dimensions of the embedding model")
+    client: Optional[QdrantClient] = Field(None, description="Existing Qdrant client instance")
+    host: Optional[str] = Field(None, description="Host address for Qdrant server")
+    port: Optional[int] = Field(None, description="Port for Qdrant server")
+    path: Optional[str] = Field("/tmp/qdrant", description="Path for local Qdrant database")
+    url: Optional[str] = Field(None, description="Full URL for Qdrant server")
+    api_key: Optional[str] = Field(None, description="API key for Qdrant server")
+    on_disk: Optional[bool] = Field(False, description="Enables persistent storage")
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_host_port_or_path(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        host, port, path, url, api_key = (
+            values.get("host"),
+            values.get("port"),
+            values.get("path"),
+            values.get("url"),
+            values.get("api_key"),
+        )
+        if not path and not (host and port) and not (url and api_key):
+            raise ValueError("Either 'host' and 'port' or 'url' and 'api_key' or 'path' must be provided.")
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }

mem0/configs/vector_stores/redis.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel, Field, model_validator
+
+
+# TODO: Upgrade to latest pydantic version
+class RedisDBConfig(BaseModel):
+    redis_url: str = Field(..., description="Redis URL")
+    collection_name: str = Field("mem0", description="Collection name")
+    embedding_model_dims: int = Field(1536, description="Embedding model dimensions")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }

mem0/configs/vector_stores/supabase.py

@@ -0,0 +1,44 @@
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class IndexMethod(str, Enum):
+    AUTO = "auto"
+    HNSW = "hnsw"
+    IVFFLAT = "ivfflat"
+
+
+class IndexMeasure(str, Enum):
+    COSINE = "cosine_distance"
+    L2 = "l2_distance"
+    L1 = "l1_distance"
+    MAX_INNER_PRODUCT = "max_inner_product"
+
+
+class SupabaseConfig(BaseModel):
+    connection_string: str = Field(..., description="PostgreSQL connection string")
+    collection_name: str = Field("mem0", description="Name for the vector collection")
+    embedding_model_dims: Optional[int] = Field(1536, description="Dimensions of the embedding model")
+    index_method: Optional[IndexMethod] = Field(IndexMethod.AUTO, description="Index method to use")
+    index_measure: Optional[IndexMeasure] = Field(IndexMeasure.COSINE, description="Distance measure to use")
+
+    @model_validator(mode="before")
+    def check_connection_string(cls, values):
+        conn_str = values.get("connection_string")
+        if not conn_str or not conn_str.startswith("postgresql://"):
+            raise ValueError("A valid PostgreSQL connection string must be provided")
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values

mem0/configs/vector_stores/upstash_vector.py

@@ -0,0 +1,36 @@
+import os
+from typing import Any, ClassVar, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+try:
+    from upstash_vector import Index
+except ImportError:
+    raise ImportError("The 'upstash_vector' library is required. Please install it using 'pip install upstash_vector'.")
+
+
+class UpstashVectorConfig(BaseModel):
+    Index: ClassVar[type] = Index
+
+    url: Optional[str] = Field(None, description="URL for Upstash Vector index")
+    token: Optional[str] = Field(None, description="Token for Upstash Vector index")
+    client: Optional[Index] = Field(None, description="Existing `upstash_vector.Index` client instance")
+    collection_name: str = Field("mem0", description="Namespace to use for the index")
+    enable_embeddings: bool = Field(
+        False, description="Whether to use built-in upstash embeddings or not. Default is True."
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_credentials_or_client(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        client = values.get("client")
+        url = values.get("url") or os.environ.get("UPSTASH_VECTOR_REST_URL")
+        token = values.get("token") or os.environ.get("UPSTASH_VECTOR_REST_TOKEN")
+
+        if not client and not (url and token):
+            raise ValueError("Either a client or URL and token must be provided.")
+        return values
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }

mem0/configs/vector_stores/vertex_ai_vector_search.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class GoogleMatchingEngineConfig(BaseModel):
+    project_id: str = Field(description="Google Cloud project ID")
+    project_number: str = Field(description="Google Cloud project number")
+    region: str = Field(description="Google Cloud region")
+    endpoint_id: str = Field(description="Vertex AI Vector Search endpoint ID")
+    index_id: str = Field(description="Vertex AI Vector Search index ID")
+    deployment_index_id: str = Field(description="Deployment-specific index ID")
+    collection_name: Optional[str] = Field(None, description="Collection name, defaults to index_id")
+    credentials_path: Optional[str] = Field(None, description="Path to service account credentials file")
+    vector_search_api_endpoint: Optional[str] = Field(None, description="Vector search API endpoint")
+
+    model_config = {"extra": "forbid"}
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if not self.collection_name:
+            self.collection_name = self.index_id
+
+    def model_post_init(self, _context) -> None:
+        """Set collection_name to index_id if not provided"""
+        if self.collection_name is None:
+            self.collection_name = self.index_id

mem0/configs/vector_stores/weaviate.py

@@ -0,0 +1,43 @@
+from typing import Any, ClassVar, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class WeaviateConfig(BaseModel):
+    from weaviate import WeaviateClient
+
+    WeaviateClient: ClassVar[type] = WeaviateClient
+
+    collection_name: str = Field("mem0", description="Name of the collection")
+    embedding_model_dims: int = Field(1536, description="Dimensions of the embedding model")
+    cluster_url: Optional[str] = Field(None, description="URL for Weaviate server")
+    auth_client_secret: Optional[str] = Field(None, description="API key for Weaviate authentication")
+    additional_headers: Optional[Dict[str, str]] = Field(None, description="Additional headers for requests")
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_connection_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        cluster_url = values.get("cluster_url")
+
+        if not cluster_url:
+            raise ValueError("'cluster_url' must be provided.")
+
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+
+        return values
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }

mem0/dbs/__init__.py

@@ -0,0 +1,4 @@
+from mem0.dbs.base import DBBase
+from mem0.dbs.mysql import MySQLManager
+
+__all__ = ["DBBase", "MySQLManager"]

mem0/dbs/base.py

@@ -0,0 +1,68 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from mem0.configs.dbs.base import BaseDBConfig
+
+
+class DBBase(ABC):
+    """Initialized a base database class
+
+    :param config: Database configuration option class, defaults to None
+    :type config: Optional[BaseDBConfig], optional
+    """
+
+    def __init__(self, config: Optional[BaseDBConfig] = None):
+        if config is None:
+            self.config = BaseDBConfig()
+        else:
+            self.config = config
+
+    @abstractmethod
+    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:
+        """Add a history record to the database.
+        
+        :param memory_id: The ID of the memory being tracked
+        :param old_memory: The previous memory content
+        :param new_memory: The new memory content
+        :param event: The type of event that occurred
+        :param created_at: When the record was created
+        :param updated_at: When the record was last updated
+        :param is_deleted: Whether the record is deleted (0 or 1)
+        :param actor_id: ID of the actor who made the change
+        :param role: Role of the actor
+        """
+        pass
+
+    @abstractmethod
+    def get_history(self, memory_id: str) -> List[Dict[str, Any]]:
+        """Retrieve history records for a given memory ID.
+        
+        :param memory_id: The ID of the memory to get history for
+        :return: List of history records as dictionaries
+        """
+        pass
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Reset/clear all data in the database."""
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """Close the database connection and clean up resources."""
+        pass
+
+    def __del__(self):
+        self.close()

mem0/dbs/configs.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class DBConfig(BaseModel):
+    provider: str = Field(
+        description="Provider of the database (e.g., 'mysql')",
+        default="mysql",
+    )
+    config: Optional[dict] = Field(description="Configuration for the specific database", default={})
+
+    @field_validator("config")
+    def validate_config(cls, v, values):
+        provider = values.data.get("provider")
+        if provider in [
+            "mysql",
+        ]:
+            return v
+        else:
+            raise ValueError(f"Unsupported database provider: {provider}")