gnosisllm-knowledge 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

gnosisllm_knowledge/backends/__init__.py

@@ -9,18 +9,27 @@ from gnosisllm_knowledge.backends.opensearch import (
     OpenSearchKnowledgeSearcher,
     OpenSearchSetupAdapter,
 )
+from gnosisllm_knowledge.backends.opensearch.memory import (
+    MemoryConfig,
+    MemorySetup,
+    OpenSearchMemoryClient,
+)
 from gnosisllm_knowledge.backends.opensearch.queries import QueryBuilder
 
 __all__ = [
+    "AgenticSearchFallback",
+    # OpenSearch Memory
+    "MemoryConfig",
+    # Memory (for testing)
+    "MemoryIndexer",
+    "MemorySearcher",
+    "MemorySetup",
+    "OpenSearchAgenticSearcher",
     # OpenSearch
     "OpenSearchConfig",
     "OpenSearchIndexer",
     "OpenSearchKnowledgeSearcher",
+    "OpenSearchMemoryClient",
     "OpenSearchSetupAdapter",
-    "OpenSearchAgenticSearcher",
-    "AgenticSearchFallback",
     "QueryBuilder",
-    # Memory (for testing)
-    "MemoryIndexer",
-    "MemorySearcher",
 ]

gnosisllm_knowledge/backends/memory/indexer.py

@@ -1,4 +1,10 @@
-"""In-memory document indexer for testing."""
+"""In-memory document indexer for testing.
+
+Note:
+    This library is tenant-agnostic. Multi-tenancy is achieved through index
+    isolation (e.g., `knowledge-{account_id}`). The memory indexer does not
+    include tenant filtering logic - use separate index names per tenant.
+"""
 
 from __future__ import annotations
 
@@ -14,6 +20,9 @@ from gnosisllm_knowledge.core.domain.result import BatchResult, IndexResult
 class MemoryIndexer:
     """In-memory document indexer for testing.
 
+    This indexer is tenant-agnostic. Multi-tenancy is achieved through index
+    isolation by using tenant-specific index names.
+
     Stores documents in a dictionary for fast testing without
     requiring an external OpenSearch instance.
 
@@ -185,6 +194,22 @@ class MemoryIndexer:
         """
         return await self.index(document, index_name)
 
