Commit chatbot chnages

src/agents/rag_agent.py

@@ -1,16 +1,11 @@
 # src/agents/rag_agent.py
-from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Optional, Tuple, Dict
 
 from ..llms.base_llm import BaseLLM
 from src.embeddings.base_embedding import BaseEmbedding
 from src.vectorstores.base_vectorstore import BaseVectorStore
 from src.utils.text_splitter import split_text
-
-@dataclass
-class RAGResponse:
-    response: str
-    context_docs: Optional[List[str]] = None
+from src.models.rag import RAGResponse
 
 class RAGAgent:
     def __init__(
@@ -23,11 +18,21 @@ class RAGAgent:
         self.embedding = embedding
         self.vector_store = vector_store
     
+    def _convert_metadata_to_strings(self, metadata: Dict) -> Dict:
+        """Convert numeric metadata values to strings"""
+        converted = {}
+        for key, value in metadata.items():
+            if isinstance(value, (int, float)):
+                converted[key] = str(value)
+            else:
+                converted[key] = value
+        return converted
+    
     def retrieve_context(
         self, 
         query: str, 
         top_k: int = 3
-    ) -> List[str]:
+    ) -> Tuple[List[str], List[Dict], Optional[List[float]]]:
         """
         Retrieve relevant context documents for a given query
         
@@ -36,22 +41,36 @@ class RAGAgent:
             top_k (int): Number of top context documents to retrieve
         
         Returns:
-            List[str]: List of retrieved context documents
+            Tuple[List[str], List[Dict], Optional[List[float]]]: Retrieved documents, sources, and scores
         """
         # Embed the query
         query_embedding = self.embedding.embed_query(query)
         
