Working chat with context and history

config/config.py

@@ -26,6 +26,9 @@ class Settings:
     # MongoDB Configuration
     MONGODB_URI = os.getenv('MONGODB_URI', 'mongodb://localhost:27017')
     
+    # Feedback Configuration
+    MAX_RATING = int(os.getenv('MAX_RATING', '5'))
+    
     # Application Configuration
     DEBUG = os.getenv('DEBUG', 'False') == 'True'
     

src/agents/rag_agent.py

@@ -1,136 +1,163 @@
 # src/agents/rag_agent.py
 from typing import List, Optional, Tuple, Dict
+import uuid
 
 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
+from src.utils.conversation_manager import ConversationManager
+from src.db.mongodb_store import MongoDBStore
 from src.models.rag import RAGResponse
+from src.utils.logger import logger
 
 class RAGAgent:
     def __init__(
-        self, 
-        llm: BaseLLM, 
-        embedding: BaseEmbedding, 
-        vector_store: BaseVectorStore
+        self,
+        llm: BaseLLM,
+        embedding: BaseEmbedding,
+        vector_store: BaseVectorStore,
+        mongodb: MongoDBStore,
+        max_history_tokens: int = 4000,
+        max_history_messages: int = 10
     ):
-        self.llm = llm
-        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
-    ) -> Tuple[List[str], List[Dict], Optional[List[float]]]:
         """
-        Retrieve relevant context documents for a given query
+        Initialize RAG Agent
         
         Args:
-            query (str): Input query to find context for
-            top_k (int): Number of top context documents to retrieve
-        
-        Returns:
-            Tuple[List[str], List[Dict], Optional[List[float]]]: Retrieved documents, sources, and scores
+            llm (BaseLLM): Language model instance
+            embedding (BaseEmbedding): Embedding model instance
+            vector_store (BaseVectorStore): Vector store instance
+            mongodb (MongoDBStore): MongoDB store instance
+            max_history_tokens (int): Maximum tokens in conversation history
+            max_history_messages (int): Maximum messages to keep in history
         """