+    async def get(
+        self,
+        doc_id: str,
+        index_name: str,
+    ) -> dict[str, Any] | None:
+        """Get a document by ID (async interface).
+
+        Args:
+            doc_id: Document ID.
+            index_name: Index name.
+
+        Returns:
+            Document dictionary or None if not found.
+        """
+        return self._indices.get(index_name, {}).get(doc_id)
+
     async def delete(
         self,
         doc_id: str,
@@ -365,8 +390,8 @@ class MemoryIndexer:
             "url": document.url,
             "title": document.title,
             "source": document.source,
-            "account_id": document.account_id,
             "collection_id": document.collection_id,
+            "collection_name": document.collection_name,
             "source_id": document.source_id,
             "chunk_index": document.chunk_index,
             "total_chunks": document.total_chunks,

gnosisllm_knowledge/backends/memory/searcher.py

@@ -1,10 +1,16 @@
-"""In-memory document searcher for testing."""
+"""In-memory document searcher for testing.
+
+Note: This module is tenant-agnostic. Multi-tenancy should be handled
+at the API layer by using separate indices per account (e.g.,
+gnosisllm-{account_id}-knowledge) rather than filtering by account_id.
+"""
 
 from __future__ import annotations
 
 import math
 import re
 import time
+import warnings
 from typing import Any, Callable
 
 from gnosisllm_knowledge.backends.memory.indexer import MemoryIndexer
@@ -147,7 +153,7 @@ class MemorySearcher:
 
         for doc in filtered_docs:
             content = doc.get("content", "").lower()
-            title = doc.get("title", "").lower()
+            title = (doc.get("title") or "").lower()
 
             # Simple TF scoring
             content_score = sum(
@@ -209,7 +215,7 @@ class MemorySearcher:
         for doc in filtered_docs:
             # Keyword score
             content = doc.get("content", "").lower()
-            title = doc.get("title", "").lower()
+            title = (doc.get("title") or "").lower()
             keyword_score = sum(content.count(term) for term in query_terms)
             keyword_score += sum(title.count(term) for term in query_terms) * 2
 
@@ -348,6 +354,101 @@ class MemorySearcher:
             results.append(result)
         return results
 
+    async def list_documents(
+        self,
+        index_name: str,
+        *,
+        source_id: str | None = None,
+        collection_id: str | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List documents with optional filters.
+
+        Args:
+            index_name: Index to query.
+            source_id: Optional source ID filter.
+            collection_id: Optional collection ID filter.
+            limit: Maximum documents to return.
+            offset: Number of documents to skip.
+
+        Returns:
+            Dictionary with documents, total, limit, offset.
+        """
+        documents = self._indexer.get_all(index_name)
+
+        # Apply filters
+        if source_id:
+            documents = [d for d in documents if d.get("source_id") == source_id]
+        if collection_id:
+            documents = [d for d in documents if d.get("collection_id") == collection_id]
+
+        total = len(documents)
+
+        # Apply pagination
+        paginated = documents[offset : offset + limit]
+
+        return {
+            "documents": paginated,
+            "total": total,
+            "limit": limit,
+            "offset": offset,
+        }
+
+    def count(self, index_name: str) -> int:
+        """Count documents in index.
+
+        Args:
+            index_name: Index to count.
+
+        Returns:
+            Document count.
+        """
+        return self._indexer.count(index_name)
+
+    async def get_collections(self, index_name: str) -> list[dict[str, Any]]:
+        """Get unique collections with document counts.
+
+        Args:
+            index_name: Index to query.
+
+        Returns:
+            List of collections with id, name, and document_count.
+        """
+        documents = self._indexer.get_all(index_name)
+        collections: dict[str, dict[str, Any]] = {}
+
+        for doc in documents:
+            col_id = doc.get("collection_id")
+            if not col_id:
+                continue
+
+            if col_id not in collections:
+                collections[col_id] = {
+                    "id": col_id,
+                    "name": doc.get("collection_name") or col_id,
+                    "document_count": 0,
+                }
+            collections[col_id]["document_count"] += 1
+
+        return list(collections.values())
+
+    async def get_stats(self, index_name: str) -> dict[str, Any]:
+        """Get index statistics.
+
+        Args:
+            index_name: Index to query.
+
+        Returns:
+            Dictionary with document_count and index info.
+        """
+        count = self._indexer.count(index_name)
+        return {
+            "document_count": count,
+            "index_name": index_name,
+            "exists": count > 0 or index_name in self._indexer._indices,
+        }
+
     def _apply_filters(
         self,
         documents: list[dict[str, Any]],
@@ -355,6 +456,10 @@ class MemorySearcher:
     ) -> list[dict[str, Any]]:
         """Apply query filters to documents.
 
+        Note:
+            This method is tenant-agnostic. Multi-tenancy should be handled
+            at the API layer by using separate indices per account.
+
         Args:
             documents: Documents to filter.
             query: Query with filter parameters.
@@ -364,10 +469,6 @@ class MemorySearcher:
         """
         filtered = documents
 
-        # Account filter
-        if query.account_id:
-            filtered = [d for d in filtered if d.get("account_id") == query.account_id]
-
         # Collection filter
         if query.collection_ids:
             filtered = [
@@ -378,9 +479,9 @@ class MemorySearcher:
         if query.source_ids:
             filtered = [d for d in filtered if d.get("source_id") in query.source_ids]
 
-        # Custom filters
-        if query.filters:
-            for field, value in query.filters.items():
+        # Custom metadata filters
+        if query.metadata_filters:
+            for field, value in query.metadata_filters.items():
                 if isinstance(value, list):
                     filtered = [d for d in filtered if d.get(field) in value]
                 else: