better-mem0-mcp 1.1.0b8__py3-none-any.whl

better_mem0_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""better-mem0-mcp: Zero-setup MCP Server for AI memory."""
+
+from .server import main
+
+__all__ = ["main"]

better_mem0_mcp/config.py

@@ -0,0 +1,176 @@
+"""
+better-mem0-mcp: Zero-setup MCP Server for AI memory.
+
+Configuration via environment variables:
+- DATABASE_URL: PostgreSQL connection string
+- API_KEYS: Provider:key pairs (e.g., "gemini:AIza...,openai:sk-xxx")
+- LLM_MODELS: Model fallback chain (e.g., "gemini/gemini-3-flash-preview,openai/gpt-4o-mini")
+- EMBEDDER_MODELS: Embedding fallback chain
+"""
+
+import os
+from functools import lru_cache
+from urllib.parse import parse_qs, urlparse
+
+from pydantic import ConfigDict
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Configuration with multi-key and fallback support."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    # Database (Required)
+    database_url: str = ""
+
+    # API Keys: "provider:key,provider:key,..."
+    api_keys: str = ""
+
+    # Models with fallback: "provider/model,provider/model,..."
+    # Note: For >2000 dims, HNSW index is disabled (uses exact search)
+    llm_models: str = "gemini/gemini-3-flash-preview"
+    embedder_models: str = "gemini/gemini-embedding-001"
+
+    def setup_api_keys(self) -> dict[str, list[str]]:
+        """
+        Parse API_KEYS and set environment variables for LiteLLM.
+
+        Returns:
+            Dict mapping provider to list of API keys.
+        """
+        env_map = {
+            "gemini": "GOOGLE_API_KEY",
+            "openai": "OPENAI_API_KEY",
+            "anthropic": "ANTHROPIC_API_KEY",
+            "groq": "GROQ_API_KEY",
+            "deepseek": "DEEPSEEK_API_KEY",
+            "mistral": "MISTRAL_API_KEY",
+        }
+
+        keys_by_provider: dict[str, list[str]] = {}
+
+        for pair in self.api_keys.split(","):
+            pair = pair.strip()
+            if ":" not in pair:
+                continue
+
+            provider, key = pair.split(":", 1)
+            provider = provider.strip().lower()
+            key = key.strip()
+
+            if not key:
+                continue
+
+            keys_by_provider.setdefault(provider, []).append(key)
+
+        # Set first key of each provider as env var (LiteLLM reads from env)
+        for provider, keys in keys_by_provider.items():
+            if provider in env_map and keys:
+                os.environ[env_map[provider]] = keys[0]
+
+        return keys_by_provider
+
+    def parse_database_url(self) -> dict:
+        """Parse DATABASE_URL into connection parameters."""
+        if not self.database_url:
+            return {}
+
+        parsed = urlparse(self.database_url)
+        query = parse_qs(parsed.query)
+
+        return {
+            "dbname": parsed.path[1:] if parsed.path else "mem0",
+            "user": parsed.username or "postgres",
+            "password": parsed.password or "",
+            "host": parsed.hostname or "localhost",
+            "port": parsed.port or 5432,
+            "sslmode": query.get("sslmode", ["prefer"])[0],
+        }
+
+    def get_llm_config(self) -> dict:
+        """Build Mem0 LLM configuration with fallback."""
+        models = [m.strip() for m in self.llm_models.split(",") if m.strip()]
+
+        if not models:
+            models = ["gemini/gemini-3-flash-preview"]
+
+        primary = models[0]
+        fallbacks = models[1:] if len(models) > 1 else None
+
+        # Gemini 3 models require temperature=1.0 to avoid infinite loops
+        temperature = 1.0 if "gemini-3" in primary else 0.1
+
+        config: dict = {
+            "provider": "litellm",
+            "config": {
+                "model": primary,
+                "temperature": temperature,
+            },
+        }
+
+        if fallbacks:
+            config["config"]["fallbacks"] = fallbacks
+            config["config"]["num_retries"] = 2
+
+        return config
+
+    def get_embedder_config(self) -> dict:
+        """Build Mem0 embedder configuration."""
+        models = [m.strip() for m in self.embedder_models.split(",") if m.strip()]
+
+        primary = models[0]
+
+        # Parse provider/model
+        if "/" in primary:
+            parts = primary.split("/", 1)
+            provider = parts[0]
+            model = parts[1]
+        else:
+            provider = "openai"
+            model = primary
+
+        # Fixed 1536 dims for all models:
+        # - Compatible with pgvector HNSW index (limit: 2000)
+        # - Good balance between quality and storage
+        # - Matryoshka models (gemini-embedding-001, text-embedding-3-*) support any dimension
+        embedding_dims = 1536
+
+        return {
+            "provider": provider,
+            "config": {
+                "model": model,
+                "embedding_dims": embedding_dims,
+            },
+        }
+
+    def get_mem0_config(self) -> dict:
+        """Build complete Mem0 configuration."""
+        embedder_config = self.get_embedder_config()
+
+        # Get embedding dimensions from embedder config
+        embedding_dims = embedder_config.get("config", {}).get("embedding_dims", 1536)
+
+        # Disable HNSW for dims > 2000 (pgvector HNSW limit)
+        # Uses exact search instead of ANN - slower but works with any dimensions
+        use_hnsw = embedding_dims <= 2000
+
+        return {
+            "vector_store": {
+                "provider": "pgvector",
+                "config": {
+                    "collection_name": "mem0_memories",
+                    "connection_string": self.database_url,
+                    "embedding_model_dims": embedding_dims,
+                    "hnsw": use_hnsw,
+                },
+            },
+            "llm": self.get_llm_config(),
+            "embedder": embedder_config,
+        }
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance."""
+    return Settings()