-        # Embed the query
-        query_embedding = self.embedding.embed_query(query)
-        
-        # Retrieve similar documents with metadata and scores
-        results = self.vector_store.similarity_search(
-            query_embedding, 
-            top_k=top_k
+        self.llm = llm
+        self.embedding = embedding
+        self.vector_store = vector_store
+        self.mongodb = mongodb
+        self.conversation_manager = ConversationManager(
+            max_tokens=max_history_tokens,
+            max_messages=max_history_messages
         )
-        
-        # 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
-    
+
     async def generate_response(
-        self, 
+        self,
         query: str,
+        conversation_id: Optional[str] = None,
         temperature: float = 0.7,
         max_tokens: Optional[int] = None,
         context_docs: Optional[List[str]] = None
     ) -> RAGResponse:
+        """Generate a response using RAG with conversation history"""
+        try:
+            # Create new conversation if no ID provided
+            if not conversation_id:
+                conversation_id = str(uuid.uuid4())
+                await self.mongodb.create_conversation(conversation_id)
+            
+            # Get conversation history
+            history = await self.mongodb.get_recent_messages(
+                conversation_id,
+                limit=self.conversation_manager.max_messages
+            )
+            
+            # Get relevant history within token limits
+            relevant_history = self.conversation_manager.get_relevant_history(
+                messages=history,
+                current_query=query
+            ) if history else []
+
+            # Retrieve context if not provided
+            if not context_docs:
+                context_docs, sources, scores = await self.retrieve_context(
+                    query,
+                    conversation_history=relevant_history
+                )
+            else:
+                sources = None
+                scores = None
+
+            # Generate prompt with context and history
+            augmented_prompt = self.conversation_manager.generate_prompt_with_history(
+                current_query=query,
+                history=relevant_history,
+                context_docs=context_docs
+            )
+
+            # Generate response using LLM
+            response = self.llm.generate(
+                augmented_prompt,
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+
+            return RAGResponse(
+                response=response,
+                context_docs=context_docs,
+                sources=sources,
+                scores=scores
+            )
+
+        except Exception as e:
+            logger.error(f"Error generating response: {str(e)}")
+            raise
+
+    async def retrieve_context(
+        self,
+        query: str,
+        conversation_history: Optional[List[Dict]] = None,
+        top_k: int = 3
+    ) -> Tuple[List[str], List[Dict], Optional[List[float]]]:
         """
-        Generate a response using RAG approach
+        Retrieve context with conversation history enhancement
         
         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
-        
+            query (str): Current query
+            conversation_history (Optional[List[Dict]]): Recent conversation history
+            top_k (int): Number of documents to retrieve
+            
         Returns:
-            RAGResponse: Response with generated text and context
+            Tuple[List[str], List[Dict], Optional[List[float]]]: 
+                Retrieved documents, sources, and scores
         """
-        # If no context provided, retrieve from vector store
-        if not context_docs:
-            context_docs, sources, scores = self.retrieve_context(query)
+        # Enhance query with conversation history
+        if conversation_history:
+            recent_queries = [
+                msg['query'] for msg in conversation_history[-2:]
+                if msg.get('query')
+            ]
+            enhanced_query = " ".join([*recent_queries, query])
         else:
-            sources = None
-            scores = None
-        
-        # Construct augmented prompt with context
-        augmented_prompt = self._construct_prompt(query, context_docs)
-        
-        # 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,
-            sources=sources,
-            scores=scores
+            enhanced_query = query
+
+        # Embed the enhanced query
+        query_embedding = self.embedding.embed_query(enhanced_query)
+
+        # Retrieve similar documents
+        results = self.vector_store.similarity_search(
+            query_embedding,
+            top_k=top_k
         )
-    
-    def _construct_prompt(
-        self, 
-        query: str, 
-        context_docs: List[str]
-    ) -> str:
-        """
-        Construct a prompt with retrieved context
-        
-        Args:
-            query (str): Original user query
-            context_docs (List[str]): Retrieved context documents
-        
-        Returns:
-            str: Augmented prompt for the LLM
-        """
-        context_str = "\n\n".join(context_docs)
-        
-        return f"""
-        Context Information:
-        {context_str}
-        
-        User Query: {query}
-        
-        Based on the context, please provide a comprehensive and accurate response.
-        """
+
+        # Process results
+        documents = [doc['text'] for doc in results]
+        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]
+
+        # Return scores only if available for all documents
+        if len(scores) != len(documents):
+            scores = None
+
+        return documents, sources, scores
+
+    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

src/db/mongodb_store.py

@@ -10,8 +10,10 @@ class MongoDBStore:
         self.client = AsyncIOMotorClient(mongo_uri)
         self.db = self.client.db_chatbot
         self.chat_history = self.db.chat_history
+        self.conversations = self.db.conversations
         self.documents = self.db.knowledge_base
 
+    # Document-related methods
     async def store_document(
         self,
         document_id: str,
@@ -56,6 +58,60 @@ class MongoDBStore:
         )
         return await cursor.to_list(length=None)
 
+    async def delete_document(self, document_id: str) -> bool:
+        """Delete document from MongoDB"""
+        result = await self.documents.delete_one({"document_id": document_id})
+        return result.deleted_count > 0
+
+    # Conversation and chat history methods
+    async def create_conversation(
+        self,
+        conversation_id: str,
+        metadata: Optional[Dict] = None
+    ) -> str:
+        """Create a new conversation"""
+        conversation = {
+            "conversation_id": conversation_id,
+            "created_at": datetime.now(),
+            "last_updated": datetime.now(),
+            "message_count": 0,
+            "metadata": metadata or {}
+        }
+        
+        await self.conversations.insert_one(conversation)
+        return conversation_id
+
+    async def get_conversation_metadata(
+        self,
+        conversation_id: str
+    ) -> Optional[Dict]:
+        """Get conversation metadata"""
+        result = await self.conversations.find_one(
+            {"conversation_id": conversation_id}
+        )
+        if result:
+            result["_id"] = str(result["_id"])
+        return result
+
+    async def update_conversation_metadata(
+        self,
+        conversation_id: str,
+        metadata: Dict
+    ) -> bool:
+        """Update conversation metadata"""
+        result = await self.conversations.update_one(
+            {"conversation_id": conversation_id},
+            {
+                "$set": {
+                    "metadata": metadata,
+                    "last_updated": datetime.now()
+                }
+            }
+        )
+        return result.modified_count > 0
+
+    # Update the store_message method:
+
     async def store_message(
         self,
         conversation_id: str,
@@ -66,23 +122,52 @@ class MongoDBStore:
         llm_provider: str
     ) -> str:
         """Store chat message in MongoDB"""
-        document = {
+        # Store user message
+        user_message = {
+            "conversation_id": conversation_id,
+            "timestamp": datetime.now(),
+            "role": "user",
+            "content": query,
+            "query": query,  # Keep for backward compatibility
+            "response": None,
+            "context": context,
+            "sources": sources,
+            "llm_provider": llm_provider,
+            "feedback": None,
+            "rating": None
+        }
+        await self.chat_history.insert_one(user_message)
+
+        # Store assistant message
+        assistant_message = {
             "conversation_id": conversation_id,
             "timestamp": datetime.now(),
-            "query": query,
-            "response": response,
+            "role": "assistant",
+            "content": response,
+            "query": None,
+            "response": response,  # Keep for backward compatibility
             "context": context,
             "sources": sources,
             "llm_provider": llm_provider,
             "feedback": None,
             "rating": None
         }
+        result = await self.chat_history.insert_one(assistant_message)
+        
+        # Update conversation metadata
+        await self.conversations.update_one(
+            {"conversation_id": conversation_id},
+            {
+                "$set": {"last_updated": datetime.now()},
+                "$inc": {"message_count": 2}  # Increment by 2 since we store both messages
+            },
+            upsert=True
+        )
         
-        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"""
+        """Retrieve complete conversation history"""
         cursor = self.chat_history.find(
             {"conversation_id": conversation_id}
         ).sort("timestamp", 1)
@@ -94,25 +179,77 @@ class MongoDBStore:
             
         return history
 
+    async def get_recent_messages(
+        self,
+        conversation_id: str,
+        limit: int = 5
+    ) -> List[Dict]:
+        """Get most recent messages from conversation"""
+        cursor = self.chat_history.find(
+            {"conversation_id": conversation_id}
+        ).sort("timestamp", -1).limit(limit * 2)  # Multiply limit by 2 to account for user-assistant pairs
+        
+        messages = []
+        async for doc in cursor:
+            messages.append(self._format_message(doc))
+            
+        return list(reversed(messages))
+    
     async def update_feedback(
         self,
         conversation_id: str,
         feedback: Optional[str],
         rating: Optional[int]
     ) -> bool:
-        """Update feedback for a conversation"""
+        """
+        Update feedback for a conversation
+        
+        Args:
+            conversation_id (str): Conversation ID
+            feedback (Optional[str]): Feedback text
+            rating (Optional[int]): Numeric rating
+            
+        Returns:
+            bool: True if update successful
+        """
+        update_fields = {}
+        
+        if feedback is not None:
+            update_fields["feedback"] = feedback
+            
+        if rating is not None:
+            from config.config import settings
+            formatted_rating = f"{rating}/{settings.MAX_RATING}"
+            update_fields.update({
+                "rating": rating,  # Store numeric value
+                "formatted_rating": formatted_rating  # Store formatted string
+            })
+        
+        if not update_fields:
+            return False
+
         result = await self.chat_history.update_many(
             {"conversation_id": conversation_id},
-            {
-                "$set": {
-                    "feedback": feedback,
-                    "rating": rating
-                }
-            }
+            {"$set": update_fields}
         )
+        
+        # Also update conversation metadata
+        if result.modified_count > 0:
+            await self.update_conversation_metadata(
+                conversation_id,
+                {
+                    "last_feedback": datetime.now(),
+                    "last_rating": rating if rating is not None else None,
+                    "formatted_rating": formatted_rating if rating is not None else None
+                }
+            )
+        
         return result.modified_count > 0
 
-    async def get_messages_for_summary(self, conversation_id: str) -> List[Dict]:
+    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}
@@ -120,16 +257,67 @@ class MongoDBStore:
         
         messages = []
         async for doc in cursor:
+            formatted = self._format_message(doc)
+            # For summary, we only need specific fields
             messages.append({
-                'role': 'user' if doc['query'] else 'assistant',
-                'content': doc['query'] or doc['response'],
-                'timestamp': doc['timestamp'],
-                'sources': doc['sources']
+                'role': formatted['role'],
+                'content': formatted['content'],
+                'timestamp': formatted['timestamp'],
+                'sources': formatted['sources']
             })
             
         return messages
     
-    async def delete_document(self, document_id: str) -> bool:
-        """Delete document from MongoDB"""
-        result = await self.documents.delete_one({"document_id": document_id})
+    
+    def _format_message(self, doc: Dict) -> Dict:
+        """Helper method to format message documents consistently"""
+        return {
+            "_id": str(doc["_id"]) if "_id" in doc else None,
+            "conversation_id": doc.get("conversation_id"),
+            "timestamp": doc.get("timestamp"),
+            "role": doc.get("role", "user" if doc.get("query") else "assistant"),
+            "content": doc.get("content", doc.get("query") or doc.get("response", "")),
+            "context": doc.get("context", []),
+            "sources": doc.get("sources", []),
+            "llm_provider": doc.get("llm_provider"),
+            "feedback": doc.get("feedback"),
+            "rating": doc.get("rating")
+        }
+    
+    # Vector store related methods
+    async def store_vector_metadata(
+        self,
+        document_id: str,
+        chunk_id: str,
+        metadata: Dict[str, Any]
+    ) -> str:
+        """Store vector chunk metadata"""
+        vector_metadata = {
+            "document_id": document_id,
+            "chunk_id": chunk_id,
+            "metadata": metadata,
+            "created_at": datetime.now()
+        }
+        
+        result = await self.db.vector_metadata.insert_one(vector_metadata)
+        return str(result.inserted_id)
+
+    async def get_vector_metadata(
+        self,
+        document_id: str
+    ) -> List[Dict]:
+        """Get vector metadata for a document"""
+        cursor = self.db.vector_metadata.find(
+            {"document_id": document_id}
+        )
+        return await cursor.to_list(length=None)
+
+    async def delete_vector_metadata(
+        self,
+        document_id: str
+    ) -> bool:
+        """Delete vector metadata for a document"""
+        result = await self.db.vector_metadata.delete_many(
+            {"document_id": document_id}
+        )
         return result.deleted_count > 0

src/main.py

@@ -2,6 +2,7 @@
 from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
 from fastapi.responses import StreamingResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware  # Add this import
 from typing import List
 import uuid
 from datetime import datetime
@@ -30,6 +31,14 @@ from config.config import settings
 
 app = FastAPI(title="Chatbot API")
 
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:8080"],  # Add your frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
 # Initialize MongoDB
 mongodb = MongoDBStore(settings.MONGODB_URI)
 
@@ -192,26 +201,25 @@ async def chat_endpoint(
         vector_store, embedding_model = await get_vector_store()
         llm = get_llm_instance(request.llm_provider)
         
+        # Initialize RAG agent with required MongoDB
         rag_agent = RAGAgent(
             llm=llm,
             embedding=embedding_model,
-            vector_store=vector_store
+            vector_store=vector_store,
+            mongodb=mongodb
         )
         
-        if request.stream:
-            return StreamingResponse(
-                rag_agent.generate_streaming_response(request.query),
-                media_type="text/event-stream"
-            )
-        
+        # Use provided conversation ID or create new one
+        conversation_id = request.conversation_id or str(uuid.uuid4())
+        query = request.query + ". The response should be short and to the point. make sure, to not add any irrelevant information. Stick to the point is very very important."
+        # Generate response
         response = await rag_agent.generate_response(
-            query=request.query,
+            query=query,
+            conversation_id=conversation_id,
             temperature=request.temperature
         )
         
-        conversation_id = request.conversation_id or str(uuid.uuid4())
-        
-        # Store chat history in MongoDB
+        # Store message in chat history
         await mongodb.store_message(
             conversation_id=conversation_id,
             query=request.query,
@@ -274,6 +282,12 @@ async def submit_feedback(
 ):
     """Submit feedback for a conversation"""
     try:
+        # Validate conversation exists
+        conversation = await mongodb.get_conversation_metadata(conversation_id)
+        if not conversation:
+            raise HTTPException(status_code=404, detail="Conversation not found")
+        
+        # Update feedback
         success = await mongodb.update_feedback(
             conversation_id=conversation_id,
             feedback=feedback_request.feedback,
@@ -281,10 +295,23 @@ async def submit_feedback(
         )
         
         if not success:
-            raise HTTPException(status_code=404, detail="Conversation not found")
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to update feedback"
+            )
             
-        return {"status": "Feedback submitted successfully"}
+        return {
+            "status": "success",
+            "message": "Feedback submitted successfully",
+            "data": {
+                "conversation_id": conversation_id,
+                "feedback": feedback_request.feedback,
+                "rating": feedback_request.format_rating()
+            }
+        }
         
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error submitting feedback: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))

src/models/chat.py

@@ -4,6 +4,11 @@ from typing import Optional, List, Dict
 from datetime import datetime
 from .base import ChatMetadata
 
+from pydantic import BaseModel, validator, Field
+from typing import Optional
+from config.config import settings
+
+
 class ChatRequest(BaseModel):
     """Request model for chat endpoint"""
     query: str
@@ -21,10 +26,19 @@ class ChatResponse(ChatMetadata):
     relevant_doc_scores: Optional[List[float]] = None
 
 class FeedbackRequest(BaseModel):
-    """Request model for feedback endpoint"""
-    rating: int
+    rating: int = Field(..., ge=0, le=settings.MAX_RATING)
     feedback: Optional[str] = None
 
+    @validator('rating')
+    def validate_rating(cls, v):
+        if v < 0 or v > settings.MAX_RATING:
+            raise ValueError(f'Rating must be between 0 and {settings.MAX_RATING}')
+        return v
+
+    def format_rating(self) -> str:
+        """Format rating as a fraction of maximum"""
+        return f"{self.rating}/{settings.MAX_RATING}"
+
 class SummarizeRequest(BaseModel):
     """Request model for summarize endpoint"""
     conversation_id: str

src/models/rag.py

@@ -1,11 +1,37 @@
 # src/models/rag.py
 from dataclasses import dataclass
 from typing import List, Optional, Dict
+from datetime import datetime
+
+@dataclass
+class Message:
+    """Single message in a conversation"""
+    role: str  # 'user' or 'assistant'
+    content: str
+    timestamp: datetime
+
+@dataclass
+class ConversationContext:
+    """Conversation context with history"""
+    messages: List[Message]
+    max_messages: int = 10
+
+    def add_message(self, role: str, content: str):
+        """Add a message while maintaining max size"""
+        self.messages.append(Message(
+            role=role,
+            content=content,
+            timestamp=datetime.now()
+        ))
+        # Keep only the most recent messages
+        if len(self.messages) > self.max_messages:
+            self.messages = self.messages[-self.max_messages:]
 
 @dataclass
 class RAGResponse:
-    """Response model for RAG-based generation"""
+    """Enhanced RAG response with conversation context"""
     response: str
     context_docs: Optional[List[str]] = None
     sources: Optional[List[Dict]] = None
-    scores: Optional[List[float]] = None
+    scores: Optional[List[float]] = None
+    conversation_context: Optional[ConversationContext] = None

src/utils/conversation_manager.py

@@ -0,0 +1,111 @@
+# src/utils/conversation_manager.py
+from typing import List, Dict, Optional
+import tiktoken
+from datetime import datetime
+
+class ConversationManager:
+    def __init__(
+        self,
+        max_tokens: int = 4000,
+        max_messages: int = 10,
+        model: str = "gpt-3.5-turbo"
+    ):
+        """
+        Initialize conversation manager
+        
+        Args:
+            max_tokens (int): Maximum tokens to keep in context
+            max_messages (int): Maximum number of messages to keep
+            model (str): Model name for token counting
+        """
+        self.max_tokens = max_tokens
+        self.max_messages = max_messages
+        self.encoding = tiktoken.encoding_for_model(model)
+        
+    def format_messages(self, messages: List[Dict]) -> str:
+        """Format messages into a conversation string"""
+        formatted = []
+        for msg in messages:
+            role = msg.get('role', 'unknown')
+            content = msg.get('content', '')
+            formatted.append(f"{role.capitalize()}: {content}")
+        return "\n".join(formatted)
+    
+    def count_tokens(self, text: str) -> int:
+        """Count tokens in text"""
+        return len(self.encoding.encode(text))
+    
+    def get_relevant_history(
+        self,
+        messages: List[Dict],
+        current_query: str,
+        max_tokens: Optional[int] = None
+    ) -> List[Dict]:
+        """
+        Get relevant conversation history within token limit
+        
+        Args:
+            messages (List[Dict]): Full message history
+            current_query (str): Current user query
+            max_tokens (Optional[int]): Override default max tokens
+            
+        Returns:
+            List[Dict]: Relevant message history
+        """
+        max_tokens = max_tokens or self.max_tokens
+        current_tokens = self.count_tokens(current_query)
+        
+        # Keep track of tokens and messages
+        history = []
+        total_tokens = current_tokens
+        
+        # Process messages from most recent to oldest
+        for msg in reversed(messages[-self.max_messages:]):
+            msg_text = f"{msg['role']}: {msg['content']}\n"
+            msg_tokens = self.count_tokens(msg_text)
+            
+            # Check if adding this message would exceed token limit
+            if total_tokens + msg_tokens > max_tokens:
+                break
+                
+            total_tokens += msg_tokens
+            history.append(msg)
+        
+        # Reverse back to chronological order
+        return list(reversed(history))
+    
+    def generate_prompt_with_history(
+        self,
+        current_query: str,
+        history: List[Dict],
+        context_docs: List[str]
+    ) -> str:
+        """
+        Generate a prompt that includes conversation history and context
+        
+        Args:
+            current_query (str): Current user query
+            history (List[Dict]): Relevant conversation history
+            context_docs (List[str]): Retrieved context documents
+            
+        Returns:
+            str: Formatted prompt
+        """
+        # Format conversation history
+        conversation_context = self.format_messages(history)
+        
+        # Format context documents
+        context_str = "\n\n".join(context_docs)
+        
+        prompt = f"""
+Previous Conversation:
+{conversation_context}
+
+Relevant Context:
+{context_str}
+
+Current Query: {current_query}
+
+Based on the previous conversation and the provided context, please provide a comprehensive and accurate response that maintains continuity with the conversation history."""
+        
+        return prompt