Refactoring code

config/config.py

@@ -23,6 +23,9 @@ class Settings:
     # Vector Store Configuration
     CHROMA_PATH = os.getenv('CHROMA_PATH', './chroma_db')
     
+    # MongoDB Configuration
+    MONGODB_URI = os.getenv('MONGODB_URI', 'mongodb://localhost:27017')
+    
     # Application Configuration
     DEBUG = os.getenv('DEBUG', 'False') == 'True'
     

src/db/mongodb_store.py

@@ -0,0 +1,86 @@
+# src/db/mongodb_store.py
+from motor.motor_asyncio import AsyncIOMotorClient
+from datetime import datetime
+import json
+from typing import List, Dict, Optional
+from bson import ObjectId
+
+class MongoDBStore:
+    def __init__(self, mongo_uri: str = "mongodb://localhost:27017"):
+        """Initialize MongoDB connection"""
+        self.client = AsyncIOMotorClient(mongo_uri)
+        self.db = self.client.rag_chatbot
+        self.chat_history = self.db.chat_history
+
+    async def store_message(
+        self,
+        conversation_id: str,
+        query: str,
+        response: str,
+        context: List[str],
+        sources: List[Dict],
+        llm_provider: str
+    ) -> str:
+        """Store chat message in MongoDB"""
+        document = {
+            "conversation_id": conversation_id,
+            "timestamp": datetime.now(),
+            "query": query,
+            "response": response,
+            "context": context,
+            "sources": sources,
+            "llm_provider": llm_provider,
+            "feedback": None,
+            "rating": None
+        }
+        
+        result = await self.chat_history.insert_one(document)
+        return str(result.inserted_id)
+
+    async def get_conversation_history(self, conversation_id: str) -> List[Dict]:
+        """Retrieve conversation history"""
+        cursor = self.chat_history.find(
+            {"conversation_id": conversation_id}
+        ).sort("timestamp", 1)
+        
+        history = []
+        async for document in cursor:
+            document["_id"] = str(document["_id"])
+            history.append(document)
+            
+        return history
+
+    async def update_feedback(
+        self,
+        conversation_id: str,
+        feedback: Optional[str],
+        rating: Optional[int]
+    ) -> bool:
+        """Update feedback for a conversation"""
+        result = await self.chat_history.update_many(
+            {"conversation_id": conversation_id},
+            {
+                "$set": {
+                    "feedback": feedback,
+                    "rating": rating
+                }
+            }
+        )
+        return result.modified_count > 0
+
+    async def get_messages_for_summary(self, conversation_id: str) -> List[Dict]:
+        """Get messages in format suitable for summarization"""
+        cursor = self.chat_history.find(
+            {"conversation_id": conversation_id}
+        ).sort("timestamp", 1)
+        
+        messages = []
+        async for doc in cursor:
+            messages.append({
+                'role': 'user' if doc['query'] else 'assistant',
+                'content': doc['query'] or doc['response'],
+                'timestamp': doc['timestamp'],
+                'sources': doc['sources']
+            })
+            
+        return messages

src/implementations/__init__.py

@@ -0,0 +1,4 @@
+# src/implementations/__init__.py
+from .document_service import DocumentService
+
+__all__ = ['DocumentService']

src/implementations/document_service.py