better_mem0_mcp/docs/memory.md

@@ -0,0 +1,47 @@
+# memory - Full Documentation
+
+## Overview
+Memory operations for AI agents: add, search, list, delete.
+
+Uses Mem0 for vector memory (pgvector) and SQL-based graph storage.
+
+## Actions
+
+### add
+Save information to long-term memory. Mem0 automatically:
+- Extracts key facts
+- Creates embeddings for semantic search
+- Deduplicates similar memories
+
+```json
+{"action": "add", "content": "User prefers dark mode and uses FastAPI"}
+```
+
+### search
+Semantic search across stored memories. Combines vector search with graph context.
+
+```json
+{"action": "search", "query": "coding preferences", "limit": 5}
+```
+
+### list
+Get all stored memories for a user.
+
+```json
+{"action": "list"}
+```
+
+### delete
+Remove a memory by ID.
+
+```json
+{"action": "delete", "memory_id": "abc12345-..."}
+```
+
+## Parameters
+- `action` - Required: add, search, list, delete
+- `content` - Required for add: information to remember
+- `query` - Required for search: what to search for
+- `memory_id` - Required for delete: ID of memory to remove
+- `limit` - Optional for search: max results (default: 5)
+- `user_id` - Optional: scope memories to a specific user

better_mem0_mcp/graph.py

