mem-llm 1.3.0__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.0.dist-info → mem_llm-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mem-llm
-Version: 1.3.0
+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
@@ -59,9 +59,9 @@ Requires-Dist: pymongo>=4.6.0; extra == "all"
 [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-**Memory-enabled AI assistant with local LLM support**
+**Memory-enabled AI assistant with multi-backend LLM support (Ollama, LM Studio, Gemini)**
 
-Mem-LLM is a powerful Python library that brings persistent memory capabilities to local Large Language Models. Build AI assistants that remember user interactions, manage knowledge bases, and work completely offline with Ollama.
+Mem-LLM is a powerful Python library that brings persistent memory capabilities to Large Language Models. Build AI assistants that remember user interactions, manage knowledge bases, and choose between local (Ollama, LM Studio) or cloud (Gemini) backends.
 
 ## 🔗 Links
 
@@ -70,29 +70,40 @@ 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.2.0
+## 🆕 What's New in v1.3.2
 
-- � **Conversation Summarization**: Automatic conversation compression (~40-60% token reduction)
-- 📤 **Data Export/Import**: JSON, CSV, SQLite, PostgreSQL, MongoDB support
-- 🗄️ **Multi-Database**: Enterprise-ready PostgreSQL & MongoDB integration
-- �️ **In-Memory DB**: Use `:memory:` for temporary operations
-- � **Cleaner Logs**: Default WARNING level for production-ready output
-- � **Bug Fixes**: Database path handling, organized SQLite files
+- 📊 **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
 
-[See full changelog](CHANGELOG.md#120---2025-10-21)
+## 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
+- 🔍 **Auto-Detection**: Automatically finds and uses available local LLM services
+- ⚡ **Unified API**: Same code works across all backends - just change one parameter
+- 📚 **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)
 
 ## ✨ 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 Ollama Support** - Works with ALL Ollama models (Qwen3, DeepSeek, Llama3, Granite, etc.)
+- 🤖 **Universal Model Support** - Works with 100+ Ollama models, LM Studio models, and Gemini
 - 💾 **Dual Storage Modes** - JSON (simple) or SQLite (advanced) memory backends
 - 📚 **Knowledge Base** - Built-in FAQ/support system with categorized entries
 - 🎯 **Dynamic Prompts** - Context-aware system prompts that adapt to active features
 - 👥 **Multi-User Support** - Separate memory spaces for different users
 - 🔧 **Memory Tools** - Search, export, and manage stored memories
 - 🎨 **Flexible Configuration** - Personal or business usage modes
-- 📊 **Production Ready** - Comprehensive test suite with 34+ automated tests
-- 🔒 **100% Local & Private** - No cloud dependencies, your data stays yours
+- 📊 **Production Ready** - Comprehensive test suite with 50+ automated tests
+- 🔒 **Privacy Options** - 100% local (Ollama/LM Studio) or cloud (Gemini)
 - 🛡️ **Prompt Injection Protection** (v1.1.0+) - Advanced security against prompt attacks (opt-in)
 - ⚡ **High Performance** (v1.1.0+) - Thread-safe operations, 15K+ msg/s throughput
 - 🔄 **Retry Logic** (v1.1.0+) - Automatic exponential backoff for network errors
@@ -130,8 +141,9 @@ pip install -U mem-llm
 
 ### Prerequisites
 
-Install and start [Ollama](https://ollama.ai):
+**Choose one of the following LLM backends:**
 
+#### Option 1: Ollama (Local, Privacy-First)
 ```bash
 # Install Ollama (visit https://ollama.ai)
 # Then pull a model
@@ -141,15 +153,38 @@ ollama pull granite4:tiny-h
 ollama serve
 ```
 
+#### Option 2: LM Studio (Local, GUI-Based)
+```bash
+# 1. Download and install LM Studio: https://lmstudio.ai
+# 2. Download a model from the UI
+# 3. Start the local server (default port: 1234)
+```
+
+#### Option 3: Google Gemini (Cloud, Powerful)
+```bash
+# Get API key from: https://makersuite.google.com/app/apikey
+# Set environment variable
+export GEMINI_API_KEY="your-api-key-here"
+```
+
 ### Basic Usage
 
 ```python
 from mem_llm import MemAgent
 
-# Create an agent
+# Option 1: Use Ollama (default)
 agent = MemAgent(model="granite4:tiny-h")
 
-# Set user and chat
+# Option 2: Use LM Studio
+agent = MemAgent(backend='lmstudio', model='local-model')
+
+# Option 3: Use Gemini
+agent = MemAgent(backend='gemini', model='gemini-2.5-flash', api_key='your-key')
+
+# Option 4: Auto-detect available backend
+agent = MemAgent(auto_detect_backend=True)
+
+# Set user and chat (same for all backends!)
 agent.set_user("alice")
 response = agent.chat("My name is Alice and I love Python!")
 print(response)
@@ -159,10 +194,34 @@ response = agent.chat("What's my name and what do I love?")
 print(response)  # Agent remembers: "Your name is Alice and you love Python!"
 ```
 
-That's it! Just 5 lines of code to get started.
+That's it! Just 5 lines of code to get started with any backend.
 
 ## 📖 Usage Examples
 
+### Multi-Backend Examples (v1.3.0+)
+
+```python
+from mem_llm import MemAgent
+
+# LM Studio - Fast local inference
+agent = MemAgent(
+    backend='lmstudio',
+    model='local-model',
+    base_url='http://localhost:1234'
+)
+
+# Google Gemini - Cloud power
+agent = MemAgent(
+    backend='gemini',
+    model='gemini-2.5-flash',
+    api_key='your-api-key'
+)
+
+# Auto-detect - Universal compatibility
+agent = MemAgent(auto_detect_backend=True)
+print(f"Using: {agent.llm.get_backend_info()['name']}")
+```
+
 ### Multi-User Conversations
 
 ```python
@@ -379,16 +438,21 @@ Mem-LLM works with **ALL Ollama models**, including:
 ```
 mem-llm/
 ├── mem_llm/
-│   ├── mem_agent.py           # Main agent class
-│   ├── memory_manager.py      # JSON memory backend
-│   ├── memory_db.py           # SQL memory backend
-│   ├── llm_client.py          # Ollama API client
-│   ├── knowledge_loader.py    # Knowledge base system
-│   ├── dynamic_prompt.py      # Context-aware prompts
-│   ├── memory_tools.py        # Memory management tools
-│   ├── config_manager.py      # Configuration handler
-│   └── cli.py                 # Command-line interface
-└── examples/                  # Usage examples
+│   ├── mem_agent.py              # Main agent class (multi-backend)
+│   ├── base_llm_client.py        # Abstract LLM interface
+│   ├── llm_client_factory.py     # Backend factory pattern
+│   ├── clients/                  # LLM backend implementations
+│   │   ├── ollama_client.py      # Ollama integration
+│   │   ├── lmstudio_client.py    # LM Studio integration
+│   │   └── gemini_client.py      # Google Gemini integration
+│   ├── memory_manager.py         # JSON memory backend
+│   ├── memory_db.py              # SQL memory backend
+│   ├── knowledge_loader.py       # Knowledge base system
+│   ├── dynamic_prompt.py         # Context-aware prompts
+│   ├── memory_tools.py           # Memory management tools
+│   ├── config_manager.py         # Configuration handler
+│   └── cli.py                    # Command-line interface
+└── examples/                     # Usage examples (14 total)
 ```
 
 ## 🔥 Advanced Features
@@ -430,10 +494,12 @@ stats = agent.get_memory_stats()
 ## 📦 Project Structure
 
 ### Core Components
-- **MemAgent**: Main interface for building AI assistants
+- **MemAgent**: Main interface for building AI assistants (multi-backend support)
+- **LLMClientFactory**: Factory pattern for backend creation
+- **BaseLLMClient**: Abstract interface for all LLM backends
+- **OllamaClient / LMStudioClient / GeminiClient**: Backend implementations
 - **MemoryManager**: JSON-based memory storage (simple)
 - **SQLMemoryManager**: SQLite-based storage (advanced)
-- **OllamaClient**: LLM communication handler
 - **KnowledgeLoader**: Knowledge base management
 
 ### Optional Features
@@ -457,14 +523,19 @@ The `examples/` directory contains ready-to-run demonstrations:
 8. **08_conversation_summarization.py** - Token compression with auto-summary (v1.2.0+)
 9. **09_data_export_import.py** - Multi-format export/import demo (v1.2.0+)
 10. **10_database_connection_test.py** - Enterprise PostgreSQL/MongoDB migration (v1.2.0+)
+11. **11_lmstudio_example.py** - Using LM Studio backend (v1.3.0+)
+12. **12_gemini_example.py** - Using Google Gemini API (v1.3.0+)
+13. **13_multi_backend_comparison.py** - Compare different backends (v1.3.0+)
+14. **14_auto_detect_backend.py** - Auto-detection feature demo (v1.3.0+)
 
 ## 📊 Project Status
 
-- **Version**: 1.2.0
+- **Version**: 1.3.0
 - **Status**: Production Ready
-- **Last Updated**: October 21, 2025
-- **Test Coverage**: 16/16 automated tests (100% success rate)
+- **Last Updated**: October 31, 2025
+- **Test Coverage**: 50+ automated tests (100% success rate)
 - **Performance**: Thread-safe operations, <1ms search latency
+- **Backends**: Ollama, LM Studio, Google Gemini
 - **Databases**: SQLite, PostgreSQL, MongoDB, In-Memory
 
 ## 📈 Roadmap
@@ -476,10 +547,14 @@ The `examples/` directory contains ready-to-run demonstrations:
 - [x] ~~Conversation Summarization~~ (v1.2.0)
 - [x] ~~Multi-Database Export/Import~~ (v1.2.0)
 - [x] ~~In-Memory Database~~ (v1.2.0)
+- [x] ~~Multi-Backend Support (Ollama, LM Studio, Gemini)~~ (v1.3.0)
+- [x] ~~Auto-Detection~~ (v1.3.0)
+- [x] ~~Factory Pattern Architecture~~ (v1.3.0)
+- [ ] OpenAI & Claude backends
+- [ ] Streaming support
 - [ ] Web UI dashboard
 - [ ] REST API server
 - [ ] Vector database integration
-- [ ] Advanced analytics dashboard
 
 ## 📄 License
 

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

@@ -1,9 +1,9 @@
-mem_llm/__init__.py,sha256=Nx_7o8uFoK7WzLjY4Ko2sVITQoAcYtwNsUK4AugddbE,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.0.dist-info/METADATA,sha256=Ov-FBPV2qYjgWWYv9l0WidhSmr7vGx-NW1uIqxAToi4,15518
-mem_llm-1.3.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-mem_llm-1.3.0.dist-info/entry_points.txt,sha256=z9bg6xgNroIobvCMtnSXeFPc-vI1nMen8gejHCdnl0U,45
-mem_llm-1.3.0.dist-info/top_level.txt,sha256=_fU1ML-0JwkaxWdhqpwtmTNaJEOvDMQeJdA8d5WqDn8,8
-mem_llm-1.3.0.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,,