memorygraphMCP 0.11.7__py3-none-any.whl

memorygraph/backends/__init__.py

@@ -0,0 +1,21 @@
+"""
+Backend abstraction layer for the Claude Code Memory Server.
+
+This package provides a unified interface for different graph database backends,
+allowing the memory server to work with Neo4j, Memgraph, or SQLite.
+"""
+
+from .base import GraphBackend
+from .factory import BackendFactory
+
+# Backend classes are imported lazily via the factory to avoid
+# import-time dependencies on optional packages (neo4j, etc.)
+# Import them explicitly when needed:
+#   from memorygraph.backends.neo4j_backend import Neo4jBackend
+#   from memorygraph.backends.memgraph_backend import MemgraphBackend
+#   from memorygraph.backends.sqlite_fallback import SQLiteFallbackBackend
+
+__all__ = [
+    "GraphBackend",
+    "BackendFactory",
+]

memorygraph/backends/base.py

@@ -0,0 +1,179 @@
+"""
+Abstract base class for graph database backends.
+
+This module defines the interface that all backend implementations must follow,
+ensuring compatibility across Neo4j, Memgraph, and SQLite fallback.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+class GraphBackend(ABC):
+    """
+    Abstract base class for graph database backends.
+
+    All backend implementations (Neo4j, Memgraph, SQLite) must implement
+    this interface to ensure compatibility with the memory server.
+    """
+
+    @abstractmethod
+    async def connect(self) -> bool:
+        """
+        Establish connection to the database backend.
+
+        Returns:
+            bool: True if connection successful, False otherwise
+
+        Raises:
+            DatabaseConnectionError: If connection cannot be established
+        """
+        pass
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """
+        Close the database connection and clean up resources.
+
+        This method should be idempotent and safe to call multiple times.
+        """
+        pass
+
+    @abstractmethod
+    async def execute_query(
+        self,
+        query: str,
+        parameters: Optional[dict[str, Any]] = None,
+        write: bool = False
+    ) -> list[dict[str, Any]]:
+        """
+        Execute a Cypher query and return results.
+
+        Args:
+            query: The Cypher query string
+            parameters: Query parameters for parameterized queries
+            write: Whether this is a write operation (default: False)
+
+        Returns:
+            List of result records as dictionaries
+
+        Raises:
+            DatabaseConnectionError: If not connected
+            Exception: For query execution errors
+        """
+        pass
+
+    @abstractmethod
+    async def initialize_schema(self) -> None:
+        """
+        Initialize database schema including indexes and constraints.
+
+        This should be idempotent and safe to call multiple times.
+
+        Raises:
+            SchemaError: If schema initialization fails
+        """
+        pass
+
+    @abstractmethod
+    async def health_check(self) -> dict[str, Any]:
+        """
+        Check backend health and return status information.
+
+        Returns:
+            Dictionary with health check results:
+                - connected: bool
+                - backend_type: str
+                - version: str (if available)
+                - statistics: dict (optional)
+        """
+        pass
+
+    @abstractmethod
+    def backend_name(self) -> str:
+        """
+        Return the name of this backend implementation.
+
+        Returns:
+            Backend name (e.g., "neo4j", "memgraph", "sqlite")
+        """
+        pass
+
+    @abstractmethod
+    def supports_fulltext_search(self) -> bool:
+        """
+        Check if this backend supports full-text search.
+
+        Returns:
+            True if full-text search is supported
+        """
+        pass
+
+    @abstractmethod
+    def supports_transactions(self) -> bool:
+        """
+        Check if this backend supports ACID transactions.
+
+        Returns:
+            True if transactions are supported
+        """
+        pass
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.disconnect()
+        return False
+
+    # Compatibility methods for legacy MemoryDatabase interface
+    async def execute_write_query(
+        self,
+        query: str,
+        parameters: Optional[dict[str, Any]] = None
+    ) -> list[dict[str, Any]]:
+        """
+        Execute a write query (compatibility wrapper for execute_query).
+
+        This method provides compatibility with the legacy Neo4jConnection interface
+        used by MemoryDatabase.
+
+        Args:
+            query: The Cypher query string
+            parameters: Query parameters for parameterized queries
+
+        Returns:
+            List of result records as dictionaries
+        """
+        return await self.execute_query(query, parameters, write=True)
+
+    async def execute_read_query(
+        self,
+        query: str,
+        parameters: Optional[dict[str, Any]] = None
+    ) -> list[dict[str, Any]]:
+        """
+        Execute a read query (compatibility wrapper for execute_query).
+
+        This method provides compatibility with the legacy Neo4jConnection interface
+        used by MemoryDatabase.
+
+        Args:
+            query: The Cypher query string
+            parameters: Query parameters for parameterized queries
+
+        Returns:
+            List of result records as dictionaries
+        """
+        return await self.execute_query(query, parameters, write=False)
+
+    async def close(self) -> None:
+        """
+        Close the connection (compatibility wrapper for disconnect).
+
+        This method provides compatibility with the legacy Neo4jConnection interface.
+        """
+        await self.disconnect()

memorygraph/backends/cloud.py

@@ -0,0 +1,75 @@
+"""
+Cloud backend for MemoryGraph.
+
+This is a placeholder for future cloud sync functionality.
+When MEMORYGRAPH_API_KEY is set, this backend will sync
+memories to the MemoryGraph cloud service.
+
+NOTE: This backend is not yet implemented. Use Turso backend
+for cloud persistence today.
+"""
+
+from typing import Any, Optional
+from .base import GraphBackend
+from ..models import DatabaseConnectionError
+
+
+class CloudBackend(GraphBackend):
+    """Placeholder for cloud backend implementation."""
+
+    def __init__(self, api_key: str, api_url: str = "https://api.memorygraph.dev"):
+        """
+        Initialize cloud backend.
+
+        Args:
+            api_key: MemoryGraph API key
+            api_url: MemoryGraph API endpoint URL
+
+        Raises:
+            NotImplementedError: Cloud backend not yet available
+        """
+        self.api_key = api_key
+        self.api_url = api_url
+
+        raise NotImplementedError(
+            "Cloud backend coming soon. "
+            "For persistent cloud storage, use Turso backend: "
+            "pip install memorygraphMCP[turso] and set TURSO_DATABASE_URL"
+        )
+
+    async def connect(self) -> bool:
+        """Not implemented."""
+        raise NotImplementedError("Cloud backend not yet available")
+
+    async def disconnect(self) -> None:
+        """Not implemented."""
+        raise NotImplementedError("Cloud backend not yet available")
+
+    async def execute_query(
+        self,
+        query: str,
+        parameters: Optional[dict[str, Any]] = None,
+        write: bool = False,
+    ) -> list[dict[str, Any]]:
+        """Not implemented."""
+        raise NotImplementedError("Cloud backend not yet available")
+
+    async def initialize_schema(self) -> None:
+        """Not implemented."""
+        raise NotImplementedError("Cloud backend not yet available")
+
+    async def health_check(self) -> dict[str, Any]:
+        """Not implemented."""
+        raise NotImplementedError("Cloud backend not yet available")
+
+    def backend_name(self) -> str:
+        """Return backend identifier."""
+        return "cloud"
+
+    def supports_fulltext_search(self) -> bool:
+        """Not implemented."""
+        return False
+
+    def supports_transactions(self) -> bool:
+        """Not implemented."""
+        return False