@@ -0,0 +1,172 @@
+"""SQL-based Graph Storage - works with any PostgreSQL, no extensions needed."""
+
+from typing import Any
+
+import psycopg
+from loguru import logger
+
+
+class SQLGraphStore:
+    """Graph storage using plain SQL tables (nodes + edges)."""
+
+    INIT_SQL = """
+    CREATE TABLE IF NOT EXISTS graph_nodes (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        label VARCHAR(50) NOT NULL,
+        name VARCHAR(255),
+        properties JSONB DEFAULT '{}',
+        user_id VARCHAR(100) NOT NULL,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+    );
+
+    CREATE TABLE IF NOT EXISTS graph_edges (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        from_node_id UUID REFERENCES graph_nodes(id) ON DELETE CASCADE,
+        to_node_id UUID REFERENCES graph_nodes(id) ON DELETE CASCADE,
+        relationship VARCHAR(100) NOT NULL,
+        properties JSONB DEFAULT '{}',
+        created_at TIMESTAMPTZ DEFAULT NOW()
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_graph_nodes_user ON graph_nodes(user_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_nodes_name ON graph_nodes(name);
+    CREATE INDEX IF NOT EXISTS idx_graph_nodes_label ON graph_nodes(label);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_from ON graph_edges(from_node_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_to ON graph_edges(to_node_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_rel ON graph_edges(relationship);
+    """
+
+    def __init__(self, conn_params: dict[str, Any]):
+        """Initialize graph store with database connection parameters."""
+        self.conn_params = {
+            k: v
+            for k, v in conn_params.items()
+            if k in ("host", "port", "dbname", "user", "password")
+        }
+        # Add sslmode if present
+        if "sslmode" in conn_params:
+            self.conn_params["sslmode"] = conn_params["sslmode"]
+        self._init_tables()
+
+    def _get_connection(self):
+        """Get a new database connection."""
+        return psycopg.connect(**self.conn_params)
+
+    def _init_tables(self):
+        """Initialize graph tables if not exist."""
+        try:
+            with self._get_connection() as conn:
+                conn.execute(self.INIT_SQL)
+                conn.commit()
+            logger.info("Graph tables initialized")
+        except Exception as e:
+            logger.warning(f"Graph init failed (may already exist): {e}")
+
+    def add_node(
+        self,
+        label: str,
+        name: str,
+        user_id: str,
+        properties: dict | None = None,
+    ) -> str | None:
+        """Add or get existing node. Returns node ID."""
+        try:
+            with self._get_connection() as conn:
+                # Check if exists
+                result = conn.execute(
+                    "SELECT id FROM graph_nodes WHERE label = %s AND name = %s AND user_id = %s",
+                    (label, name, user_id),
+                ).fetchone()
+
+                if result:
+                    return str(result[0])
+
+                # Create new
+                from psycopg.types.json import Json
+
+                result = conn.execute(
+                    """INSERT INTO graph_nodes (label, name, properties, user_id)
+                       VALUES (%s, %s, %s, %s) RETURNING id""",
+                    (label, name, Json(properties or {}), user_id),
+                ).fetchone()
+                conn.commit()
+                return str(result[0]) if result else None
+        except Exception as e:
+            logger.error(f"Failed to add node: {e}")
+            return None
+
+    def add_edge(
+        self,
+        from_id: str,
+        to_id: str,
+        relationship: str,
+        properties: dict | None = None,
+    ) -> bool:
+        """Add edge between nodes."""
+        try:
+            with self._get_connection() as conn:
+                from psycopg.types.json import Json
+
+                conn.execute(
+                    """INSERT INTO graph_edges (from_node_id, to_node_id, relationship, properties)
+                       VALUES (%s, %s, %s, %s)
+                       ON CONFLICT DO NOTHING""",
+                    (from_id, to_id, relationship, Json(properties or {})),
+                )
+                conn.commit()
+                return True
+        except Exception as e:
+            logger.error(f"Failed to add edge: {e}")
+            return False
+
+    def find_related(self, name: str, user_id: str, limit: int = 10) -> list[dict]:
+        """Find nodes related to a name."""
+        try:
+            with self._get_connection() as conn:
+                results = conn.execute(
+                    """
+                    SELECT DISTINCT n2.label, n2.name, e.relationship
+                    FROM graph_nodes n1
+                    JOIN graph_edges e ON n1.id = e.from_node_id OR n1.id = e.to_node_id
+                    JOIN graph_nodes n2 ON (e.to_node_id = n2.id OR e.from_node_id = n2.id)
+                        AND n2.id != n1.id
+                    WHERE n1.name ILIKE %s AND n1.user_id = %s
+                    LIMIT %s
+                    """,
+                    (f"%{name}%", user_id, limit),
+                ).fetchall()
+
+                return [
+                    {"label": r[0], "name": r[1], "relationship": r[2]} for r in results
+                ]
+        except Exception as e:
+            logger.error(f"Failed to find related: {e}")
+            return []
+
+    def get_context(self, query: str, user_id: str) -> str:
+        """Get graph context for a query (find related entities)."""
+        words = [w for w in query.split() if len(w) > 3]
+        related: list[dict] = []
+
+        for word in words[:5]:  # Limit to first 5 significant words
+            related.extend(self.find_related(word, user_id, limit=3))
+
+        if not related:
+            return ""
+
+        # Deduplicate
+        seen = set()
+        unique = []
+        for r in related:
+            key = (r["name"], r["relationship"])
+            if key not in seen:
+                seen.add(key)
+                unique.append(r)
+
+        if not unique:
+            return ""
+
+        lines = [
+            f"- {r['name']} ({r['label']}) - {r['relationship']}" for r in unique[:5]
+        ]
+        return "Related context:\n" + "\n".join(lines)

