AbstractMemory 0.2.1__tar.gz → 0.2.3__tar.gz

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/AbstractMemory.egg-info/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: AbstractMemory
-Version: 0.2.1
+Version: 0.2.3
 Summary: Production-ready memory system for LLM agents - NO MOCKS, real semantic search, clear LLM vs embedding provider separation
-Author-email: AbstractMemory Team <lpalbou@gmail.com>
-Maintainer-email: AbstractMemory Team <palbou@gmail.com>
+Author-email: Laurent-Philippe Albou <lpalbou@gmail.com>
+Maintainer-email: Laurent-Philippe Albou <lpalbou@gmail.com>
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/lpalbou/AbstractAgent
-Project-URL: Documentation, https://github.com/lpalbou/AbstractAgent#readme
-Project-URL: Repository, https://github.com/lpalbou/AbstractAgent
-Project-URL: Bug Reports, https://github.com/lpalbou/AbstractAgent/issues
+Project-URL: Homepage, https://github.com/lpalbou/AbstractMemory
+Project-URL: Documentation, https://github.com/lpalbou/AbstractMemory#readme
+Project-URL: Repository, https://github.com/lpalbou/AbstractMemory
+Project-URL: Bug Reports, https://github.com/lpalbou/AbstractMemory/issues
 Keywords: llm,memory,semantic-search,embeddings,ai,agents,knowledge-graph,temporal,grounded-memory,vector-search
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -34,11 +34,13 @@ Requires-Dist: abstractcore>=2.1.0; extra == "llm"
 Provides-Extra: embeddings
 Requires-Dist: abstractcore>=2.1.0; extra == "embeddings"
 Requires-Dist: lancedb>=0.6.0; extra == "embeddings"
+Requires-Dist: sentence-transformers>=2.0.0; extra == "embeddings"
 Provides-Extra: storage
 Requires-Dist: lancedb>=0.6.0; extra == "storage"
 Provides-Extra: all
 Requires-Dist: abstractcore>=2.1.0; extra == "all"
 Requires-Dist: lancedb>=0.6.0; extra == "all"
+Requires-Dist: sentence-transformers>=2.0.0; extra == "all"
 Dynamic: license-file
 
 # AbstractMemory
