memorygraphMCP 0.11.7__py3-none-any.whl

memorygraph/utils/pagination.py

@@ -0,0 +1,149 @@
+"""
+Pagination utilities for working with memories across different backends.
+
+Provides reusable pagination helpers that work with both MemoryDatabase
+and SQLiteMemoryDatabase interfaces.
+"""
+
+import logging
+from typing import AsyncIterator, List, Callable, Optional
+
+from ..models import Memory, SearchQuery
+
+logger = logging.getLogger(__name__)
+
+
+async def paginate_memories(
+    db,  # MemoryDatabase or SQLiteMemoryDatabase
+    batch_size: int = 1000,
+    progress_callback: Optional[Callable[[int], None]] = None
+) -> AsyncIterator[List[Memory]]:
+    """
+    Async generator that yields batches of memories.
+
+    Works with both MemoryDatabase and SQLiteMemoryDatabase by using
+    the search_memories interface with pagination support.
+
+    Args:
+        db: Database instance (any backend)
+        batch_size: Number of memories to fetch per batch
+        progress_callback: Optional callback(total_yielded) for progress reporting
+
+    Yields:
+        Batches of Memory objects
+
+    Example:
+        async for batch in paginate_memories(db, batch_size=500):
+            for memory in batch:
+                print(memory.title)
+    """
+    offset = 0
+    total_yielded = 0
+
+    while True:
+        query = SearchQuery(
+            query="",  # Empty query matches all memories
+            limit=batch_size,
+            offset=offset,
+            match_mode="any"
+        )
+
+        # Use paginated search if available, fallback to regular search
+        if hasattr(db, 'search_memories_paginated'):
+            result = await db.search_memories_paginated(query)
+            memories = result.results
+            has_more = result.has_more
+        else:
+            # Fallback for backends without pagination
+            memories = await db.search_memories(query)
+            has_more = len(memories) >= batch_size
+
+        if memories:
+            yield memories
+            total_yielded += len(memories)
+
+            if progress_callback:
+                progress_callback(total_yielded)
+
+        if not has_more or not memories:
+            break
+
+        offset += batch_size
+
+
+async def count_memories(db) -> int:
+    """
+    Count total memories in database using efficient method.
+
+    Args:
+        db: Database instance (any backend)
+
+    Returns:
+        Total number of memories
+    """
+    query = SearchQuery(query="", limit=1, offset=0, match_mode="any")
+
+    # Use paginated search for efficient counting if available
+    if hasattr(db, 'search_memories_paginated'):
+        result = await db.search_memories_paginated(query)
+        return result.total_count
+    else:
+        # Fallback: count manually by iterating
+        count = 0
+        async for batch in paginate_memories(db, batch_size=1000):
+            count += len(batch)
+        return count
+
+
+async def count_relationships(db) -> int:
+    """
+    Count total relationships in database.
+
+    Args:
+        db: Database instance (any backend)
+
+    Returns:
+        Total number of relationships (deduplicated)
+    """
+    count = 0
+    seen_relationships = set()
+
+    async for batch in paginate_memories(db, batch_size=1000):
+        for memory in batch:
+            try:
+                related = await db.get_related_memories(memory.id, max_depth=1)
+                for _, relationship in related:
+                    # Use tuple as key for deduplication
+                    key = (
+                        relationship.from_memory_id,
+                        relationship.to_memory_id,
+                        relationship.type.value
+                    )
+                    if key not in seen_relationships:
+                        seen_relationships.add(key)
+                        count += 1
+            except Exception as e:
+                logger.warning(f"Failed to count relationships for memory {memory.id}: {e}")
+                continue
+
+    return count
+
+
+async def get_all_memories(db) -> List[Memory]:
+    """
+    Get all memories from database.
+
+    Args:
+        db: Database instance (any backend)
+
+    Returns:
+        List of all memories
+
+    Warning:
+        This loads all memories into memory. For large databases,
+        prefer using paginate_memories() to process in batches.
+    """
+    all_memories = []
+    async for batch in paginate_memories(db, batch_size=1000):
+        all_memories.extend(batch)
+    return all_memories

memorygraph/utils/project_detection.py

@@ -0,0 +1,133 @@
+"""
+Project context detection utilities.
+
+Auto-detects project name and context from environment.
+"""
+
+import os
+import subprocess
+from typing import Optional, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def detect_project_context(cwd: Optional[str] = None) -> Optional[Dict[str, Any]]:
+    """
+    Detect project context from current working directory or git repository.
+
+    Args:
+        cwd: Current working directory (defaults to os.getcwd())
+
+    Returns:
+        Dictionary with project information:
+        - project_name: Name of the project
+        - project_path: Absolute path to project root
+        - is_git_repo: Whether this is a git repository
+        - git_remote: Git remote URL (if available)
+
+        Returns None if project cannot be detected.
+    """
+    if cwd is None:
+        cwd = os.getcwd()
+
+    cwd = os.path.abspath(cwd)
+
+    result = {
+        "project_path": cwd,
+        "is_git_repo": False
+    }
+
+    # Try to detect from git repository
+    git_info = _detect_from_git(cwd)
+    if git_info:
+        result.update(git_info)
+        result["is_git_repo"] = True
+        return result
+
+    # Fallback: use directory name
+    project_name = os.path.basename(cwd)
+    result["project_name"] = project_name
+
+    return result
+
+
+def _detect_from_git(cwd: str) -> Optional[Dict[str, Any]]:
+    """
+    Detect project information from git repository.
+
+    Args:
+        cwd: Current working directory
+
+    Returns:
+        Dictionary with git-based project info, or None if not a git repo
+    """
+    try:
+        # Check if this is a git repository
+        git_check = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+
+        if git_check.returncode != 0:
+            return None
+
+        # Get repository root
+        repo_root = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+
+        if repo_root.returncode != 0:
+            return None
+
+        project_path = repo_root.stdout.strip()
+        project_name = os.path.basename(project_path)
+
+        result = {
+            "project_name": project_name,
+            "project_path": project_path
+        }
+
+        # Try to get git remote (optional)
+        try:
+            remote = subprocess.run(
+                ["git", "remote", "get-url", "origin"],
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+
+            if remote.returncode == 0:
+                result["git_remote"] = remote.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass  # Git remote is optional
+
+        return result
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as e:
+        logger.debug(f"Git detection failed: {e}")
+        return None
+
+
+def get_project_from_memories(db, limit: int = 50) -> Optional[str]:
+    """
+    Infer current project from frequently mentioned project paths in recent memories.
+
+    Args:
+        db: Database instance
+        limit: Number of recent memories to analyze
+
+    Returns:
+        Most common project path, or None if cannot determine
+    """
+    # This would require database access, which we'll implement later
+    # For now, return None
+    return None