better_mem0_mcp/server.py

@@ -0,0 +1,177 @@
+"""
+better-mem0-mcp MCP Server.
+
+Tiered Description Pattern:
+- Tier 1: Compressed descriptions in tool definitions (~150 tokens)
+- Tier 2: Full docs via `help` tool (on-demand, ~500 tokens)
+- Tier 3: MCP Resources for supported clients
+"""
+
+from pathlib import Path
+
+from loguru import logger
+from mcp.server.fastmcp import FastMCP
+
+from .config import get_settings
+
+# Initialize MCP Server
+mcp = FastMCP("better-mem0-mcp")
+
+# Lazy-initialized globals
+_memory = None
+_graph = None
+_settings = None
+
+DEFAULT_USER = "default"
+
+
+def _init():
+    """Lazy initialization of memory and graph stores."""
+    global _memory, _graph, _settings
+
+    if _settings is not None:
+        return
+
+    _settings = get_settings()
+
+    # Validate required settings
+    if not _settings.database_url:
+        raise ValueError("DATABASE_URL is required")
+    if not _settings.api_keys:
+        raise ValueError("API_KEYS is required")
+
+    # Setup API keys (sets env vars for LiteLLM)
+    keys_by_provider = _settings.setup_api_keys()
+    logger.info(f"API keys configured for: {list(keys_by_provider.keys())}")
+
+    # Initialize Mem0 Memory (Vector Store)
+    from mem0 import Memory
+
+    mem0_config = _settings.get_mem0_config()
+    _memory = Memory.from_config(mem0_config)
+    logger.info(f"Vector Memory initialized: {_settings.llm_models.split(',')[0]}")
+
+    # Initialize Graph Store (SQL-based)
+    try:
+        from .graph import SQLGraphStore
+
+        _graph = SQLGraphStore(_settings.parse_database_url())
+        logger.info("Graph Memory initialized (SQL)")
+    except Exception as e:
+        logger.warning(f"Graph Memory disabled: {e}")
+
+
+def _load_doc(name: str) -> str:
+    """Load documentation file from docs/ directory."""
+    docs_dir = Path(__file__).parent / "docs"
+    doc_file = docs_dir / f"{name}.md"
+    if doc_file.exists():
+        return doc_file.read_text()
+    return f"Documentation not found: {name}"
+
+
+# =============================================================================
+# Tool: memory
+# Tier 1: Compressed description
+# =============================================================================
+@mcp.tool()
+async def memory(
+    action: str,
+    content: str | None = None,
+    query: str | None = None,
+    memory_id: str | None = None,
+    user_id: str | None = None,
+    limit: int = 5,
+) -> str:
+    """
+    Memory operations: add, search, list, delete.
+    - add: Save information (requires content)
+    - search: Find memories (requires query)
+    - list: Get all memories
+    - delete: Remove by ID (requires memory_id)
+    Use `help` tool for full documentation.
+    """
+    _init()
+
+    user_id = user_id or DEFAULT_USER
+
+    try:
+        if action == "add":
+            if not content:
+                return "Error: 'content' required for add action"
+
+            result = _memory.add(content, user_id=user_id)
+            logger.info(f"Added memory for {user_id}: {content[:50]}...")
+            return f"Saved: {result}"
+
+        elif action == "search":
+            if not query:
+                return "Error: 'query' required for search action"
+
+            # Vector search
+            results = _memory.search(query, user_id=user_id, limit=limit)
+
+            # Add graph context
+            graph_context = ""
+            if _graph:
+                graph_context = _graph.get_context(query, user_id)
+
+            if not results and not graph_context:
+                return "No memories found."
+
+            output = ""
+            if results:
+                output = "Memories:\n" + "\n".join(
+                    [f"- {r.get('memory', str(r))}" for r in results]
+                )
+            if graph_context:
+                output += f"\n\n{graph_context}"
+
+            return output
+
+        elif action == "list":
+            results = _memory.get_all(user_id=user_id)
+
+            if not results:
+                return "No memories stored."
+
+            lines = [f"- [{r['id'][:8]}] {r['memory']}" for r in results]
+            return f"Memories ({len(results)}):\n" + "\n".join(lines)
+
+        elif action == "delete":
+            if not memory_id:
+                return "Error: 'memory_id' required for delete action"
+
+            _memory.delete(memory_id)
+            logger.info(f"Deleted memory: {memory_id}")
+            return f"Deleted: {memory_id}"
+
+        else:
+            return f"Unknown action: {action}. Use: add, search, list, delete"
+
+    except Exception as e:
+        logger.error(f"Memory operation failed: {e}")
+        return f"Error: {e}"
+
+
+# =============================================================================
+# Tool: help
+# Tier 2: Full documentation on-demand
+# =============================================================================
+@mcp.tool()
+async def help(tool_name: str = "memory") -> str:
+    """
+    Get full documentation for a tool.
+    Use when compressed descriptions are insufficient.
+    """
+    return _load_doc(tool_name)
+
+
+def main():
+    """Entry point for MCP server."""
+    logger.info("Starting better-mem0-mcp server (stdio)")
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

