mem-llm 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

mem_llm/vector_store.py

@@ -0,0 +1,278 @@
+"""
+Vector Store Abstraction Layer
+Supports multiple vector databases (Chroma, FAISS, etc.)
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class VectorStore(ABC):
+    """Abstract interface for vector stores"""
+    
+    @abstractmethod
+    def add_documents(self, documents: List[Dict[str, Any]]) -> None:
+        """
+        Add documents to vector store
+        
+        Args:
+            documents: List of dicts with 'id', 'text', 'metadata'
+        """
+        pass
+    
+    @abstractmethod
+    def search(self, query: str, limit: int = 5, filter_metadata: Optional[Dict] = None) -> List[Dict[str, Any]]:
+        """
+        Search similar documents
+        
+        Args:
+            query: Search query text
+            limit: Maximum number of results
+            filter_metadata: Optional metadata filters
+            
+        Returns:
+            List of similar documents with scores
+        """
+        pass
+    
+    @abstractmethod
+    def delete_collection(self) -> None:
+        """Delete all vectors in collection"""
+        pass
+    
+    @abstractmethod
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the vector store"""
+        pass
+
+
+try:
+    import chromadb
+    from chromadb.config import Settings
+    CHROMA_AVAILABLE = True
+except ImportError:
+    CHROMA_AVAILABLE = False
+    logger.warning("ChromaDB not available. Install with: pip install chromadb")
+
+
+class ChromaVectorStore(VectorStore):
+    """ChromaDB implementation of VectorStore"""
+    
+    def __init__(self, collection_name: str = "knowledge_base", 
+                 persist_directory: Optional[str] = None,
+                 embedding_model: str = "all-MiniLM-L6-v2"):
+        """
+        Initialize ChromaDB vector store
+        
+        Args:
+            collection_name: Name of the collection
+            persist_directory: Directory to persist data (None = in-memory)
+            embedding_model: Embedding model name (sentence-transformers compatible)
+        """
+        if not CHROMA_AVAILABLE:
+            raise ImportError(
+                "ChromaDB is not installed. Install with: pip install chromadb"
+            )
+        
+        self.collection_name = collection_name
+        self.persist_directory = persist_directory
+        self.embedding_model = embedding_model
+        
+        # Initialize Chroma client
+        if persist_directory:
+            self.client = chromadb.PersistentClient(path=persist_directory)
+        else:
+            self.client = chromadb.Client()
+        
+        # Lazy load embedding model
+        self._embedding_fn = None
+        
+        # Get or create collection with embedding function
+        try:
+            # Create embedding function
+            embedding_fn = self._get_embedding_function()
+            
+            self.collection = self.client.get_or_create_collection(
+                name=collection_name,
+                embedding_function=embedding_fn,
+                metadata={"hnsw:space": "cosine"}
+            )
+        except Exception as e:
+            logger.error(f"Failed to create Chroma collection: {e}")
+            raise
+    
+    def _get_embedding_function(self):
+        """Lazy load embedding function"""
+        if self._embedding_fn is None:
+            try:
+                # Try to use ChromaDB's native SentenceTransformerEmbeddingFunction
+                try:
+                    # Try different import paths for ChromaDB embedding functions
+                    try:
+                        from chromadb.utils import embedding_functions
+                        embedding_fn_class = embedding_functions.SentenceTransformerEmbeddingFunction
+                    except (ImportError, AttributeError):
+                        try:
+                            from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction as embedding_fn_class
+                        except ImportError:
+                            embedding_fn_class = None
+                    
+                    if embedding_fn_class:
+                        self._embedding_fn = embedding_fn_class(model_name=self.embedding_model)
+                        logger.info(f"Loaded embedding model using ChromaDB native function: {self.embedding_model}")
+                    else:
+                        raise AttributeError("SentenceTransformerEmbeddingFunction not found")
+                        
+                except (ImportError, AttributeError, Exception) as e:
+                    # Fallback: Custom embedding function wrapper compatible with ChromaDB
+                    from sentence_transformers import SentenceTransformer
+                    model = SentenceTransformer(self.embedding_model)
+                    
+                    class CustomEmbeddingFunction:
+                        def __init__(self, model, model_name):
+                            self.model = model
+                            self.model_name = model_name
+                            self.name = model_name  # ChromaDB may check for 'name' attribute
+                        
+                        def __call__(self, texts: List[str]) -> List[List[float]]:
+                            embeddings = self.model.encode(texts, show_progress_bar=False)
+                            return embeddings.tolist()
+                        
+                        def encode_queries(self, queries: List[str]) -> List[List[float]]:
+                            return self.__call__(queries)
+                    
+                    self._embedding_fn = CustomEmbeddingFunction(model, self.embedding_model)
+                    logger.info(f"Loaded embedding model using custom wrapper: {self.embedding_model} (fallback: {e})")
+            except ImportError:
+                raise ImportError(
+                    "sentence-transformers not installed. "
+                    "Install with: pip install sentence-transformers"
+                )
+        
+        return self._embedding_fn
+    
+    def add_documents(self, documents: List[Dict[str, Any]]) -> None:
+        """Add documents to ChromaDB"""
+        if not documents:
+            return
+        
+        # Prepare data
+        ids = []
+        texts = []
+        metadatas = []
+        
+        for doc in documents:
+            doc_id = str(doc.get('id', doc.get('text', ''))[:100])
+            # Ensure unique IDs
+            if doc_id in ids:
+                doc_id = f"{doc_id}_{len(ids)}"
+            ids.append(doc_id)
+            texts.append(doc['text'])
+            # Ensure metadata values are JSON-serializable
+            metadata = doc.get('metadata', {})
+            clean_metadata = {}
+            for k, v in metadata.items():
+                if isinstance(v, (str, int, float, bool)) or v is None:
+                    clean_metadata[k] = v
+                else:
+                    clean_metadata[k] = str(v)
+            metadatas.append(clean_metadata)
+        
+        # Add to collection (Chroma will use embedding function automatically)
+        try:
+            self.collection.add(
+                ids=ids,
+                documents=texts,
+                metadatas=metadatas
+            )
+            
+            logger.debug(f"Added {len(documents)} documents to Chroma")
+        except Exception as e:
+            logger.error(f"Error adding documents to Chroma: {e}")
+            raise
+    
+    def search(self, query: str, limit: int = 5, 
+               filter_metadata: Optional[Dict] = None) -> List[Dict[str, Any]]:
+        """Search in ChromaDB"""
+        try:
+            # Build where clause for metadata filtering
+            where = None
+            if filter_metadata:
+                where = filter_metadata
+            
+            # Search (Chroma will use embedding function automatically)
+            results = self.collection.query(
+                query_texts=[query],
+                n_results=limit,
+                where=where
+            )
+            
+            # Format results
+            formatted_results = []
+            if results.get('documents') and len(results['documents']) > 0 and len(results['documents'][0]) > 0:
+                num_results = len(results['documents'][0])
+                distances = results.get('distances', [[0.0] * num_results])
+                
+                for i in range(num_results):
+                    # ChromaDB uses cosine distance (0 = identical, 1 = opposite)
+                    # Convert to similarity score (1 = identical, 0 = opposite)
+                    distance = distances[0][i] if distances and len(distances[0]) > i else 0.0
+                    similarity = 1.0 - distance if distance <= 1.0 else max(0.0, 1.0 / (1.0 + distance))
+                    
+                    formatted_results.append({
+                        'id': results['ids'][0][i] if results.get('ids') and len(results['ids'][0]) > i else f"doc_{i}",
+                        'text': results['documents'][0][i],
+                        'metadata': results['metadatas'][0][i] if results.get('metadatas') and len(results['metadatas'][0]) > i else {},
+                        'score': similarity
+                    })
+            
+            return formatted_results
+        except Exception as e:
+            logger.error(f"Error searching Chroma: {e}")
+            return []
+    
+    def delete_collection(self) -> None:
+        """Delete collection"""
+        try:
+            self.client.delete_collection(self.collection_name)
+            logger.info(f"Deleted Chroma collection: {self.collection_name}")
+        except Exception as e:
+            logger.error(f"Error deleting collection: {e}")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get collection statistics"""
+        try:
+            count = self.collection.count()
+            return {
+                'total_documents': count,
+                'collection_name': self.collection_name,
+                'embedding_model': self.embedding_model
+            }
+        except Exception as e:
+            logger.error(f"Error getting stats: {e}")
+            return {'total_documents': 0}
+
+
+def create_vector_store(store_type: str = "chroma", **kwargs) -> Optional[VectorStore]:
+    """
+    Factory function to create vector store
+    
+    Args:
+        store_type: Type of vector store ('chroma', 'faiss', etc.)
+        **kwargs: Store-specific parameters
+        
+    Returns:
+        VectorStore instance or None if not available
+    """
+    if store_type == "chroma":
+        if not CHROMA_AVAILABLE:
+            logger.warning("ChromaDB not available. Install with: pip install chromadb")
+            return None
+        return ChromaVectorStore(**kwargs)
+    else:
+        logger.warning(f"Unknown vector store type: {store_type}")
+        return None
+

{mem_llm-1.3.1.dist-info → mem_llm-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mem-llm
-Version: 1.3.1
+Version: 1.3.2
 Summary: Memory-enabled AI assistant with multi-backend LLM support (Ollama, LM Studio, Gemini) - Local and cloud ready
 Author-email: "C. Emre Karataş" <karatasqemre@gmail.com>
 License: MIT
@@ -70,7 +70,14 @@ Mem-LLM is a powerful Python library that brings persistent memory capabilities
 - **Issues**: https://github.com/emredeveloper/Mem-LLM/issues
 - **Documentation**: See examples/ directory
 
-## 🆕 What's New in v1.3.0
+## 🆕 What's New in v1.3.2
+
+- 📊 **Response Metrics** (v1.3.1+) – Track confidence, latency, KB usage, and quality analytics
+- 🔍 **Vector Search** (v1.3.2+) – Semantic search with ChromaDB, cross-lingual support
+- 🎯 **Quality Monitoring** – Production-ready metrics for response quality
+- 🌐 **Semantic Understanding** – Understands meaning, not just keywords
+
+## What's New in v1.3.0
 
 - 🔌 **Multi-Backend Support**: Choose between Ollama (local), LM Studio (local), or Google Gemini (cloud)
 - 🏗️ **Factory Pattern**: Clean, extensible architecture for easy backend switching
@@ -79,12 +86,14 @@ Mem-LLM is a powerful Python library that brings persistent memory capabilities
 - 📚 **New Examples**: 4 additional examples showing multi-backend usage
 - 🎯 **Backward Compatible**: All v1.2.0 code still works without changes
 
-[See full changelog](CHANGELOG.md#130---2025-10-31)
+[See full changelog](CHANGELOG.md)
 
 ## ✨ Key Features
 
 - 🔌 **Multi-Backend Support** (v1.3.0+) - Choose Ollama, LM Studio, or Gemini with unified API
 - 🔍 **Auto-Detection** (v1.3.0+) - Automatically find and use available LLM services
+- 📊 **Response Metrics** (v1.3.1+) - Track confidence, latency, KB usage, and quality analytics
+- 🔍 **Vector Search** (v1.3.2+) - Semantic search with ChromaDB, cross-lingual support
 - 🧠 **Persistent Memory** - Remembers conversations across sessions
 - 🤖 **Universal Model Support** - Works with 100+ Ollama models, LM Studio models, and Gemini
 - 💾 **Dual Storage Modes** - JSON (simple) or SQLite (advanced) memory backends

{mem_llm-1.3.1.dist-info → mem_llm-1.3.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-mem_llm/__init__.py,sha256=e65UMPGqGj69SwDeUkvVE_W4KijKAtI8Jxfn_40Xuc4,2636
+mem_llm/__init__.py,sha256=fKHDaLkOUE4uFqaTkqfKcop4Ckz9qfFOTKGcfz6BGlE,2918
 mem_llm/base_llm_client.py,sha256=aCpr8ZnvOsu-a-zp9quTDP42XvjAC1uci6r11s0QdVA,5218
 mem_llm/cli.py,sha256=DiqQyBZknN8pVagY5jXH85_LZ6odVGopfpa-7DILNNE,8666
 mem_llm/config.yaml.example,sha256=lgmfaU5pxnIm4zYxwgCcgLSohNx1Jw6oh3Qk0Xoe2DE,917
 mem_llm/config_from_docs.py,sha256=YFhq1SWyK63C-TNMS73ncNHg8sJ-XGOf2idWVCjxFco,4974
-mem_llm/config_manager.py,sha256=is4m0ISBIfv4PInGjrpvhxy0A7p9_BQ_UoJeayaIT3A,7084
+mem_llm/config_manager.py,sha256=QwkZz8qNBj5KI0h7t45PQmvJ7Orqnx3iOIUbU5yAVoo,7255
 mem_llm/conversation_summarizer.py,sha256=yCG2pKrAJf7xjaG6DPXL0i9eesMZnnzjKTpuyLHMTPQ,12509
 mem_llm/data_export_import.py,sha256=gQIdD0hBY23qcRvx139yE15RWHXPinL_EoRNY7iabj0,22592
 mem_llm/dynamic_prompt.py,sha256=8H99QVDRJSVtGb_o4sdEPnG1cJWuer3KiD-nuL1srTA,10244
@@ -11,19 +11,21 @@ mem_llm/knowledge_loader.py,sha256=oSNhfYYcx7DlZLVogxnbSwaIydq_Q3__RDJFeZR2XVw,2
 mem_llm/llm_client.py,sha256=3F04nlnRWRlhkQ3aZO-OfsxeajB2gwbIDfClu04cyb0,8709
 mem_llm/llm_client_factory.py,sha256=jite-4CkgFBd9e0b2cIaZzP-zTqA7tjNqXnJ5CQgcbs,9325
 mem_llm/logger.py,sha256=dZUmhGgFXtDsDBU_D4kZlJeMp6k-VNPaBcyTt7rZYKE,4507
-mem_llm/mem_agent.py,sha256=Y4qCHNtdPlOJssQLG1GJdy02FsztYe9sjnbh54qAWWU,37221
-mem_llm/memory_db.py,sha256=4HbxgfhPrijbBKsEv4ncmjZeK-RhtLkyWBrg-quCsNE,14715
-mem_llm/memory_manager.py,sha256=CZI3A8pFboHQIgeiXB1h2gZK7mgfbVSU3IxuqE-zXtc,9978
+mem_llm/mem_agent.py,sha256=8R0oAtXzD_X99QVVsfMjZl_wkiCCHdKNWrTrsrbpzdY,52771
+mem_llm/memory_db.py,sha256=yY_afim1Rpk3mOz-qI5WvDDAwWoVd-NucBMBLVUNpwg,21711
+mem_llm/memory_manager.py,sha256=BtzI1o-NYZXMkZHtc36xEZizgNn9fAu6cBkGzNXa-uI,10373
 mem_llm/memory_tools.py,sha256=ARANFqu_bmL56SlV1RzTjfQsJj-Qe2QvqY0pF92hDxU,8678
 mem_llm/prompt_security.py,sha256=ehAi6aLiXj0gFFhpyjwEr8LentSTJwOQDLbINV7SaVM,9960
+mem_llm/response_metrics.py,sha256=nMegWV7brNOmptjxGJfYEqRKvAj_302MIw8Ky1PzEy8,7912
 mem_llm/retry_handler.py,sha256=z5ZcSQKbvVeNK7plagTLorvOeoYgRpQcsX3PpNqUjKM,6389
 mem_llm/thread_safe_db.py,sha256=Fq-wSn4ua1qiR6M4ZTIy7UT1IlFj5xODNExgub1blbU,10328
+mem_llm/vector_store.py,sha256=7fzvxLjfJrspN1Tcety4JtcKksxnkM0E5es0UtBgI-c,10816
 mem_llm/clients/__init__.py,sha256=Nvr4NuL9ZlDF_dUjr-ZMFxRRrBdHoUOjqncZs3n5Wow,475
 mem_llm/clients/gemini_client.py,sha256=dmRZRd8f-x6J2W7luzcB1BOx_4UpXpCF4YiPGUccWCw,14432
 mem_llm/clients/lmstudio_client.py,sha256=IxUX3sVRfXN46hfEUTCrspGTOeqsn4YAu9WzFuGh940,10156
 mem_llm/clients/ollama_client.py,sha256=2BfYSBiOowhFg9UiCXkILlBG9_4Vri3-Iny_gH6-um0,9710
-mem_llm-1.3.1.dist-info/METADATA,sha256=d6sfUEBBg7Ir7y2495WAg6rqrKO9how5d3AgD-1NxU0,18217
-mem_llm-1.3.1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-mem_llm-1.3.1.dist-info/entry_points.txt,sha256=z9bg6xgNroIobvCMtnSXeFPc-vI1nMen8gejHCdnl0U,45
-mem_llm-1.3.1.dist-info/top_level.txt,sha256=_fU1ML-0JwkaxWdhqpwtmTNaJEOvDMQeJdA8d5WqDn8,8
-mem_llm-1.3.1.dist-info/RECORD,,
+mem_llm-1.3.2.dist-info/METADATA,sha256=6KYvn0Y00gcxzyU45tkckwW991IqSDpLoAvSfubeypY,18774
+mem_llm-1.3.2.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+mem_llm-1.3.2.dist-info/entry_points.txt,sha256=z9bg6xgNroIobvCMtnSXeFPc-vI1nMen8gejHCdnl0U,45
+mem_llm-1.3.2.dist-info/top_level.txt,sha256=_fU1ML-0JwkaxWdhqpwtmTNaJEOvDMQeJdA8d5WqDn8,8
+mem_llm-1.3.2.dist-info/RECORD,,