@@ -165,26 +167,39 @@ memory = create_memory(
 ```
 
 #### Powerful Vector Search
-High-performance search with AbstractCore embeddings:
+High-performance search with default optimized embeddings:
 
 ```python
-from abstractllm import create_llm
-
-# Create provider with embedding support
-provider = create_llm("openai", embedding_model="text-embedding-3-small")
+# Uses default all-MiniLM-L6-v2 model (recommended)
+memory = create_memory(
+    "grounded",
+    storage_backend="lancedb",
+    storage_uri="./memory.db"
+    # embedding_provider automatically configured with all-MiniLM-L6-v2
+)
 
-# Vector search storage
+# Or with custom embedding model
+from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
 memory = create_memory(
     "grounded",
     storage_backend="lancedb",
     storage_uri="./memory.db",
-    embedding_provider=provider
+    embedding_provider=custom_provider
 )
 
 # Semantic search across stored interactions
 results = memory.search_stored_interactions("machine learning concepts")
 ```
 
+**🎯 Default Embedding Model**: AbstractMemory now uses **all-MiniLM-L6-v2** as the default embedding model, providing:
+- **Superior accuracy** (best semantic similarity performance)
+- **Maximum efficiency** (22M parameters, 384D embeddings)
+- **50% storage savings** compared to larger models
+- **Perfect retrieval performance** (100% P@5, R@5, F1 scores)
+
+See [embedding comparison report](docs/test-embeddings-report.md) for detailed benchmarks.
+
 #### Dual Storage - Best of Both Worlds
 Complete observability with powerful search:
 
@@ -290,7 +305,7 @@ python -m pytest tests/storage/test_dual_storage_comprehensive.py -v
 ### Installation
 
 ```bash
-# Install with semantic search capabilities (recommended)
+# Install with semantic search capabilities (includes sentence-transformers for default all-MiniLM-L6-v2 model)
 pip install abstractmemory[embeddings]
 
 # Or install everything
@@ -334,33 +349,39 @@ memory = create_memory("grounded", embedding_provider=embedder)  # NOT llm!
 ### Basic Usage
 
 ```python
-from abstractllm.embeddings import EmbeddingManager
 from abstractmemory import create_memory
 
-# 1. Create embedding manager for semantic search
-em = EmbeddingManager()  # Uses EmbeddingGemma (768D vectors)
-
-# 2. Create memory with dual storage
+# 1. Create memory with default all-MiniLM-L6-v2 embeddings (recommended)
 memory = create_memory(
     "grounded",
     storage_backend="dual",           # Markdown + LanceDB
     storage_path="./memory_files",    # Observable files
-    storage_uri="./memory.db",        # Vector search
-    embedding_provider=em             # Real embeddings
+    storage_uri="./memory.db"         # Vector search (auto-configured with all-MiniLM-L6-v2)
 )
 
-# 3. Add interactions (embeddings generated immediately!)
+# 2. Add interactions (embeddings generated automatically!)
 memory.set_current_user("alice")
 memory.add_interaction(
     "I'm working on machine learning projects",
     "Great! ML has amazing applications in many fields."
 )
-# ↳ Takes ~36ms: embedding generated and stored instantly
+# ↳ Takes ~13ms: optimized all-MiniLM-L6-v2 embedding generated and stored
 
-# 4. Semantic search finds contextually relevant content
+# 3. Semantic search finds contextually relevant content
 results = memory.search_stored_interactions("artificial intelligence research")
 # ↳ Finds ML interaction via semantic similarity (not keywords!)
 print(f"Found {len(results)} relevant conversations")
+
+# Optional: Use custom embedding model
+from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
+custom_memory = create_memory(
+    "grounded",
+    storage_backend="dual",
+    storage_path="./memory_files",
+    storage_uri="./memory.db",
+    embedding_provider=custom_provider
+)
 ```
 
 ### 📋 What Happens When You Add Interactions

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/AbstractMemory.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ abstractmemory/core/__init__.py
 abstractmemory/core/interfaces.py
 abstractmemory/core/temporal.py
 abstractmemory/embeddings/__init__.py
+abstractmemory/embeddings/sentence_transformer_provider.py
 abstractmemory/graph/__init__.py
 abstractmemory/graph/knowledge_graph.py
 abstractmemory/storage/__init__.py

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/AbstractMemory.egg-info/requires.txt

@@ -3,6 +3,7 @@ networkx>=3.0
 [all]
 abstractcore>=2.1.0
 lancedb>=0.6.0
+sentence-transformers>=2.0.0
 
 [dev]
 pytest
@@ -12,6 +13,7 @@ mypy
 [embeddings]
 abstractcore>=2.1.0
 lancedb>=0.6.0
+sentence-transformers>=2.0.0
 
 [llm]
 abstractcore>=2.1.0

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: AbstractMemory
-Version: 0.2.1
+Version: 0.2.3
 Summary: Production-ready memory system for LLM agents - NO MOCKS, real semantic search, clear LLM vs embedding provider separation
-Author-email: AbstractMemory Team <lpalbou@gmail.com>
-Maintainer-email: AbstractMemory Team <palbou@gmail.com>
+Author-email: Laurent-Philippe Albou <lpalbou@gmail.com>
+Maintainer-email: Laurent-Philippe Albou <lpalbou@gmail.com>
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/lpalbou/AbstractAgent
-Project-URL: Documentation, https://github.com/lpalbou/AbstractAgent#readme
-Project-URL: Repository, https://github.com/lpalbou/AbstractAgent
-Project-URL: Bug Reports, https://github.com/lpalbou/AbstractAgent/issues
+Project-URL: Homepage, https://github.com/lpalbou/AbstractMemory
+Project-URL: Documentation, https://github.com/lpalbou/AbstractMemory#readme
+Project-URL: Repository, https://github.com/lpalbou/AbstractMemory
+Project-URL: Bug Reports, https://github.com/lpalbou/AbstractMemory/issues
 Keywords: llm,memory,semantic-search,embeddings,ai,agents,knowledge-graph,temporal,grounded-memory,vector-search
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -34,11 +34,13 @@ Requires-Dist: abstractcore>=2.1.0; extra == "llm"
 Provides-Extra: embeddings
 Requires-Dist: abstractcore>=2.1.0; extra == "embeddings"
 Requires-Dist: lancedb>=0.6.0; extra == "embeddings"
+Requires-Dist: sentence-transformers>=2.0.0; extra == "embeddings"
 Provides-Extra: storage
 Requires-Dist: lancedb>=0.6.0; extra == "storage"
 Provides-Extra: all
 Requires-Dist: abstractcore>=2.1.0; extra == "all"
 Requires-Dist: lancedb>=0.6.0; extra == "all"
+Requires-Dist: sentence-transformers>=2.0.0; extra == "all"
 Dynamic: license-file
 
 # AbstractMemory
@@ -165,26 +167,39 @@ memory = create_memory(
 ```
 
 #### Powerful Vector Search
-High-performance search with AbstractCore embeddings:
+High-performance search with default optimized embeddings:
 
 ```python
-from abstractllm import create_llm
-
-# Create provider with embedding support
-provider = create_llm("openai", embedding_model="text-embedding-3-small")
+# Uses default all-MiniLM-L6-v2 model (recommended)
+memory = create_memory(
+    "grounded",
+    storage_backend="lancedb",
+    storage_uri="./memory.db"
+    # embedding_provider automatically configured with all-MiniLM-L6-v2
+)
 
-# Vector search storage
+# Or with custom embedding model
+from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
 memory = create_memory(
     "grounded",
     storage_backend="lancedb",
     storage_uri="./memory.db",
-    embedding_provider=provider
+    embedding_provider=custom_provider
 )
 
 # Semantic search across stored interactions
 results = memory.search_stored_interactions("machine learning concepts")
 ```
 
+**🎯 Default Embedding Model**: AbstractMemory now uses **all-MiniLM-L6-v2** as the default embedding model, providing:
+- **Superior accuracy** (best semantic similarity performance)
+- **Maximum efficiency** (22M parameters, 384D embeddings)
+- **50% storage savings** compared to larger models
+- **Perfect retrieval performance** (100% P@5, R@5, F1 scores)
+
+See [embedding comparison report](docs/test-embeddings-report.md) for detailed benchmarks.
+
 #### Dual Storage - Best of Both Worlds
 Complete observability with powerful search:
 
@@ -290,7 +305,7 @@ python -m pytest tests/storage/test_dual_storage_comprehensive.py -v
 ### Installation
 
 ```bash
-# Install with semantic search capabilities (recommended)
+# Install with semantic search capabilities (includes sentence-transformers for default all-MiniLM-L6-v2 model)
 pip install abstractmemory[embeddings]
 
 # Or install everything
@@ -334,33 +349,39 @@ memory = create_memory("grounded", embedding_provider=embedder)  # NOT llm!
 ### Basic Usage
 
 ```python
-from abstractllm.embeddings import EmbeddingManager
 from abstractmemory import create_memory
 
-# 1. Create embedding manager for semantic search
-em = EmbeddingManager()  # Uses EmbeddingGemma (768D vectors)
-
-# 2. Create memory with dual storage
+# 1. Create memory with default all-MiniLM-L6-v2 embeddings (recommended)
 memory = create_memory(
     "grounded",
     storage_backend="dual",           # Markdown + LanceDB
     storage_path="./memory_files",    # Observable files
-    storage_uri="./memory.db",        # Vector search
-    embedding_provider=em             # Real embeddings
+    storage_uri="./memory.db"         # Vector search (auto-configured with all-MiniLM-L6-v2)
 )
 
-# 3. Add interactions (embeddings generated immediately!)
+# 2. Add interactions (embeddings generated automatically!)
 memory.set_current_user("alice")
 memory.add_interaction(
     "I'm working on machine learning projects",
     "Great! ML has amazing applications in many fields."
 )
-# ↳ Takes ~36ms: embedding generated and stored instantly
+# ↳ Takes ~13ms: optimized all-MiniLM-L6-v2 embedding generated and stored
 
-# 4. Semantic search finds contextually relevant content
+# 3. Semantic search finds contextually relevant content
 results = memory.search_stored_interactions("artificial intelligence research")
 # ↳ Finds ML interaction via semantic similarity (not keywords!)
 print(f"Found {len(results)} relevant conversations")
+
+# Optional: Use custom embedding model
+from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
+custom_memory = create_memory(
+    "grounded",
+    storage_backend="dual",
+    storage_path="./memory_files",
+    storage_uri="./memory.db",
+    embedding_provider=custom_provider
+)
 ```
 
 ### 📋 What Happens When You Add Interactions

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/README.md

@@ -122,26 +122,39 @@ memory = create_memory(
 ```
 
 #### Powerful Vector Search
-High-performance search with AbstractCore embeddings:
+High-performance search with default optimized embeddings:
 
 ```python
-from abstractllm import create_llm
-
-# Create provider with embedding support
-provider = create_llm("openai", embedding_model="text-embedding-3-small")
+# Uses default all-MiniLM-L6-v2 model (recommended)
+memory = create_memory(
+    "grounded",
+    storage_backend="lancedb",
+    storage_uri="./memory.db"
+    # embedding_provider automatically configured with all-MiniLM-L6-v2
+)
 
-# Vector search storage
+# Or with custom embedding model
+from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
 memory = create_memory(
     "grounded",
     storage_backend="lancedb",
     storage_uri="./memory.db",
-    embedding_provider=provider
+    embedding_provider=custom_provider
 )
 
 # Semantic search across stored interactions
 results = memory.search_stored_interactions("machine learning concepts")
 ```
 
+**🎯 Default Embedding Model**: AbstractMemory now uses **all-MiniLM-L6-v2** as the default embedding model, providing:
+- **Superior accuracy** (best semantic similarity performance)
+- **Maximum efficiency** (22M parameters, 384D embeddings)
+- **50% storage savings** compared to larger models
+- **Perfect retrieval performance** (100% P@5, R@5, F1 scores)
+
+See [embedding comparison report](docs/test-embeddings-report.md) for detailed benchmarks.
+
 #### Dual Storage - Best of Both Worlds
 Complete observability with powerful search:
 
@@ -247,7 +260,7 @@ python -m pytest tests/storage/test_dual_storage_comprehensive.py -v
 ### Installation
 
 ```bash
-# Install with semantic search capabilities (recommended)
+# Install with semantic search capabilities (includes sentence-transformers for default all-MiniLM-L6-v2 model)
 pip install abstractmemory[embeddings]
 
 # Or install everything
@@ -291,33 +304,39 @@ memory = create_memory("grounded", embedding_provider=embedder)  # NOT llm!
 ### Basic Usage
 
 ```python
-from abstractllm.embeddings import EmbeddingManager
 from abstractmemory import create_memory
 
-# 1. Create embedding manager for semantic search
-em = EmbeddingManager()  # Uses EmbeddingGemma (768D vectors)
-
-# 2. Create memory with dual storage
+# 1. Create memory with default all-MiniLM-L6-v2 embeddings (recommended)
 memory = create_memory(
     "grounded",
     storage_backend="dual",           # Markdown + LanceDB
     storage_path="./memory_files",    # Observable files
-    storage_uri="./memory.db",        # Vector search
-    embedding_provider=em             # Real embeddings
+    storage_uri="./memory.db"         # Vector search (auto-configured with all-MiniLM-L6-v2)
 )
 
-# 3. Add interactions (embeddings generated immediately!)
+# 2. Add interactions (embeddings generated automatically!)
 memory.set_current_user("alice")
 memory.add_interaction(
     "I'm working on machine learning projects",
     "Great! ML has amazing applications in many fields."
 )
-# ↳ Takes ~36ms: embedding generated and stored instantly
+# ↳ Takes ~13ms: optimized all-MiniLM-L6-v2 embedding generated and stored
 
-# 4. Semantic search finds contextually relevant content
+# 3. Semantic search finds contextually relevant content
 results = memory.search_stored_interactions("artificial intelligence research")
 # ↳ Finds ML interaction via semantic similarity (not keywords!)
 print(f"Found {len(results)} relevant conversations")
+
+# Optional: Use custom embedding model
+from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
+custom_memory = create_memory(
+    "grounded",
+    storage_backend="dual",
+    storage_path="./memory_files",
+    storage_uri="./memory.db",
+    embedding_provider=custom_provider
+)
 ```
 
 ### 📋 What Happens When You Add Interactions

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/abstractmemory/__init__.py

@@ -36,7 +36,7 @@ def create_memory(
             storage_backend: "markdown", "lancedb", "dual", or None
             storage_path: Path for markdown storage
             storage_uri: URI for LanceDB storage
-            embedding_provider: AbstractCore instance for embeddings
+            embedding_provider: Embedding provider for semantic search (defaults to all-MiniLM-L6-v2)
 
     Examples:
         # For a ReAct agent
@@ -55,21 +55,20 @@ def create_memory(
             storage_path="./memory"
         )
 
-        # With LanceDB storage (SQL + vector search)
-        from abstractllm import create_llm
-        provider = create_llm("openai")
+        # With LanceDB storage (uses default all-MiniLM-L6-v2 embeddings)
         memory = create_memory("grounded",
             storage_backend="lancedb",
-            storage_uri="./lance.db",
-            embedding_provider=provider
+            storage_uri="./lance.db"
         )
 
-        # With dual storage (both markdown and LanceDB)
+        # With custom embedding provider
+        from abstractmemory.embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+        custom_provider = create_sentence_transformer_provider("bge-base-en-v1.5")
         memory = create_memory("grounded",
             storage_backend="dual",
             storage_path="./memory",
             storage_uri="./lance.db",
-            embedding_provider=provider
+            embedding_provider=custom_provider
         )
     """
     if memory_type == "scratchpad":
@@ -77,6 +76,30 @@ def create_memory(
     elif memory_type == "buffer":
         return BufferMemory(**kwargs)
     elif memory_type == "grounded":
+        # Auto-configure default embedding provider if needed
+        storage_backend = kwargs.get('storage_backend')
+        embedding_provider = kwargs.get('embedding_provider')
+
+        # If storage requires embeddings but no provider specified, use default
+        if storage_backend in ['lancedb', 'dual'] and embedding_provider is None:
+            try:
+                from .embeddings.sentence_transformer_provider import create_sentence_transformer_provider
+                default_provider = create_sentence_transformer_provider("all-MiniLM-L6-v2")
+                kwargs['embedding_provider'] = default_provider
+
+                import logging
+                logging.info("Using default all-MiniLM-L6-v2 embedding model for semantic search")
+
+            except ImportError:
+                import logging
+                logging.warning(
+                    "sentence-transformers not available. Install with: pip install sentence-transformers. "
+                    "Vector search will not be available."
+                )
+            except Exception as e:
+                import logging
+                logging.warning(f"Could not initialize default embedding provider: {e}")
+
         return GroundedMemory(**kwargs)
     else:
         raise ValueError(f"Unknown memory type: {memory_type}")
@@ -243,6 +266,11 @@ class GroundedMemory:
                     if interaction_id and note_id:
                         self.storage_manager.link_interaction_to_note(interaction_id, note_id)
 
+            return interaction_id
+
+        # If no storage manager, return None (or could generate a simple ID)
+        return None
+
     def _extract_facts_to_kg(self, text: str, event_time: datetime):
         """Extract facts from text and add to KG"""
         # Simplified extraction - would use NLP/LLM in production
@@ -510,6 +538,23 @@ class GroundedMemory:
             for episode in episodes:
                 context_parts.append(f"- {str(episode.content)[:100]}...")
 
+        # Get from storage manager (semantic search if available)
+        if hasattr(self, 'storage_manager') and self.storage_manager and hasattr(self.storage_manager, 'search_interactions'):
+            try:
+                storage_results = self.storage_manager.search_interactions(query, user_id=user_id, limit=max_items//2)
+                if storage_results:
+                    context_parts.append("\n=== Recent Interactions ===")
+                    for result in storage_results:
+                        # Show both user input and agent response from stored interaction
+                        if 'user_input' in result and 'agent_response' in result:
+                            user_text = result['user_input'][:100]
+                            agent_text = result['agent_response'][:100]
+                            context_parts.append(f"User: {user_text}{'...' if len(result['user_input']) > 100 else ''}")
+                            context_parts.append(f"Agent: {agent_text}{'...' if len(result['agent_response']) > 100 else ''}")
+            except Exception as e:
+                # Don't fail if storage search has issues
+                pass
+
         # Get from knowledge graph
         if self.kg:
             facts = self.kg.query_at_time(query, datetime.now())

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/abstractmemory/embeddings/__init__.py

@@ -57,6 +57,14 @@ class EmbeddingAdapter:
         except ImportError:
             pass
 
+        # Check for SentenceTransformer provider first (before AbstractCore check)
+        if hasattr(self.provider, 'model') and hasattr(self.provider, 'generate_embedding'):
+            # Check if it's our SentenceTransformerProvider
+            if hasattr(self.provider, 'model_name') and hasattr(self.provider, 'provider_name'):
+                # Additional check to distinguish from AbstractCore
+                if hasattr(self.provider, 'get_embedding_dimension') and hasattr(self.provider, 'get_model_info'):
+                    return "sentence_transformers"
+
         # Check for AbstractCore provider with embedding support (has specific AbstractCore attributes)
         if hasattr(self.provider, 'generate_embedding') and hasattr(self.provider, 'provider_name'):
             return "abstractcore"
@@ -103,6 +111,19 @@ class EmbeddingAdapter:
                 return len(test_embedding)
             except:
                 return 1024  # Common Ollama embedding dimension
+        elif self.provider_type == "sentence_transformers":
+            # Get dimension directly from SentenceTransformer provider
+            try:
+                return self.provider.get_embedding_dimension()
+            except Exception as e:
+                logger.error(f"Failed to get dimension from SentenceTransformer provider: {e}")
+                # Fallback to test embedding
+                try:
+                    test_embedding = self.provider.generate_embedding("dimension_test")
+                    return len(test_embedding)
+                except Exception as e2:
+                    logger.error(f"Fallback dimension test failed: {e2}")
+                    raise ValueError(f"Unable to determine embedding dimension: {e}")
         elif self.provider_type == "generic_embedding_provider":
             # For any provider with generate_embedding method
             try:
@@ -142,6 +163,16 @@ class EmbeddingAdapter:
                     info["backend"] = str(self.provider.backend)
             except Exception as e:
                 logger.debug(f"Could not extract model info: {e}")
+        elif self.provider_type == "sentence_transformers":
+            # Get model info from SentenceTransformer provider
+            try:
+                provider_info = self.provider.get_model_info()
+                info.update(provider_info)
+            except Exception as e:
+                logger.debug(f"Could not extract SentenceTransformer model info: {e}")
+                # Fallback info
+                if hasattr(self.provider, 'model_name'):
+                    info["model_name"] = self.provider.model_name
         elif self.provider_type == "openai":
             info["model_name"] = "text-embedding-3-small"  # Default assumption
 
@@ -171,6 +202,8 @@ class EmbeddingAdapter:
                 return self._generate_ollama_embedding(text)
             elif self.provider_type == "mlx":
                 return self._generate_mlx_embedding(text)
+            elif self.provider_type == "sentence_transformers":
+                return self._generate_sentence_transformers_embedding(text)
             elif self.provider_type == "generic_embedding_provider":
                 return self.provider.generate_embedding(text)
             else:
@@ -226,9 +259,13 @@ class EmbeddingAdapter:
             "Please use AbstractCore EmbeddingManager or another provider."
         )
 
+    def _generate_sentence_transformers_embedding(self, text: str) -> List[float]:
+        """Generate embedding using SentenceTransformer provider."""
+        return self.provider.generate_embedding(text)
+
     def is_real_embedding(self) -> bool:
         """Check if this adapter provides real semantic embeddings."""
-        return self.provider_type in ["abstractcore_embeddings", "abstractcore", "openai", "ollama", "generic_embedding_provider"]
+        return self.provider_type in ["abstractcore_embeddings", "abstractcore", "openai", "ollama", "sentence_transformers", "generic_embedding_provider"]
 
     def get_embedding_info(self) -> dict:
         """Get comprehensive information about the embedding provider for consistency tracking."""

abstractmemory-0.2.3/abstractmemory/embeddings/sentence_transformer_provider.py

@@ -0,0 +1,159 @@
+"""
+SentenceTransformer-based embedding provider for testing different models.
+Supports BAAI/bge-base-en-v1.5, all-MiniLM-L6-v2, and other sentence-transformers models.
+"""
+
+import logging
+from typing import List, Optional
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class SentenceTransformerProvider:
+    """
+    A provider for SentenceTransformer models that can be used with the EmbeddingAdapter.
+    Supports various models including BAAI/bge-base-en-v1.5 and all-MiniLM-L6-v2.
+    """
+
+    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2", device: Optional[str] = None):
+        """
+        Initialize the SentenceTransformer provider.
+
+        Args:
+            model_name: Name of the sentence-transformers model to use
+            device: Device to run the model on ('cpu', 'cuda', or None for auto)
+        """
+        self.model_name = model_name
+        self.device = device
+        self.model = None
+        self.provider_name = f"sentence_transformers_{model_name.replace('/', '_').replace('-', '_')}"
+
+        try:
+            from sentence_transformers import SentenceTransformer
+            logger.info(f"Loading SentenceTransformer model: {model_name}")
+            self.model = SentenceTransformer(model_name, device=device)
+            logger.info(f"Successfully loaded model: {model_name}")
+        except ImportError:
+            raise ImportError(
+                "sentence-transformers library is required. Install with: "
+                "pip install sentence-transformers"
+            )
+        except Exception as e:
+            logger.error(f"Failed to load model {model_name}: {e}")
+            raise
+
+    def generate_embedding(self, text: str) -> List[float]:
+        """
+        Generate embedding for the given text.
+
+        Args:
+            text: Input text to embed
+
+        Returns:
+            List[float]: Embedding vector
+        """
+        if not self.model:
+            raise RuntimeError("Model not initialized")
+
+        try:
+            # Generate embedding and convert to list
+            embedding = self.model.encode([text], normalize_embeddings=True)[0]
+            if isinstance(embedding, np.ndarray):
+                return embedding.tolist()
+            return list(embedding)
+        except Exception as e:
+            logger.error(f"Failed to generate embedding: {e}")
+            raise
+
+    def generate_embeddings_batch(self, texts: List[str]) -> List[List[float]]:
+        """
+        Generate embeddings for a batch of texts (more efficient).
+
+        Args:
+            texts: List of input texts to embed
+
+        Returns:
+            List[List[float]]: List of embedding vectors
+        """
+        if not self.model:
+            raise RuntimeError("Model not initialized")
+
+        try:
+            # Generate embeddings and convert to list of lists
+            embeddings = self.model.encode(texts, normalize_embeddings=True)
+            if isinstance(embeddings, np.ndarray):
+                return embeddings.tolist()
+            return [list(emb) for emb in embeddings]
+        except Exception as e:
+            logger.error(f"Failed to generate batch embeddings: {e}")
+            raise
+
+    def get_embedding_dimension(self) -> int:
+        """Get the embedding dimension of the model."""
+        if not self.model:
+            raise RuntimeError("Model not initialized")
+        return self.model.get_sentence_embedding_dimension()
+
+    def get_model_info(self) -> dict:
+        """Get information about the model."""
+        return {
+            "model_name": self.model_name,
+            "provider": "sentence_transformers",
+            "dimension": self.get_embedding_dimension() if self.model else None,
+            "device": str(self.device) if self.device else "auto",
+            "provider_name": self.provider_name
+        }
+
+
+# Common model configurations
+MODEL_CONFIGS = {
+    "bge-base-en-v1.5": {
+        "model_name": "BAAI/bge-base-en-v1.5",
+        "dimension": 768,
+        "description": "BAAI BGE Base English v1.5 - High performance retrieval model",
+        "max_sequence_length": 512,
+        "parameters": "109M"
+    },
+    "all-MiniLM-L6-v2": {
+        "model_name": "sentence-transformers/all-MiniLM-L6-v2",
+        "dimension": 384,
+        "description": "All MiniLM L6 v2 - Fast and efficient sentence transformer",
+        "max_sequence_length": 256,
+        "parameters": "22M"
+    },
+    "all-mpnet-base-v2": {
+        "model_name": "sentence-transformers/all-mpnet-base-v2",
+        "dimension": 768,
+        "description": "All MPNet Base v2 - High quality general purpose model",
+        "max_sequence_length": 384,
+        "parameters": "109M"
+    },
+    "bge-small-en-v1.5": {
+        "model_name": "BAAI/bge-small-en-v1.5",
+        "dimension": 384,
+        "description": "BAAI BGE Small English v1.5 - Compact high performance model",
+        "max_sequence_length": 512,
+        "parameters": "33M"
+    }
+}
+
+
+def create_sentence_transformer_provider(model_key: str = "all-MiniLM-L6-v2",
+                                       device: Optional[str] = None) -> SentenceTransformerProvider:
+    """
+    Create a SentenceTransformer provider with a predefined model configuration.
+
+    Args:
+        model_key: Key from MODEL_CONFIGS or full model name
+        device: Device to run on
+
+    Returns:
+        SentenceTransformerProvider: Configured provider
+    """
+    if model_key in MODEL_CONFIGS:
+        model_name = MODEL_CONFIGS[model_key]["model_name"]
+    else:
+        model_name = model_key
+
+    return SentenceTransformerProvider(model_name, device)

{abstractmemory-0.2.1 → abstractmemory-0.2.3}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AbstractMemory"
-version = "0.2.1"
+version = "0.2.3"
 description = "Production-ready memory system for LLM agents - NO MOCKS, real semantic search, clear LLM vs embedding provider separation"
 readme = "README.md"
 license = "MIT"
 authors = [
-    {name = "AbstractMemory Team", email = "lpalbou@gmail.com"}
+    {name = "Laurent-Philippe Albou", email = "lpalbou@gmail.com"}
 ]
 maintainers = [
-    {name = "AbstractMemory Team", email = "palbou@gmail.com"}
+    {name = "Laurent-Philippe Albou", email = "lpalbou@gmail.com"}
 ]
 keywords = ["llm", "memory", "semantic-search", "embeddings", "ai", "agents", "knowledge-graph", "temporal", "grounded-memory", "vector-search"]
 classifiers = [
@@ -36,15 +36,15 @@ dependencies = [
 [project.optional-dependencies]
 dev = ["pytest", "black", "mypy"]
 llm = ["abstractcore>=2.1.0"]
-embeddings = ["abstractcore>=2.1.0", "lancedb>=0.6.0"]
+embeddings = ["abstractcore>=2.1.0", "lancedb>=0.6.0", "sentence-transformers>=2.0.0"]
 storage = ["lancedb>=0.6.0"]
-all = ["abstractcore>=2.1.0", "lancedb>=0.6.0"]
+all = ["abstractcore>=2.1.0", "lancedb>=0.6.0", "sentence-transformers>=2.0.0"]
 
 [project.urls]
-Homepage = "https://github.com/lpalbou/AbstractAgent"
-Documentation = "https://github.com/lpalbou/AbstractAgent#readme"
-Repository = "https://github.com/lpalbou/AbstractAgent"
-"Bug Reports" = "https://github.com/lpalbou/AbstractAgent/issues"
+Homepage = "https://github.com/lpalbou/AbstractMemory"
+Documentation = "https://github.com/lpalbou/AbstractMemory#readme"
+Repository = "https://github.com/lpalbou/AbstractMemory"
+"Bug Reports" = "https://github.com/lpalbou/AbstractMemory/issues"
 
 [tool.setuptools.packages.find]
 where = ["."]