better_mem0_mcp-1.1.0b8.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: better-mem0-mcp
+Version: 1.1.0b8
+Summary: Zero-setup MCP Server for AI memory - works with Neon/Supabase
+Project-URL: Homepage, https://github.com/n24q02m/better-mem0-mcp
+Project-URL: Repository, https://github.com/n24q02m/better-mem0-mcp.git
+Project-URL: Issues, https://github.com/n24q02m/better-mem0-mcp/issues
+Author-email: n24q02m <quangminh2422004@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai-agent,llm,mcp,mem0,memory,pgvector
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.13
+Requires-Dist: google-genai>=1.0.0
+Requires-Dist: litellm>=1.0.0
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: mem0ai>=0.1.0
+Requires-Dist: psycopg[binary,pool]>=3.1.0
+Requires-Dist: pydantic-settings>=2.0.0
+Description-Content-Type: text/markdown
+
+# better-mem0-mcp
+
+**Zero-setup** MCP Server for AI memory. Works with Neon/Supabase free tier.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Quick Start
+
+### 1. Get Prerequisites
+
+- **Database**: [Neon](https://neon.tech) or [Supabase](https://supabase.com) (free tier)
+- **API Key**: [Google AI Studio](https://aistudio.google.com/apikey) (free tier)
+
+### 2. Add to mcp.json
+
+#### uvx (Recommended)
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "uvx",
+      "args": ["better-mem0-mcp"],
+      "env": {
+        "DATABASE_URL": "postgresql://user:pass@xxx.neon.tech/neondb?sslmode=require",
+        "API_KEYS": "gemini:AIza..."
+      }
+    }
+  }
+}
+```
+
+#### Docker
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "docker",
+      "args": ["run", "-i", "--rm", "-e", "DATABASE_URL", "-e", "API_KEYS", "n24q02m/better-mem0-mcp:latest"],
+      "env": {
+        "DATABASE_URL": "postgresql://...",
+        "API_KEYS": "gemini:AIza..."
+      }
+    }
+  }
+}
+```
+
+### 3. Done!
+
+Ask Claude: "Remember that I prefer dark mode and use FastAPI"
+
+---
+
+## Configuration
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `DATABASE_URL` | Yes | PostgreSQL connection string |
+| `API_KEYS` | Yes | `provider:key,...` (multi-key per provider OK) |
+| `LLM_MODELS` | No | `provider/model,...` (fallback chain) |
+| `EMBEDDER_MODELS` | No | `provider/model,...` (fallback chain) |
+
+### Examples
+
+**Minimal (Gemini only):**
+```
+API_KEYS=gemini:AIza...
+```
+
+**Multi-key with fallback:**
+```
+API_KEYS=gemini:AIza-1,gemini:AIza-2,openai:sk-xxx
+LLM_MODELS=gemini/gemini-2.5-flash,openai/gpt-4o-mini
+EMBEDDER_MODELS=gemini/gemini-embedding-001,openai/text-embedding-3-small
+```
+
+### Defaults
+
+| Setting | Default |
+|---------|---------|
+| `LLM_MODELS` | `gemini/gemini-2.5-flash` |
+| `EMBEDDER_MODELS` | `gemini/gemini-embedding-001` |
+
+---
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `memory` | `action`: add, search, list, delete |
+| `help` | Detailed documentation |
+
+### Usage
+
+```json
+{"action": "add", "content": "I prefer TypeScript over JavaScript"}
+{"action": "search", "query": "preferences"}
+{"action": "list"}
+{"action": "delete", "memory_id": "abc123"}
+```
+
+---
+
+## Why better-mem0-mcp?
+
+| Feature | Official mem0-mcp | better-mem0-mcp |
+|---------|-------------------|-----------------|
+| Storage | Mem0 Cloud | **Self-hosted PostgreSQL** |
+| Graph Memory | No | **Yes (SQL-based)** |
+| LLM Provider | OpenAI only | **Any (Gemini/OpenAI/Ollama/...)** |
+| Fallback | No | **Yes (multi-key + multi-model)** |
+| Setup | API Key | **DATABASE_URL + API_KEYS** |
+
+---
+
+## License
+
+MIT

