Clean up vector store examples

Author: abrookins

docs/contextual-grounding.md

@@ -30,6 +30,7 @@ With grounding: "John was really helpful with the project"
 Replaces pronouns with their actual referents from conversation context.
 
 **Examples:**
+
 - "He likes coffee" → "John likes coffee"
 - "She recommended the book" → "Sarah recommended the book"
 - "They are meeting tomorrow" → "Alice and Bob are meeting tomorrow"
@@ -40,6 +41,7 @@ Replaces pronouns with their actual referents from conversation context.
 Converts relative time references to specific dates and times.
 
 **Examples:**
+
 - "Yesterday" → "January 15, 2024"
 - "Last week" → "The week of January 8-14, 2024"
 - "Tomorrow" → "January 17, 2024"
@@ -50,6 +52,7 @@ Converts relative time references to specific dates and times.
 Resolves location references to specific places mentioned in context.
 
 **Examples:**
+
 - "That place" → "Starbucks on Main Street"
 - "There" → "The office conference room"
 - "Here" → "The user's home office"
@@ -59,6 +62,7 @@ Resolves location references to specific places mentioned in context.
 Links vague references to specific entities from the conversation.
 
 **Examples:**
+
 - "The project" → "The website redesign project"
 - "The meeting" → "The quarterly review meeting"
 - "The document" → "The project proposal document"
@@ -229,29 +233,6 @@ grounding_quality = {
 }
 ```
 
-## Best Practices
-
-### Conversation Design
-
-1. **Provide context early**: Introduce entities, people, and places clearly
-2. **Use specific names**: Avoid excessive pronoun use when clarity matters
-3. **Maintain conversation threads**: Keep related discussions in the same session
-4. **Include temporal markers**: Use specific dates when discussing events
-
-### Memory Quality
-
-1. **Review extracted memories**: Check that grounding resolved references correctly
-2. **Provide feedback**: Use memory editing to correct grounding errors
-3. **Monitor patterns**: Identify common grounding failures for improvement
-4. **Test edge cases**: Verify grounding works with complex conversations
-
-### Performance Optimization
-
-1. **Limit conversation history**: Very long conversations may impact grounding quality
-2. **Use appropriate models**: Balance accuracy vs. speed based on your needs
-3. **Monitor token usage**: Grounding requires additional context tokens
-4. **Cache frequently referenced entities**: Consistent entity names improve grounding
-
 ## Troubleshooting
 
 ### Common Issues

docs/vector-store-advanced.md

@@ -4,110 +4,7 @@ This guide covers advanced configuration patterns, performance optimization, cus
 
 ## Advanced Factory Patterns
 
-### Multi-Environment Factory
 
-Create factories that adapt to different environments:
-
-```python
-# my_vectorstores.py
-import os
-from langchain_core.embeddings import Embeddings
-from langchain_redis import Redis as LangchainRedis
-from langchain_chroma import Chroma
-from langchain_pinecone import PineconeVectorStore
-
-def create_adaptive_vectorstore(embeddings: Embeddings) -> VectorStore:
-    """Dynamically choose vectorstore based on environment."""
-
-    environment = os.getenv("ENVIRONMENT", "development")
-
-    if environment == "production":
-        # Use Pinecone for production
-        return PineconeVectorStore(
-            index_name=os.getenv("PINECONE_INDEX_NAME"),
-            embedding=embeddings,
-            api_key=os.getenv("PINECONE_API_KEY"),
-            environment=os.getenv("PINECONE_ENVIRONMENT")
-        )
-    elif environment == "staging":
-        # Use Redis for staging
-        return LangchainRedis(
-            redis_url=os.getenv("REDIS_URL"),
-            index_name="staging_memories",
-            embeddings=embeddings
-        )
-    else:
-        # Use Chroma for development
-        return Chroma(
-            persist_directory="./dev_chroma_data",
-            collection_name="dev_memories",
-            embedding_function=embeddings
-        )
-```
-
-### High-Availability Factory
-
-Create factories with resilience and failover capabilities:
-
-```python
-# resilient_factory.py
-import os
-from langchain_core.embeddings import Embeddings
-from langchain_core.vectorstores import VectorStore
-
-def create_resilient_vectorstore(embeddings: Embeddings) -> VectorStore:
-    """Create vectorstore with built-in resilience patterns."""
-
-    # Try multiple backends in order of preference
-    backend_preferences = [
-        ("redis", _create_redis_backend),
-        ("chroma", _create_chroma_backend),
-        ("memory", _create_memory_backend)  # Fallback to in-memory
-    ]
-
-    last_error = None
-    for backend_name, factory_func in backend_preferences:
-        try:
-            vectorstore = factory_func(embeddings)
-            print(f"Successfully initialized {backend_name} vectorstore")
-            return vectorstore
-        except Exception as e:
-            print(f"Failed to initialize {backend_name}: {e}")
-            last_error = e
-            continue
-
-    raise Exception(f"All vectorstore backends failed. Last error: {last_error}")
-
-def _create_redis_backend(embeddings: Embeddings) -> VectorStore:
-    """Try Redis with connection validation."""
-    from langchain_redis import Redis as LangchainRedis
-
-    vectorstore = LangchainRedis(
-        redis_url=os.getenv("REDIS_URL", "redis://localhost:6379"),
-        index_name="resilient_memories",
-        embeddings=embeddings
-    )
-
-    # Validate connection
-    vectorstore.client.ping()
-    return vectorstore
-
-def _create_chroma_backend(embeddings: Embeddings) -> VectorStore:
-    """Fallback to Chroma."""
-    from langchain_chroma import Chroma
-
-    return Chroma(
-        persist_directory=os.getenv("BACKUP_PERSIST_DIR", "./backup_chroma"),
-        collection_name="backup_memories",
-        embedding_function=embeddings
-    )
-
-def _create_memory_backend(embeddings: Embeddings) -> VectorStore:
-    """Final fallback to in-memory store."""
-    from langchain_core.vectorstores import InMemoryVectorStore
-
-    return InMemoryVectorStore(embeddings)
-```
 
 ### Multi-Backend Hybrid Factory
 
@@ -616,17 +513,17 @@ class VectorStoreMigrator:
         return await self.import_memories(memories, batch_size)
 
 # Usage example
-async def migrate_redis_to_pinecone():
-    """Example: Migrate from Redis to Pinecone."""
+async def migrate_pinecone_to_redis():
+    """Example: Migrate from Pinecone to Redis."""
 
-    # Source (Redis)
+    # Source (Pinecone)
     source_client = MemoryAPIClient(
-        base_url="http://localhost:8000",  # Current Redis setup
+        base_url="http://localhost:8000",  # Current Pinecone setup
     )
 
-    # Target (Pinecone) - Temporarily switch backend
+    # Target (Redis) - New Redis-based setup
     target_client = MemoryAPIClient(
-        base_url="http://localhost:8001",  # New Pinecone setup
+        base_url="http://localhost:8001",  # New Redis setup
     )
 
     migrator = VectorStoreMigrator(source_client, target_client)
@@ -637,7 +534,7 @@ async def migrate_redis_to_pinecone():
 
     # Option 2: File-based migration (safer for large datasets)
     await migrator.export_to_file("memory_export.json")
-    # ... Stop old server, start new server with Pinecone backend ...
+    # ... Stop old server, start new server with Redis backend ...
     imported = await migrator.import_from_file("memory_export.json")
     print(f"Imported {imported} memories from file")
 ```