@@ -0,0 +1,147 @@
+# src/implementations/document_service.py
+from pathlib import Path
+import shutil
+import os
+import uuid
+from typing import List, Tuple
+from fastapi import UploadFile, BackgroundTasks
+from ..vectorstores.chroma_vectorstore import ChromaVectorStore
+from ..utils.document_processor import DocumentProcessor
+from ..models import DocumentResponse, DocumentInfo, BatchUploadResponse
+from ..utils.logger import logger
+
+class DocumentService:
+    def __init__(self, doc_processor: DocumentProcessor):
+        self.doc_processor = doc_processor
+        self.upload_dir = Path("temp_uploads")
+        self.upload_dir.mkdir(exist_ok=True)
+
+    async def process_documents(
+        self,
+        files: List[UploadFile],
+        vector_store: ChromaVectorStore,
+        background_tasks: BackgroundTasks
+    ) -> BatchUploadResponse:
+        """Process multiple document uploads"""
+        processed_files, failed_files = await self._handle_file_uploads(
+            files, 
+            vector_store, 
+            background_tasks
+        )
+
+        return BatchUploadResponse(
+            message=f"Processed {len(processed_files)} documents with {len(failed_files)} failures",
+            processed_files=processed_files,
+            failed_files=failed_files
+        )
+
+    async def _handle_file_uploads(
+        self,
+        files: List[UploadFile],
+        vector_store: ChromaVectorStore,
+        background_tasks: BackgroundTasks
+    ) -> Tuple[List[DocumentResponse], List[dict]]:
+        """Handle individual file uploads and processing"""
+        processed_files = []
+        failed_files = []
+
+        for file in files:
+            try:
+                if not self._is_supported_format(file.filename):
+                    failed_files.append(self._create_failed_file_entry(
+                        file.filename, 
+                        "Unsupported file format"
+                    ))
+                    continue
+
+                document_response = await self._process_single_file(
+                    file, 
+                    vector_store, 
+                    background_tasks
+                )
+                processed_files.append(document_response)
+
+            except Exception as e:
+                logger.error(f"Error processing file {file.filename}: {str(e)}")
+                failed_files.append(self._create_failed_file_entry(
+                    file.filename, 
+                    str(e)
+                ))
+
+        return processed_files, failed_files
+
+    def _is_supported_format(self, filename: str) -> bool:
+        """Check if file format is supported"""
+        return any(filename.lower().endswith(ext) 
+                  for ext in self.doc_processor.supported_formats)
+
+    async def _process_single_file(
+        self,
+        file: UploadFile,
+        vector_store: ChromaVectorStore,
+        background_tasks: BackgroundTasks
+    ) -> DocumentResponse:
+        """Process a single file upload"""
+        document_id = str(uuid.uuid4())
+        temp_path = self.upload_dir / f"{document_id}_{file.filename}"
+        
+        # Save file
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Add background task for processing
+        background_tasks.add_task(
+            self._process_and_store_document,
+            temp_path,
+            vector_store,
+            document_id
+        )
+
+        return DocumentResponse(
+            message="Document queued for processing",
+            document_id=document_id,
+            status="processing",
+            document_info=DocumentInfo(
+                original_filename=file.filename,
+                size=os.path.getsize(temp_path),
+                content_type=file.content_type
+            )
+        )
+
+    async def _process_and_store_document(
+        self,
+        file_path: Path,
+        vector_store: ChromaVectorStore,
+        document_id: str
+    ):
+        """Process document and store in vector database"""
+        try:
+            processed_doc = await self.doc_processor.process_document(file_path)
+            
+            vector_store.add_documents(
+                documents=processed_doc['chunks'],
+                metadatas=[{
+                    'document_id': document_id,
+                    'chunk_id': i,
+                    'source': str(file_path.name),
+                    'metadata': processed_doc['metadata']
+                } for i in range(len(processed_doc['chunks']))],
+                ids=[f"{document_id}_chunk_{i}" for i in range(len(processed_doc['chunks']))]
+            )
+            
+            return processed_doc
+        finally:
+            if file_path.exists():
+                file_path.unlink()
+
+    def _create_failed_file_entry(self, filename: str, error: str) -> dict:
+        """Create a failed file entry"""
+        return {
+            "filename": filename,
+            "error": error
+        }
+
+    def cleanup(self):
+        """Clean up upload directory"""
+        if self.upload_dir.exists() and not any(self.upload_dir.iterdir()):
+            self.upload_dir.rmdir()

src/main.py

@@ -1,29 +1,26 @@
 # src/main.py
-from fastapi import FastAPI, UploadFile, File, HTTPException, Depends, BackgroundTasks
-from fastapi.responses import StreamingResponse, JSONResponse
-from pydantic import BaseModel
-from typing import List, Optional, AsyncGenerator, Dict
-import asyncio
-import json
+from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
+from fastapi.responses import StreamingResponse
+from typing import List
 import uuid
 from datetime import datetime
-import aiosqlite
-from pathlib import Path
-import shutil
-import os
 
 # Import custom modules