better_mem0_mcp-1.1.0b8.dist-info/RECORD

@@ -0,0 +1,11 @@
+better_mem0_mcp/__init__.py,sha256=fcqgbz2HvMCPidqqoPvtRky5pGIHP2w9oVim7UQkuBc,106
+better_mem0_mcp/config.py,sha256=vgKLIw3jHyeBLTzzBnuHV5x6Nra0Rbav1IJRL8rLCuk,5576
+better_mem0_mcp/graph.py,sha256=rE9z6XECiAktEqDNgmwqCpFpvKSn3azO9H4sRBhj8UU,6195
+better_mem0_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+better_mem0_mcp/server.py,sha256=O6s0L1FggB9FDfX4OKF6govrRznwUIAh9RkFRCrYX3Y,5124
+better_mem0_mcp/docs/memory.md,sha256=jqoxBYHVh2N9TZbt77qY5zhL1vSU-Ro-yuaczT1r7Mo,1126
+better_mem0_mcp-1.1.0b8.dist-info/METADATA,sha256=5YzOORgrypbkhJIhVf7sQpcs3ceqGz4QTNMn6Ix8ahM,3873
+better_mem0_mcp-1.1.0b8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+better_mem0_mcp-1.1.0b8.dist-info/entry_points.txt,sha256=2b7E3D6yo94mQXP2Ms0bhUlWkK9f664f0GrstImOq30,57
+better_mem0_mcp-1.1.0b8.dist-info/licenses/LICENSE,sha256=d7xQ6sRyeGus6gnvwgqiQtSY7XdFw0Jd0w5-Co_xHnk,1064
+better_mem0_mcp-1.1.0b8.dist-info/RECORD,,

better_mem0_mcp-1.1.0b8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

better_mem0_mcp-1.1.0b8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+better-mem0-mcp = better_mem0_mcp:main

better_mem0_mcp-1.1.0b8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 n24q02m
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.