mem0ai-azure-mysql 0.1.116.12__tar.gz → 0.2.1__tar.gz

mem0ai_azure_mysql-0.2.1/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: mem0ai-azure-mysql
+Version: 0.2.1
+Summary: Long-term memory for AI Agents with Azure DefaultAzureCredential authentication and MySQL history database support. Async-only API.
+Requires-Python: <4.0,>=3.10
+Requires-Dist: azure-identity>=1.24.0
+Requires-Dist: azure-search-documents>=11.5.3
+Requires-Dist: boto3>=1.34.0
+Requires-Dist: cohere>=5.17.0
+Requires-Dist: langchain-neo4j==0.6.0
+Requires-Dist: neo4j>=5.23.1
+Requires-Dist: openai<1.100.0,>=1.90.0
+Requires-Dist: posthog>=3.5.0
+Requires-Dist: protobuf>=5.29.0
+Requires-Dist: pydantic>=2.7.3
+Requires-Dist: pymysql
+Requires-Dist: pytz>=2024.1
+Requires-Dist: rank-bm25>=0.2.2
+Requires-Dist: sqlalchemy>=2.0.31
+Description-Content-Type: text/markdown
+
+# Mem0 - Azure Enhanced Fork
+
+This repository is an enhanced fork of [mem0ai/mem0](https://github.com/mem0ai/mem0.git) that provides enterprise-grade improvements for Azure environments and production deployments.
+
+## Key Enhancements
+
+### 1. Async-Only API
+- **AsyncMemory**: This fork provides only the async `AsyncMemory` class for better performance and scalability
+- **Simplified Codebase**: Removed synchronous `Memory` class to reduce code complexity and maintenance burden
+- **Modern Python**: Built for async/await patterns with full asyncio support
+
+### 2. Azure Entra ID Authentication
+- **Azure AI Search**: Support for Azure Entra ID (Azure AD) authentication using `DefaultAzureCredential`
+- **Azure OpenAI**: Seamless Entra ID integration for both LLM and embedding services
+- **Simplified Authentication**: No need to manage API keys when using managed identities or service principals
+
+### 3. MySQL Database Support
+- **Production-Ready**: Replace SQLite3 with enterprise-grade MySQL for scalable memory history storage
+- **Connection Pooling**: Built-in connection pooling and SSL support for secure connections
+- **Thread-Safe**: Thread-safe operations with proper connection management
+
+## Installation
+
+Install the enhanced package with Azure and MySQL dependencies:
+
+```bash
+pip install mem0ai-azure-mysql
+```
+
+Or with uv:
+
+```bash
+uv add mem0ai-azure-mysql
+```
+
+## Quick Start
+
+```python
+import asyncio
+from mem0 import AsyncMemory
+
+config = {
+    "vector_store": {
+        "provider": "azure_ai_search",
+        "config": {
+            "collection_name": "mem0",
+            "service_name": "your-search-service",
+            "embedding_model_dims": 1536,
+            "azure_ad_token": "<your-token>"  # Or use DefaultAzureCredential
+        },
+    },
+    "llm": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "gpt-4",
+            "azure_kwargs": {
+                "api_version": "2024-12-01-preview",
+                "azure_deployment": "gpt-4",
+                "azure_endpoint": "https://your-endpoint.openai.azure.com/",
+                "azure_ad_token": "<your-token>",
+            },
+        },
+    },
+    "embedder": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "text-embedding-3-small",
+            "embedding_dims": 1536,
+            "azure_kwargs": {
+                "api_version": "2024-12-01-preview",
+                "azure_deployment": "text-embedding-3-small",
+                "azure_endpoint": "https://your-endpoint.openai.azure.com/",
+                "azure_ad_token": "<your-token>",
+            },
+        },
+    },
+    "db": {
+        "provider": "mysql",
+        "config": {
+            "host": "your-mysql-server.mysql.database.azure.com",
+            "port": 3306,
+            "user": "mem0",
+            "password": "<your-password>",
+            "database": "mem0",
+            "ssl_enabled": True,
+        },
+    },
+}
+
+async def main():
+    memory = await AsyncMemory.from_config(config)
+
+    # Add memories
+    result = await memory.add(
+        "I love playing tennis on weekends",
+        user_id="user123"
+    )
+    print(result)
+
+    # Search memories
+    results = await memory.search("What sports do I like?", user_id="user123")
+    print(results)
+
+asyncio.run(main())
+```
+
+## Development
+
+### Setup with uv (Recommended)
+
+```bash
+# Install dependencies with dev extras
+uv sync --extra dev
+
+# Run example
+uv run python example.py
+
+# Run tests
+uv run pytest tests/
+```
+
+### Setup with hatch
+
+```bash
+# Create environment
+make install
+
+# Run tests
+make test
+```
+
+### Available Commands
+
+```bash
+make format    # Format code with ruff
+make lint      # Lint code with ruff
+make test      # Run tests
+make build     # Build package
+make clean     # Clean build artifacts
+```
+
+## API Reference
+
+### AsyncMemory
+
+The main class for interacting with the memory system.
+
+```python
+from mem0 import AsyncMemory
+
+# Create from config
+memory = await AsyncMemory.from_config(config)
+
+# Add memories
+await memory.add(messages, user_id="user123")
+
+# Search memories
+await memory.search(query, user_id="user123")
+
+# Get all memories
+await memory.get_all(user_id="user123")
+
+# Delete memories
+await memory.delete_all(user_id="user123")
+
+# Get memory by ID
+await memory.get(memory_id)
+
+# Update memory
+await memory.update(memory_id, new_data)
+
+# Get history
+await memory.history(memory_id)
+
+# Reset all
+await memory.reset()
+```
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the original [mem0](https://github.com/mem0ai/mem0) repository for details.

mem0ai_azure_mysql-0.2.1/README.md

@@ -0,0 +1,181 @@
+# Mem0 - Azure Enhanced Fork
+
+This repository is an enhanced fork of [mem0ai/mem0](https://github.com/mem0ai/mem0.git) that provides enterprise-grade improvements for Azure environments and production deployments.
+
+## Key Enhancements
+
+### 1. Async-Only API
+- **AsyncMemory**: This fork provides only the async `AsyncMemory` class for better performance and scalability
+- **Simplified Codebase**: Removed synchronous `Memory` class to reduce code complexity and maintenance burden
+- **Modern Python**: Built for async/await patterns with full asyncio support
+
+### 2. Azure Entra ID Authentication
+- **Azure AI Search**: Support for Azure Entra ID (Azure AD) authentication using `DefaultAzureCredential`
+- **Azure OpenAI**: Seamless Entra ID integration for both LLM and embedding services
+- **Simplified Authentication**: No need to manage API keys when using managed identities or service principals
+
+### 3. MySQL Database Support
+- **Production-Ready**: Replace SQLite3 with enterprise-grade MySQL for scalable memory history storage
+- **Connection Pooling**: Built-in connection pooling and SSL support for secure connections
+- **Thread-Safe**: Thread-safe operations with proper connection management
+
+## Installation
+
+Install the enhanced package with Azure and MySQL dependencies:
+
+```bash
+pip install mem0ai-azure-mysql
+```
+
+Or with uv:
+
+```bash
+uv add mem0ai-azure-mysql
+```
+
+## Quick Start
+
+```python
+import asyncio
+from mem0 import AsyncMemory
+
+config = {
+    "vector_store": {
+        "provider": "azure_ai_search",
+        "config": {
+            "collection_name": "mem0",
+            "service_name": "your-search-service",
+            "embedding_model_dims": 1536,
+            "azure_ad_token": "<your-token>"  # Or use DefaultAzureCredential
+        },
+    },
+    "llm": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "gpt-4",
+            "azure_kwargs": {
+                "api_version": "2024-12-01-preview",
+                "azure_deployment": "gpt-4",
+                "azure_endpoint": "https://your-endpoint.openai.azure.com/",
+                "azure_ad_token": "<your-token>",
+            },
+        },
+    },
+    "embedder": {
+        "provider": "azure_openai",
+        "config": {
+            "model": "text-embedding-3-small",
+            "embedding_dims": 1536,
+            "azure_kwargs": {
+                "api_version": "2024-12-01-preview",
+                "azure_deployment": "text-embedding-3-small",
+                "azure_endpoint": "https://your-endpoint.openai.azure.com/",
+                "azure_ad_token": "<your-token>",
+            },
+        },
+    },
+    "db": {
+        "provider": "mysql",
+        "config": {
+            "host": "your-mysql-server.mysql.database.azure.com",
+            "port": 3306,
+            "user": "mem0",
+            "password": "<your-password>",
+            "database": "mem0",
+            "ssl_enabled": True,
+        },
+    },
+}
+
+async def main():
+    memory = await AsyncMemory.from_config(config)
+
+    # Add memories
+    result = await memory.add(
+        "I love playing tennis on weekends",
+        user_id="user123"
+    )
+    print(result)
+
+    # Search memories
+    results = await memory.search("What sports do I like?", user_id="user123")
+    print(results)
+
+asyncio.run(main())
+```
+
+## Development
+
+### Setup with uv (Recommended)
+
+```bash
+# Install dependencies with dev extras
+uv sync --extra dev
+
+# Run example
+uv run python example.py
+
+# Run tests
+uv run pytest tests/
+```
+
+### Setup with hatch
+
+```bash
+# Create environment
+make install
+
+# Run tests
+make test
+```
+
+### Available Commands
+
+```bash
+make format    # Format code with ruff
+make lint      # Lint code with ruff
+make test      # Run tests
+make build     # Build package
+make clean     # Clean build artifacts
+```
+
+## API Reference
+
+### AsyncMemory
+
+The main class for interacting with the memory system.
+
+```python
+from mem0 import AsyncMemory
+
+# Create from config
+memory = await AsyncMemory.from_config(config)
+
+# Add memories
+await memory.add(messages, user_id="user123")
+
+# Search memories
+await memory.search(query, user_id="user123")
+
+# Get all memories
+await memory.get_all(user_id="user123")
+
+# Delete memories
+await memory.delete_all(user_id="user123")
+
+# Get memory by ID
+await memory.get(memory_id)
+
+# Update memory
+await memory.update(memory_id, new_data)
+
+# Get history
+await memory.history(memory_id)
+
+# Reset all
+await memory.reset()
+```
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the original [mem0](https://github.com/mem0ai/mem0) repository for details.

mem0ai_azure_mysql-0.2.1/mem0/__init__.py

@@ -0,0 +1,5 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("mem0ai-azure-mysql")
+
+from mem0.memory.main import AsyncMemory  # noqa

{mem0ai_azure_mysql-0.1.116.12 → mem0ai_azure_mysql-0.2.1}/mem0/configs/llms/base.py

@@ -29,7 +29,7 @@ class BaseLlmConfig(ABC):
         Initialize a base configuration class instance for the LLM.
 
         Args:
-            model: The model identifier to use (e.g., "gpt-4o-mini", "claude-3-5-sonnet-20240620")
+            model: The model identifier to use (e.g., "gpt-5.1", "claude-3-5-sonnet-20240620")
                 Defaults to None (will be set by provider-specific configs)
             temperature: Controls the randomness of the model's output.
                 Higher values (closer to 1) make output more random, lower values make it more deterministic.

{mem0ai_azure_mysql-0.1.116.12 → mem0ai_azure_mysql-0.2.1}/mem0/embeddings/configs.py

@@ -5,26 +5,15 @@ from pydantic import BaseModel, Field, field_validator
 
 class EmbedderConfig(BaseModel):
     provider: str = Field(
-        description="Provider of the embedding model (e.g., 'ollama', 'openai')",
-        default="openai",
+        description="Provider of the embedding model (e.g., 'azure_openai')",
+        default="azure_openai",
     )
     config: Optional[dict] = Field(description="Configuration for the specific embedding model", default={})
 
     @field_validator("config")
     def validate_config(cls, v, values):
         provider = values.data.get("provider")
-        if provider in [
-            "openai",
-            "ollama",
-            "huggingface",
-            "azure_openai",
-            "gemini",
-            "vertexai",
-            "together",
-            "lmstudio",
-            "langchain",
-            "aws_bedrock",
-        ]:
+        if provider in ["azure_openai"]:
             return v
         else:
             raise ValueError(f"Unsupported embedding provider: {provider}")

mem0ai_azure_mysql-0.2.1/mem0/graphs/configs.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from mem0.llms.configs import LlmConfig
+
+
+class RerankConfig(BaseModel):
+    provider: str = Field(
+        description="Provider of the rerank model (e.g., 'openai', 'azure', 'cohere')",
+        default="cohere",
+    )
+    config: Optional[dict] = Field(
+        description="Configuration for the specific rerank model", default={}
+    )
+
+class Neo4jConfig(BaseModel):
+    url: Optional[str] = Field(None, description="Host address for the graph database")
+    username: Optional[str] = Field(None, description="Username for the graph database")
+    password: Optional[str] = Field(None, description="Password for the graph database")
+    database: Optional[str] = Field(None, description="Database for the graph database")
+    base_label: Optional[bool] = Field(None, description="Whether to use base node label __Entity__ for all entities")
+    similarity_threshold: float = Field(0.7, description="Threshold for the similarity of nodes")
+    top_k: int = Field(5, description="Number of top scored results to return")
+    rerank: Optional[RerankConfig] = Field(None, description="Rerank configuration")
+
+    @model_validator(mode="before")
+    def check_host_port_or_path(cls, values):
+        url, username, password = (
+            values.get("url"),
+            values.get("username"),
+            values.get("password"),
+        )
+        if not url or not username or not password:
+            raise ValueError("Please provide 'url', 'username' and 'password'.")
+
+        if values.get("rerank") is not None:
+            values["rerank"] = RerankConfig(**values.get("rerank"))
+            if values["rerank"].provider not in ("cohere"):
+                raise ValueError("Invalid rerank provider. Supported providers are: cohere")
+
+        return values
+
+
+class GraphStoreConfig(BaseModel):
+    provider: str = Field(
+        description="Provider of the data store (e.g., 'neo4j')",
+        default="neo4j",
+    )
+    config: Optional[Neo4jConfig] = Field(
+        description="Configuration for the specific data store", default=None
+    )
+    llm: Optional[LlmConfig] = Field(description="LLM configuration for querying the graph store", default=None)
+    custom_prompt: Optional[str] = Field(
+        description="Custom prompt to fetch entities from the given text", default=None
+    )
+
+    @field_validator("config")
+    def validate_config(cls, v, values):
+        provider = values.data.get("provider")
+        if provider in ("neo4j", "default"):
+            return Neo4jConfig(**v.model_dump())
+        else:
+            raise ValueError(f"Unsupported graph store provider: {provider}")

{mem0ai_azure_mysql-0.1.116.12 → mem0ai_azure_mysql-0.2.1}/mem0/llms/azure_openai.py

@@ -36,7 +36,7 @@ class AzureOpenAILLM(LLMBase):
 
         # Model name should match the custom deployment name chosen for it.
         if not self.config.model:
-            self.config.model = "gpt-4o"
+            self.config.model = "gpt-5.1"
 
         api_key = self.config.azure_kwargs.api_key or os.getenv("LLM_AZURE_API_KEY")
         azure_ad_token = self.config.azure_kwargs.azure_ad_token or os.getenv("LLM_AZURE_AD_TOKEN")

{mem0ai_azure_mysql-0.1.116.12 → mem0ai_azure_mysql-0.2.1}/mem0/llms/configs.py

@@ -4,31 +4,13 @@ from pydantic import BaseModel, Field, field_validator
 
 
 class LlmConfig(BaseModel):
-    provider: str = Field(description="Provider of the LLM (e.g., 'ollama', 'openai')", default="openai")
+    provider: str = Field(description="Provider of the LLM (e.g., 'azure_openai')", default="azure_openai")
     config: Optional[dict] = Field(description="Configuration for the specific LLM", default={})
 
     @field_validator("config")
     def validate_config(cls, v, values):
         provider = values.data.get("provider")
-        if provider in (
-            "openai",
-            "ollama",
-            "anthropic",
-            "groq",
-            "together",
-            "aws_bedrock",
-            "litellm",
-            "azure_openai",
-            "openai_structured",
-            "azure_openai_structured",
-            "gemini",
-            "deepseek",
-            "xai",
-            "sarvam",
-            "lmstudio",
-            "vllm",
-            "langchain",
-        ):
+        if provider in ("azure_openai",):
             return v
         else:
             raise ValueError(f"Unsupported LLM provider: {provider}")