-from .agents.rag_agent import RAGAgent
-from .llms.openai_llm import OpenAILanguageModel
-from .llms.ollama_llm import OllamaLanguageModel
-from .llms.bert_llm import BERTLanguageModel
-from .llms.falcon_llm import FalconLanguageModel
-from .llms.llama_llm import LlamaLanguageModel
-from .embeddings.huggingface_embedding import HuggingFaceEmbedding
-from .vectorstores.chroma_vectorstore import ChromaVectorStore
-from .utils.document_processor import DocumentProcessor
-from .utils.conversation_summarizer import ConversationSummarizer
-from .utils.logger import logger
+from src.agents.rag_agent import RAGAgent
+from src.utils.document_processor import DocumentProcessor
+from src.utils.conversation_summarizer import ConversationSummarizer
+from src.utils.logger import logger
+from src.utils.llm_utils import get_llm_instance, get_vector_store
+from src.db.mongodb_store import MongoDBStore
+from src.implementations.document_service import DocumentService
+from src.models import (
+    ChatRequest, 
+    ChatResponse, 
+    BatchUploadResponse,
+    SummarizeRequest,
+    SummaryResponse,
+    FeedbackRequest
+)
 from config.config import settings
 
 app = FastAPI(title="RAG Chatbot API")
@@ -35,140 +32,11 @@ doc_processor = DocumentProcessor(
     max_file_size=10 * 1024 * 1024
 )
 summarizer = ConversationSummarizer()
+document_service = DocumentService(doc_processor)
 
-# Pydantic models
-class ChatRequest(BaseModel):
-    query: str
-    llm_provider: str = 'openai'
-    max_context_docs: int = 3
-    temperature: float = 0.7
-    stream: bool = False
-    conversation_id: Optional[str] = None
-
-class ChatResponse(BaseModel):
-    response: str
-    context: Optional[List[str]] = None
-    sources: Optional[List[Dict[str, str]]] = None
-    conversation_id: str
-    timestamp: datetime
-    relevant_doc_scores: Optional[List[float]] = None
-
-class DocumentResponse(BaseModel):
-    message: str
-    document_id: str
-    status: str
-    document_info: Optional[dict] = None
-
-class BatchUploadResponse(BaseModel):
-    message: str
-    processed_files: List[DocumentResponse]
-    failed_files: List[dict]
-
-class SummarizeRequest(BaseModel):
-    conversation_id: str
-    include_metadata: bool = True
-
-class SummaryResponse(BaseModel):
-    summary: str
-    key_insights: Dict
-    metadata: Optional[Dict] = None
-
-class FeedbackRequest(BaseModel):
-    rating: int
-    feedback: Optional[str] = None
-
-# Database initialization
-async def init_db():
-    async with aiosqlite.connect('chat_history.db') as db:
-        await db.execute('''
-            CREATE TABLE IF NOT EXISTS chat_history (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                conversation_id TEXT,
-                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                query TEXT,
-                response TEXT,
-                context TEXT,
-                sources TEXT,
-                llm_provider TEXT,
-                feedback TEXT,
-                rating INTEGER
-            )
-        ''')
-        await db.commit()
-
-# Utility functions
-def get_llm_instance(provider: str):
-    """Get LLM instance based on provider"""
-    llm_map = {
-        'openai': lambda: OpenAILanguageModel(api_key=settings.OPENAI_API_KEY),
-        'ollama': lambda: OllamaLanguageModel(base_url=settings.OLLAMA_BASE_URL),
-        'bert': lambda: BERTLanguageModel(),
-        'falcon': lambda: FalconLanguageModel(),
-        'llama': lambda: LlamaLanguageModel(),
-    }
-    
-    if provider not in llm_map:
-        raise ValueError(f"Unsupported LLM provider: {provider}")
-    return llm_map[provider]()
-
-async def get_vector_store():
-    """Initialize and return vector store with embedding model."""
-    try:
-        embedding = HuggingFaceEmbedding(model_name=settings.EMBEDDING_MODEL)
-        vector_store = ChromaVectorStore(
-            embedding_function=embedding.embed_documents,
-            persist_directory=settings.CHROMA_PATH
-        )
-        return vector_store, embedding
-    except Exception as e:
-        logger.error(f"Error initializing vector store: {str(e)}")
-        raise HTTPException(status_code=500, detail="Failed to initialize vector store")
-
-async def process_and_store_document(
-    file_path: Path,
-    vector_store: ChromaVectorStore,
-    document_id: str
-):
-    """Process document and store in vector database."""
-    try:
-        processed_doc = await doc_processor.process_document(file_path)
-        
-        vector_store.add_documents(
-            documents=processed_doc['chunks'],
-            metadatas=[{
-                'document_id': document_id,
-                'chunk_id': i,
-                'source': str(file_path.name),
-                'metadata': processed_doc['metadata']
-            } for i in range(len(processed_doc['chunks']))],
-            ids=[f"{document_id}_chunk_{i}" for i in range(len(processed_doc['chunks']))]
-        )
-        
-        return processed_doc
-    finally:
-        if file_path.exists():
-            file_path.unlink()
-
-async def store_chat_history(
-    conversation_id: str,
-    query: str,
-    response: str,
-    context: List[str],
-    sources: List[Dict],
-    llm_provider: str
-):
-    """Store chat history in database"""
-    async with aiosqlite.connect('chat_history.db') as db:
-        await db.execute(
-            '''INSERT INTO chat_history 
-               (conversation_id, query, response, context, sources, llm_provider)
-               VALUES (?, ?, ?, ?, ?, ?)''',
-            (conversation_id, query, response, json.dumps(context),
-             json.dumps(sources), llm_provider)
-        )
-        await db.commit()
+# Initialize MongoDB
+mongodb = MongoDBStore(settings.MONGODB_URI)
 