-        # Retrieve similar documents
-        context_docs = self.vector_store.similarity_search(
+        # Retrieve similar documents with metadata and scores
+        results = self.vector_store.similarity_search(
             query_embedding, 
             top_k=top_k
         )
         
-        return context_docs
+        # Extract documents, sources, and scores from results
+        documents = [doc['text'] for doc in results]
+        
+        # Convert numeric metadata values to strings
+        sources = [self._convert_metadata_to_strings(doc['metadata']) for doc in results]
+        
+        scores = [doc['score'] for doc in results if doc.get('score') is not None]
+        
+        # Only return scores if we have them for all documents
+        if len(scores) != len(documents):
+            scores = None
+            
+        return documents, sources, scores
     
-    def generate_response(
+    async def generate_response(
         self, 
-        query: str, 
+        query: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
         context_docs: Optional[List[str]] = None
     ) -> RAGResponse:
         """
@@ -59,6 +78,8 @@ class RAGAgent:
         
         Args:
             query (str): User input query
+            temperature (float): Sampling temperature for the LLM
+            max_tokens (Optional[int]): Maximum tokens to generate
             context_docs (Optional[List[str]]): Optional pre-provided context documents
         
         Returns:
@@ -66,17 +87,26 @@ class RAGAgent:
         """
         # If no context provided, retrieve from vector store
         if not context_docs:
-            context_docs = self.retrieve_context(query)
+            context_docs, sources, scores = self.retrieve_context(query)
+        else:
+            sources = None
+            scores = None
         
         # Construct augmented prompt with context
         augmented_prompt = self._construct_prompt(query, context_docs)
         
-        # Generate response using LLM
-        response = self.llm.generate(augmented_prompt)
+        # Generate response using LLM with temperature
+        response = self.llm.generate(
+            augmented_prompt,
+            temperature=temperature,
+            max_tokens=max_tokens
+        )
         
         return RAGResponse(
-            response=response, 
-            context_docs=context_docs
+            response=response,
+            context_docs=context_docs,
+            sources=sources,
+            scores=scores
         )
     
     def _construct_prompt(

src/main.py

@@ -289,6 +289,37 @@ async def submit_feedback(
         logger.error(f"Error submitting feedback: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/debug/config")
+async def debug_config():
+    """Debug endpoint to check configuration"""
+    import os
+    from config.config import settings
+    from pathlib import Path
+    
+    debug_info = {
+        "environment_variables": {
+            "OPENAI_API_KEY": "[SET]" if os.getenv('OPENAI_API_KEY') else "[NOT SET]",
+            "OPENAI_MODEL": os.getenv('OPENAI_MODEL', '[NOT SET]')
+        },
+        "settings": {
+            "OPENAI_API_KEY": "[SET]" if settings.OPENAI_API_KEY else "[NOT SET]",
+            "OPENAI_MODEL": settings.OPENAI_MODEL,
+        },
+        "files": {
+            "env_file_exists": Path('.env').exists(),
+            "openai_config_exists": (Path.home() / '.openai' / 'api_key').exists()
+        }
+    }
+    
+    if settings.OPENAI_API_KEY:
+        key = settings.OPENAI_API_KEY
+        debug_info["api_key_info"] = {
+            "length": len(key),
+            "preview": f"{key[:4]}...{key[-4:]}" if len(key) > 8 else "[INVALID LENGTH]"
+        }
+        
+    return debug_info
+
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""

src/models/rag.py

@@ -0,0 +1,11 @@
+# src/models/rag.py
+from dataclasses import dataclass
+from typing import List, Optional, Dict
+
+@dataclass
+class RAGResponse:
+    """Response model for RAG-based generation"""
+    response: str
+    context_docs: Optional[List[str]] = None
+    sources: Optional[List[Dict]] = None
+    scores: Optional[List[float]] = None

src/vectorstores/chroma_vectorstore.py

@@ -91,7 +91,7 @@ class ChromaVectorStore(BaseVectorStore):
         query_embedding: List[float], 
         top_k: int = 3,
         **kwargs
-    ) -> List[str]:
+    ) -> List[Dict[str, Any]]:
         """
         Perform similarity search
         
@@ -101,20 +101,34 @@ class ChromaVectorStore(BaseVectorStore):
             **kwargs: Additional search parameters
         
         Returns:
-            List[str]: List of most similar documents
+            List[Dict[str, Any]]: List of documents with their text, metadata, and scores
         """
         try:
             results = self.collection.query(
                 query_embeddings=[query_embedding],
                 n_results=top_k,
-                **kwargs
+                include=['documents', 'metadatas', 'distances']
             )
             
             # Handle the case where no results are found
-            if not results or 'documents' not in results:
+            if not results or 'documents' not in results or not results['documents']:
                 return []
+            
+            # Format results to include text, metadata, and scores
+            formatted_results = []
+            documents = results['documents'][0]  # First query's results
+            metadatas = results['metadatas'][0] if results.get('metadatas') else [None] * len(documents)
+            distances = results['distances'][0] if results.get('distances') else [None] * len(documents)
+            
+            for doc, meta, dist in zip(documents, metadatas, distances):
+                formatted_results.append({
+                    'text': doc,
+                    'metadata': meta or {},
+                    'score': 1.0 - (dist or 0.0) if dist is not None else None  # Convert distance to similarity score
+                })
+            
+            return formatted_results
                 
-            return results.get('documents', [[]])[0]
         except Exception as e:
             logging.error(f"Error performing similarity search in ChromaDB: {str(e)}")
             raise
@@ -125,6 +139,12 @@ class ChromaVectorStore(BaseVectorStore):
     ) -> List[Dict[str, Any]]:
         """
         Retrieve all documents from the vector store
+        
+        Args:
+            include_embeddings (bool): Whether to include embeddings in the response
+        
+        Returns:
+            List[Dict[str, Any]]: List of documents with their IDs and optionally embeddings
         """
         try:
             include = ["documents", "metadatas"]
@@ -163,7 +183,15 @@ class ChromaVectorStore(BaseVectorStore):
             raise
     
     def get_document_chunks(self, document_id: str) -> List[Dict[str, Any]]:
-        """Retrieve all chunks for a specific document"""
+        """
+        Retrieve all chunks for a specific document
+        
+        Args:
+            document_id (str): ID of the document to retrieve chunks for
+            
+        Returns:
+            List[Dict[str, Any]]: List of document chunks with their metadata
+        """
         try:
             results = self.collection.get(
                 where={"document_id": document_id},
@@ -190,7 +218,12 @@ class ChromaVectorStore(BaseVectorStore):
             raise
 
     def delete_document(self, document_id: str) -> None:
-        """Delete all chunks associated with a document_id"""
+        """
+        Delete all chunks associated with a document_id
+        
+        Args:
+            document_id (str): ID of the document to delete
+        """
         try:
             # Get all chunks with the given document_id
             results = self.collection.get(