-# Endpoints
 @app.post("/documents/upload", response_model=BatchUploadResponse)
 async def upload_documents(
     files: List[UploadFile] = File(...),
@@ -177,68 +45,17 @@ async def upload_documents(
     """Upload and process multiple documents"""
     try:
         vector_store, _ = await get_vector_store()
-        upload_dir = Path("temp_uploads")
-        upload_dir.mkdir(exist_ok=True)
-        
-        processed_files = []
-        failed_files = []
-        
-        for file in files:
-            try:
-                document_id = str(uuid.uuid4())
-                
-                if not any(file.filename.lower().endswith(ext) 
-                          for ext in doc_processor.supported_formats):
-                    failed_files.append({
-                        "filename": file.filename,
-                        "error": "Unsupported file format"
-                    })
-                    continue
-                
-                temp_path = upload_dir / f"{document_id}_{file.filename}"
-                with open(temp_path, "wb") as buffer:
-                    shutil.copyfileobj(file.file, buffer)
-                
-                background_tasks.add_task(
-                    process_and_store_document,
-                    temp_path,
-                    vector_store,
-                    document_id
-                )
-                
-                processed_files.append(
-                    DocumentResponse(
-                        message="Document queued for processing",
-                        document_id=document_id,
-                        status="processing",
-                        document_info={
-                            "original_filename": file.filename,
-                            "size": os.path.getsize(temp_path),
-                            "content_type": file.content_type
-                        }
-                    )
-                )
-                
-            except Exception as e:
-                logger.error(f"Error processing file {file.filename}: {str(e)}")
-                failed_files.append({
-                    "filename": file.filename,
-                    "error": str(e)
-                })
-        
-        return BatchUploadResponse(
-            message=f"Processed {len(processed_files)} documents with {len(failed_files)} failures",
-            processed_files=processed_files,
-            failed_files=failed_files
+        response = await document_service.process_documents(
+            files, 
+            vector_store, 
+            background_tasks
         )
-        
+        return response
     except Exception as e:
         logger.error(f"Error in document upload: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
-    
     finally:
-        if upload_dir.exists() and not any(upload_dir.iterdir()):
-            upload_dir.rmdir()
+        document_service.cleanup()
 
 @app.post("/chat", response_model=ChatResponse)
 async def chat_endpoint(
@@ -269,14 +86,14 @@ async def chat_endpoint(
         
         conversation_id = request.conversation_id or str(uuid.uuid4())
         
-        background_tasks.add_task(
-            store_chat_history,
-            conversation_id,
-            request.query,
-            response.response,
-            response.context_docs,
-            response.sources,
-            request.llm_provider
+        # Store chat history in MongoDB
+        await mongodb.store_message(
+            conversation_id=conversation_id,
+            query=request.query,
+            response=response.response,
+            context=response.context_docs,
+            sources=response.sources,
+            llm_provider=request.llm_provider
         )
         
         return ChatResponse(
@@ -295,44 +112,25 @@ async def chat_endpoint(
 @app.get("/chat/history/{conversation_id}")
 async def get_conversation_history(conversation_id: str):
     """Get complete conversation history"""
-    async with aiosqlite.connect('chat_history.db') as db:
-        db.row_factory = aiosqlite.Row
-        async with db.execute(
-            'SELECT * FROM chat_history WHERE conversation_id = ? ORDER BY timestamp',
-            (conversation_id,)
-        ) as cursor:
-            history = await cursor.fetchall()
-            
-        if not history:
-            raise HTTPException(status_code=404, detail="Conversation not found")
-            
-        return {
-            "conversation_id": conversation_id,
-            "messages": [dict(row) for row in history]
-        }
+    history = await mongodb.get_conversation_history(conversation_id)
+    
+    if not history:
+        raise HTTPException(status_code=404, detail="Conversation not found")
+        
+    return {
+        "conversation_id": conversation_id,
+        "messages": history
+    }
 
 @app.post("/chat/summarize", response_model=SummaryResponse)
 async def summarize_conversation(request: SummarizeRequest):
     """Generate a summary of a conversation"""
     try:
-        async with aiosqlite.connect('chat_history.db') as db:
-            db.row_factory = aiosqlite.Row
-            async with db.execute(
-                'SELECT * FROM chat_history WHERE conversation_id = ? ORDER BY timestamp',
-                (request.conversation_id,)
-            ) as cursor:
-                history = await cursor.fetchall()
+        messages = await mongodb.get_messages_for_summary(request.conversation_id)
         
-        if not history:
+        if not messages:
             raise HTTPException(status_code=404, detail="Conversation not found")
         
-        messages = [{
-            'role': 'user' if msg['query'] else 'assistant',
-            'content': msg['query'] or msg['response'],
-            'timestamp': msg['timestamp'],
-            'sources': json.loads(msg['sources']) if msg['sources'] else None
-        } for msg in history]
-        
         summary = await summarizer.summarize_conversation(
             messages,
             include_metadata=request.include_metadata
@@ -351,14 +149,14 @@ async def submit_feedback(
 ):
     """Submit feedback for a conversation"""
     try:
-        async with aiosqlite.connect('chat_history.db') as db:
-            await db.execute(
-                '''UPDATE chat_history 
-                   SET feedback = ?, rating = ? 
-                   WHERE conversation_id = ?''',
-                (feedback_request.feedback, feedback_request.rating, conversation_id)
-            )
-            await db.commit()
+        success = await mongodb.update_feedback(
+            conversation_id=conversation_id,
+            feedback=feedback_request.feedback,
+            rating=feedback_request.rating
+        )
+        
+        if not success:
+            raise HTTPException(status_code=404, detail="Conversation not found")
             
         return {"status": "Feedback submitted successfully"}
         
@@ -371,11 +169,6 @@ async def health_check():
     """Health check endpoint"""
     return {"status": "healthy"}
 
-# Startup event
-@app.on_event("startup")
-async def startup_event():
-    await init_db()
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)

src/models/__init__.py

@@ -0,0 +1,26 @@
+# src/models/__init__.py
+from .chat import (
+    ChatRequest,
+    ChatResponse,
+    FeedbackRequest,
+    SummarizeRequest,
+    SummaryResponse
+)
+from .document import (
+    DocumentResponse,
+    BatchUploadResponse,
+    DocumentInfo
+)
+from .base import ChatMetadata
+
+__all__ = [
+    'ChatRequest',
+    'ChatResponse',
+    'FeedbackRequest',
+    'SummarizeRequest',
+    'SummaryResponse',
+    'DocumentResponse',
+    'BatchUploadResponse',
+    'DocumentInfo',
+    'ChatMetadata'
+]

src/models/base.py

@@ -0,0 +1,9 @@
+# src/models/base.py
+from pydantic import BaseModel
+from datetime import datetime
+from typing import Optional, List, Dict
+
+class ChatMetadata(BaseModel):
+    """Base metadata model for chat-related responses"""
+    conversation_id: str
+    timestamp: datetime

src/models/chat.py

@@ -0,0 +1,37 @@
+# src/models/chat.py
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+from datetime import datetime
+from .base import ChatMetadata
+
+class ChatRequest(BaseModel):
+    """Request model for chat endpoint"""
+    query: str
+    llm_provider: str = 'openai'
+    max_context_docs: int = 3
+    temperature: float = 0.7
+    stream: bool = False
+    conversation_id: Optional[str] = None
+
+class ChatResponse(ChatMetadata):
+    """Response model for chat endpoint"""
+    response: str
+    context: Optional[List[str]] = None
+    sources: Optional[List[Dict[str, str]]] = None
+    relevant_doc_scores: Optional[List[float]] = None
+
+class FeedbackRequest(BaseModel):
+    """Request model for feedback endpoint"""
+    rating: int
+    feedback: Optional[str] = None
+
+class SummarizeRequest(BaseModel):
+    """Request model for summarize endpoint"""
+    conversation_id: str
+    include_metadata: bool = True
+
+class SummaryResponse(BaseModel):
+    """Response model for summarize endpoint"""
+    summary: str
+    key_insights: Dict
+    metadata: Optional[Dict] = None

src/models/document.py

@@ -0,0 +1,22 @@
+# src/models/document.py
+from pydantic import BaseModel
+from typing import Optional, List
+
+class DocumentInfo(BaseModel):
+    """Document information model"""
+    original_filename: str
+    size: int
+    content_type: str
+
+class DocumentResponse(BaseModel):
+    """Response model for document processing"""
+    message: str
+    document_id: str
+    status: str
+    document_info: Optional[DocumentInfo] = None
+
+class BatchUploadResponse(BaseModel):
+    """Response model for batch document upload"""
+    message: str
+    processed_files: List[DocumentResponse]
+    failed_files: List[dict]

src/utils/llm_utils.py

@@ -0,0 +1,59 @@
+# src/utils/llm_utils.py
+from fastapi import HTTPException
+from typing import Tuple
+
+from src.llms.openai_llm import OpenAILanguageModel
+from src.llms.ollama_llm import OllamaLanguageModel
+from src.llms.bert_llm import BERTLanguageModel
+from src.llms.falcon_llm import FalconLanguageModel
+from src.llms.llama_llm import LlamaLanguageModel
+from src.embeddings.huggingface_embedding import HuggingFaceEmbedding
+from src.vectorstores.chroma_vectorstore import ChromaVectorStore
+from src.utils.logger import logger
+from config.config import settings
+
+def get_llm_instance(provider: str):
+    """
+    Get LLM instance based on provider
+    
+    Args:
+        provider (str): Name of the LLM provider
+        
+    Returns:
+        BaseLLM: Instance of the LLM
+        
+    Raises:
+        ValueError: If provider is not supported
+    """
+    llm_map = {
+        'openai': lambda: OpenAILanguageModel(api_key=settings.OPENAI_API_KEY),
+        'ollama': lambda: OllamaLanguageModel(base_url=settings.OLLAMA_BASE_URL),
+        'bert': lambda: BERTLanguageModel(),
+        'falcon': lambda: FalconLanguageModel(),
+        'llama': lambda: LlamaLanguageModel(),
+    }
+    
+    if provider not in llm_map:
+        raise ValueError(f"Unsupported LLM provider: {provider}")
+    return llm_map[provider]()
+
+async def get_vector_store() -> Tuple[ChromaVectorStore, HuggingFaceEmbedding]:
+    """
+    Initialize and return vector store with embedding model.
+    
+    Returns:
+        Tuple[ChromaVectorStore, HuggingFaceEmbedding]: Initialized vector store and embedding model
+        
+    Raises:
+        HTTPException: If vector store initialization fails
+    """
+    try:
+        embedding = HuggingFaceEmbedding(model_name=settings.EMBEDDING_MODEL)
+        vector_store = ChromaVectorStore(
+            embedding_function=embedding.embed_documents,
+            persist_directory=settings.CHROMA_PATH
+        )
+        return vector_store, embedding
+    except Exception as e:
+        logger.error(f"Error initializing vector store: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to initialize vector store")