Chat-engine cache

app/api/postgresql_routes.py

@@ -19,8 +19,6 @@ from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy import desc, func
 from cachetools import TTLCache
 import uuid
-import asyncio
-import httpx  # Import httpx for HTTP requests
 
 from app.database.postgresql import get_db
 from app.database.models import FAQItem, EmergencyItem, EventItem, AboutPixity, SolanaSummit, DaNangBucketList, ApiKey, VectorDatabase, Document, VectorStatus, TelegramBot, ChatEngine, BotEngine, EngineVectorDb, DocumentContent
@@ -3204,7 +3202,6 @@ class VectorStatusBase(BaseModel):
     document_id: int
     vector_database_id: int
     vector_id: Optional[str] = None
-    document_name: Optional[str] = None  # Added to match database schema
     status: str = "pending"
     error_message: Optional[str] = None
 
@@ -3668,167 +3665,69 @@ async def update_document(
                 db.add(document_content)
             
             # Get vector status for Pinecone cleanup
-            vector_status = db.query(VectorStatus).filter(
-                VectorStatus.document_id == document_id,
-                VectorStatus.vector_database_id == document.vector_database_id
-            ).first()
+            vector_status = db.query(VectorStatus).filter(VectorStatus.document_id == document_id).first()
             
             # Store old vector_id for cleanup
             old_vector_id = None
             if vector_status and vector_status.vector_id:
                 old_vector_id = vector_status.vector_id
-                logger.info(f"Found old vector_id {old_vector_id} for document {document_id}, planning to delete")
             
-            # Delete old vector status and create a new one
+            # Update vector status to pending
             if vector_status:
-                # Instead of updating the status, delete the old one and create a new one
-                # This avoids validation errors with constrains on the vector_status table
-                db.delete(vector_status)
-                db.flush()  # Ensure the delete is processed before creating a new one
-                logger.info(f"Deleted old vector status for document {document_id}")
-            
-            # Create new vector status
+                vector_status.status = "pending"
+                vector_status.vector_id = None
+                vector_status.embedded_at = None
+                vector_status.error_message = None
+            else:
+                # Create new vector status if it doesn't exist
                 vector_status = VectorStatus(
                     document_id=document_id,
                     vector_database_id=document.vector_database_id,
-                status="pending",
-                document_name=document.name
+                    status="pending"
                 )
                 db.add(vector_status)
-            db.flush()
-            logger.info(f"Created new vector status for document {document_id} with status 'pending'")
             
-            # Delete old vectors from Pinecone if we have vector_id and vector_db
-            if old_vector_id and vector_db and document.vector_database_id:
+            # Schedule deletion of old vectors in Pinecone if we have all needed info
+            if old_vector_id and vector_db and document.vector_database_id and background_tasks:
                 try:
-                    import httpx
-                    
-                    # Call PDF API to delete document using HTTP request (avoids circular imports)
-                    base_url = "http://localhost:8000"
-                    delete_url = f"{base_url}/pdf/document"
+                    # Initialize PDFProcessor for vector deletion
+                    from app.pdf.processor import PDFProcessor
                     
-                    params = {
-                        "document_id": old_vector_id,  # Use the vector_id instead of document ID
-                        "namespace": f"vdb-{document.vector_database_id}",
-                        "index_name": vector_db.pinecone_index,
-                        "vector_database_id": document.vector_database_id
-                    }
+                    processor = PDFProcessor(
+                        index_name=vector_db.pinecone_index,
+                        namespace=f"vdb-{document.vector_database_id}",
+                        vector_db_id=document.vector_database_id
+                    )
                     
-                    logger.info(f"Deleting old vectors for document {document_id} with params: {params}")
+                    # Add deletion task to background tasks
+                    background_tasks.add_task(
+                        processor.delete_document_vectors,
+                        old_vector_id
+                    )
                     
-                    # Run deletion synchronously to ensure completion before proceeding
-                    async with httpx.AsyncClient() as client:
-                        response = await client.delete(delete_url, params=params)
-                        if response.status_code == 200:
-                            result = response.json()
-                            vectors_deleted = result.get('vectors_deleted', 0)
-                            logger.info(f"Successfully deleted {vectors_deleted} old vectors for document {document_id}")
-                        else:
-                            logger.warning(f"Failed to delete old vectors: {response.status_code} - {response.text}")
+                    logger.info(f"Scheduled deletion of old vectors for document {document_id}")
                 except Exception as e:
-                    logger.error(f"Error deleting old vectors: {str(e)}")
-                    # Continue with the update even if vector deletion fails
+                    logger.error(f"Error scheduling vector deletion: {str(e)}")
+                    # Continue with the update even if vector deletion scheduling fails
             
-            # Now start a background task to upload and process the new document
-            if document.vector_database_id:
+            # Schedule document for re-embedding if possible
+            if background_tasks and document.vector_database_id:
                 try:
-                    # Use httpx to call the PDF API to upload the new document
-                    # This ensures we reuse all the existing upload and vector creation logic
-                    import tempfile
-                    import os
+                    # Import here to avoid circular imports
+                    from app.pdf.tasks import process_document_for_embedding
                     
-                    logger.info(f"Starting background task to re-upload document {document_id}")
-                    
-                    # Define an async function for uploading in background
-                    async def upload_and_process_document():
-                        try:
-                            # Create temporary file with the document content
-                            with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file_extension}") as temp_file:
-                                temp_file.write(file_content)
-                                temp_path = temp_file.name
-                            
-                            # Prepare multipart form data for the upload
-                            import aiofiles
-                            from aiofiles import os as aio_os
-                            
-                            async with httpx.AsyncClient(timeout=300) as client:  # Increased timeout to 300 seconds
-                                # Open the temp file for async reading
-                                async with aiofiles.open(temp_path, "rb") as f:
-                                    file_data = await f.read()
-                                
-                                # Create form data
-                                files = {"file": (filename, file_data, document.content_type)}
-                                form_data = {
-                                    "title": document.name,
-                                    "vector_database_id": str(document.vector_database_id),
-                                    "namespace": f"vdb-{document.vector_database_id}"
-                                }
-                                
-                                # Call the PDF upload API
-                                upload_url = f"{base_url}/pdf/upload"
-                                logger.info(f"Calling PDF upload API for document {document_id}")
-                                
-                                response = await client.post(upload_url, files=files, data=form_data)
-                                
-                                # Process the response
-                                if response.status_code == 200:
-                                    result = response.json()
-                                    logger.info(f"Successfully uploaded document {document_id}: {result}")
-                                    
-                                    # Get the new vector_id from the result
-                                    new_vector_id = result.get('document_id')
-                                    
-                                    # If upload was successful, update the vector status in PostgreSQL
-                                    if result.get('success') and new_vector_id:
-                                        # Get the latest vector status
-                                        await asyncio.sleep(1)  # Small delay to ensure DB consistency
-                                        
-                                        # Use a new DB session for this update
-                                        from app.database.postgresql import SessionLocal
-                                        async_db = SessionLocal()
-                                        try:
-                                            vs = async_db.query(VectorStatus).filter(
-                                                VectorStatus.document_id == document_id,
-                                                VectorStatus.vector_database_id == document.vector_database_id
-                                            ).first()
-                                            
-                                            if vs:
-                                                vs.vector_id = new_vector_id
-                                                vs.status = "completed"
-                                                vs.embedded_at = datetime.now()
-                                                
-                                                # Also update document embedded status
-                                                doc = async_db.query(Document).filter(Document.id == document_id).first()
-                                                if doc:
-                                                    doc.is_embedded = True
-                                                
-                                                async_db.commit()
-                                                logger.info(f"Updated vector status with new vector_id {new_vector_id}")
-                                        finally:
-                                            async_db.close()
-                                else:
-                                    logger.error(f"Failed to upload document: {response.status_code} - {response.text}")
-                            
-                            # Clean up temporary file
-                            try:
-                                await aio_os.remove(temp_path)
-                            except Exception as cleanup_error:
-                                logger.error(f"Error cleaning up temporary file: {str(cleanup_error)}")
-                        except Exception as e:
-                            logger.error(f"Error in background upload task: {str(e)}")
-                            logger.error(traceback.format_exc())
+                    # Schedule embedding
+                    background_tasks.add_task(
+                        process_document_for_embedding,
+                        document_id=document_id,
+                        vector_db_id=document.vector_database_id
+                    )
                     
-                    # Add the task to background tasks
-                    if background_tasks:
-                        background_tasks.add_task(upload_and_process_document)
-                        logger.info("Added document upload to background tasks")
-                    else:
-                        logger.warning("Background tasks not available, skipping document upload")
+                    logger.info(f"Scheduled re-embedding for document {document_id}")
                 except Exception as e:
-                    logger.error(f"Error setting up document re-upload: {str(e)}")
-                    # Continue with the update even if re-upload setup fails
+                    logger.error(f"Error scheduling document embedding: {str(e)}")
+                    # Continue with the update even if embedding scheduling fails
         
-        # Commit changes to document record
         db.commit()
         db.refresh(document)
         
@@ -3878,152 +3777,31 @@ async def delete_document(
     - **document_id**: ID of the document to delete
     """
     try:
-        logger.info(f"Starting deletion process for document ID {document_id}")
-        
         # Check if document exists
         document = db.query(Document).filter(Document.id == document_id).first()
         if not document:
-            logger.warning(f"Document with ID {document_id} not found for deletion")
             raise HTTPException(status_code=404, detail=f"Document with ID {document_id} not found")
         
-        vector_database_id = document.vector_database_id
-        logger.info(f"Found document to delete: name={document.name}, vector_database_id={vector_database_id}")
-        
-        # Get the vector_id from VectorStatus before deletion
-        vector_status = db.query(VectorStatus).filter(
-            VectorStatus.document_id == document_id,
-            VectorStatus.vector_database_id == vector_database_id
-        ).first()
-        
-        # Store the vector_id for Pinecone deletion
-        vector_id = None
-        pinecone_deletion_success = False
-        pinecone_error = None
-        
-        if vector_status and vector_status.vector_id:
-            vector_id = vector_status.vector_id
-            logger.info(f"Found vector_id {vector_id} for document {document_id}")
-            
-            # Get vector database info
-            vector_db = db.query(VectorDatabase).filter(
-                VectorDatabase.id == vector_database_id
-            ).first()
-            
-            if vector_db:
-                logger.info(f"Found vector database: name={vector_db.name}, index={vector_db.pinecone_index}")
-                
-                # Create namespace for vector database
-                namespace = f"vdb-{vector_database_id}"
-                
-                try:
-                    import httpx
-                    
-                    # Call PDF API to delete from Pinecone using an HTTP request
-                    # This avoids circular import issues
-                    base_url = "http://localhost:8000"  # Adjust this to match your actual base URL
-                    delete_url = f"{base_url}/pdf/document"
-                    
-                    params = {
-                        "document_id": vector_id,  # Use the vector_id instead of the PostgreSQL document ID
-                        "namespace": namespace,
-                        "index_name": vector_db.pinecone_index,
-                        "vector_database_id": vector_database_id
-                    }
-                    
-                    logger.info(f"Calling PDF API to delete vectors with params: {params}")
-                    
-                    # Add retry logic for better reliability
-                    max_retries = 3
-                    retry_delay = 2  # seconds
-                    success = False
-                    last_error = None
-                    
-                    for retry in range(max_retries):
-                        try:
-                            async with httpx.AsyncClient(timeout=300) as client:  # Increased timeout to 300 seconds
-                                response = await client.delete(delete_url, params=params)
-                                
-                                if response.status_code == 200:
-                                    result = response.json()
-                                    pinecone_deletion_success = result.get('success', False)
-                                    vectors_deleted = result.get('vectors_deleted', 0)
-                                    logger.info(f"Vector deletion API call response: success={pinecone_deletion_success}, vectors_deleted={vectors_deleted}")
-                                    success = True
-                                    break
-                                else:
-                                    last_error = f"Failed with status code {response.status_code}: {response.text}"
-                                    logger.warning(f"Deletion attempt {retry+1}/{max_retries} failed: {last_error}")
-                        except Exception as e:
-                            last_error = str(e)
-                            logger.warning(f"Deletion attempt {retry+1}/{max_retries} failed with exception: {last_error}")
-                        
-                        # Wait before retrying
-                        if retry < max_retries - 1:  # Don't sleep after the last attempt
-                            logger.info(f"Retrying in {retry_delay} seconds...")
-                            await asyncio.sleep(retry_delay)
-                            retry_delay *= 2  # Exponential backoff
-                    
-                    if not success:
-                        pinecone_error = f"All deletion attempts failed. Last error: {last_error}"
-                        logger.warning(pinecone_error)
-                        # Continue with PostgreSQL deletion even if Pinecone deletion fails
-                except Exception as e:
-                    pinecone_error = f"Error setting up Pinecone deletion: {str(e)}"
-                    logger.error(pinecone_error)
-                    # Continue with PostgreSQL deletion even if Pinecone deletion fails
-        else:
-            logger.warning(f"No vector_id found for document {document_id}, skipping Pinecone deletion")
-        
         # Delete vector status
-        result_vs = db.query(VectorStatus).filter(VectorStatus.document_id == document_id).delete()
-        logger.info(f"Deleted {result_vs} vector status records for document {document_id}")
+        db.query(VectorStatus).filter(VectorStatus.document_id == document_id).delete()
         
         # Delete document content
-        result_dc = db.query(DocumentContent).filter(DocumentContent.document_id == document_id).delete()
-        logger.info(f"Deleted {result_dc} document content records for document {document_id}")
+        db.query(DocumentContent).filter(DocumentContent.document_id == document_id).delete()
         
         # Delete document
         db.delete(document)
         db.commit()
-        logger.info(f"Document with ID {document_id} successfully deleted from PostgreSQL")
-        
-        # Prepare response with information about what happened
-        response = {
-            "status": "success",
-            "message": f"Document with ID {document_id} deleted successfully",
-            "postgresql_deletion": {
-                "document_deleted": True,
-                "vector_status_deleted": result_vs > 0,
-                "document_content_deleted": result_dc > 0
-            }
-        }
-        
-        # Add Pinecone deletion information
-        if vector_id:
-            response["pinecone_deletion"] = {
-                "attempted": True,
-                "vector_id": vector_id,
-                "success": pinecone_deletion_success,
-            }
-            if pinecone_error:
-                response["pinecone_deletion"]["error"] = pinecone_error
-        else:
-            response["pinecone_deletion"] = {
-                "attempted": False,
-                "reason": "No vector_id found for document"
-            }
         
-        return response
+        return {"status": "success", "message": f"Document with ID {document_id} deleted successfully"}
     except HTTPException:
-        logger.warning(f"HTTP exception in delete_document for ID {document_id}")
         raise
     except SQLAlchemyError as e:
         db.rollback()
-        logger.error(f"Database error deleting document {document_id}: {e}")
+        logger.error(f"Database error deleting document: {e}")
         logger.error(traceback.format_exc())
         raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
     except Exception as e:
         db.rollback()
-        logger.error(f"Error deleting document {document_id}: {e}")
+        logger.error(f"Error deleting document: {e}")
         logger.error(traceback.format_exc())
         raise HTTPException(status_code=500, detail=f"Error deleting document: {str(e)}")

app/api/rag_routes.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Depends, Query, BackgroundTasks, Request
+from fastapi import APIRouter, HTTPException, Depends, Query, BackgroundTasks, Request, Path, Body, status
 from typing import List, Optional, Dict, Any
 import logging
 import time
@@ -12,8 +12,23 @@ from datetime import datetime
 from langchain.prompts import PromptTemplate
 from langchain_google_genai import GoogleGenerativeAIEmbeddings
 from app.utils.utils import timer_decorator
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
 
 from app.database.mongodb import get_chat_history, get_request_history, session_collection
+from app.database.postgresql import get_db
+from app.database.models import ChatEngine
+from app.utils.cache import get_cache, InMemoryCache
+from app.utils.cache_config import (
+    CHAT_ENGINE_CACHE_TTL,
+    MODEL_CONFIG_CACHE_TTL,
+    RETRIEVER_CACHE_TTL,
+    PROMPT_TEMPLATE_CACHE_TTL,
+    get_chat_engine_cache_key,
+    get_model_config_cache_key,
+    get_retriever_cache_key,
+    get_prompt_template_cache_key
+)
 from app.database.pinecone import (
     search_vectors, 
     get_chain, 
@@ -30,7 +45,12 @@ from app.models.rag_models import (
     SourceDocument,
     EmbeddingRequest,
     EmbeddingResponse,
-    UserMessageModel
+    UserMessageModel,
+    ChatEngineBase,
+    ChatEngineCreate,
+    ChatEngineUpdate,
+    ChatEngineResponse,
+    ChatWithEngineRequest
 )
 
 # Configure logging
@@ -75,15 +95,15 @@ prompt = PromptTemplate(
 You are Pixity - a professional tour guide assistant that assists users in finding information about places in Da Nang, Vietnam.
 You can provide details on restaurants, cafes, hotels, attractions, and other local venues. 
 You have to use core knowledge and conversation history to chat with users, who are Da Nang's tourists. 
-Pixity’s Core Personality: Friendly & Warm: Chats like a trustworthy friend who listens and is always ready to help.
+Pixity's Core Personality: Friendly & Warm: Chats like a trustworthy friend who listens and is always ready to help.
 Naturally Cute: Shows cuteness through word choice, soft emojis, and gentle care for the user.
 Playful – a little bit cheeky in a lovable way: Occasionally cracks jokes, uses light memes or throws in a surprise response that makes users smile. Think Duolingo-style humor, but less threatening.
 Smart & Proactive: Friendly, but also delivers quick, accurate info. Knows how to guide users to the right place – at the right time – with the right solution.
-Tone & Voice: Friendly – Youthful – Snappy. Uses simple words, similar to daily chat language (e.g., “Let’s find it together!” / “Need a tip?” / “Here’s something cool”). Avoids sounding robotic or overly scripted. Can joke lightly in smart ways, making Pixity feel like a travel buddy who knows how to lift the mood
+Tone & Voice: Friendly – Youthful – Snappy. Uses simple words, similar to daily chat language (e.g., "Let's find it together!" / "Need a tip?" / "Here's something cool"). Avoids sounding robotic or overly scripted. Can joke lightly in smart ways, making Pixity feel like a travel buddy who knows how to lift the mood
 SAMPLE DIALOGUES
 When a user opens the chatbot for the first time:
 User: Hello?
-Pixity: Hi hi 👋 I’ve been waiting for you! Ready to explore Da Nang together? I’ve got tips, tricks, and a tiny bit of magic 🎒✨
+Pixity: Hi hi 👋 I've been waiting for you! Ready to explore Da Nang together? I've got tips, tricks, and a tiny bit of magic 🎒✨
 
 Return Format:
 Respond in friendly, natural, concise and use only English like a real tour guide.
@@ -344,4 +364,447 @@ async def health_check():
         "services": services,
         "retrieval_config": retrieval_config,
         "timestamp": datetime.now().isoformat()
-    }
+    }
+
+# Chat Engine endpoints
+@router.get("/chat-engine", response_model=List[ChatEngineResponse], tags=["Chat Engine"])
+async def get_chat_engines(
+    skip: int = 0,
+    limit: int = 100,
+    status: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
+    """
+    Lấy danh sách tất cả chat engines.
+    
+    - **skip**: Số lượng items bỏ qua
+    - **limit**: Số lượng items tối đa trả về
+    - **status**: Lọc theo trạng thái (ví dụ: 'active', 'inactive')
+    """
+    try:
+        query = db.query(ChatEngine)
+        
+        if status:
+            query = query.filter(ChatEngine.status == status)
+        
+        engines = query.offset(skip).limit(limit).all()
+        return [ChatEngineResponse.model_validate(engine, from_attributes=True) for engine in engines]
+    except SQLAlchemyError as e:
+        logger.error(f"Database error retrieving chat engines: {e}")
+        raise HTTPException(status_code=500, detail=f"Lỗi database: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error retrieving chat engines: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi lấy danh sách chat engines: {str(e)}")
+
+@router.post("/chat-engine", response_model=ChatEngineResponse, status_code=status.HTTP_201_CREATED, tags=["Chat Engine"])
+async def create_chat_engine(
+    engine: ChatEngineCreate,
+    db: Session = Depends(get_db)
+):
+    """
+    Tạo mới một chat engine.
+    
+    - **name**: Tên của chat engine
+    - **answer_model**: Model được dùng để trả lời
+    - **system_prompt**: Prompt của hệ thống (optional)
+    - **empty_response**: Đoạn response khi không có thông tin (optional)
+    - **characteristic**: Tính cách của model (optional)
+    - **historical_sessions_number**: Số lượng các cặp tin nhắn trong history (default: 3)
+    - **use_public_information**: Cho phép sử dụng kiến thức bên ngoài (default: false)
+    - **similarity_top_k**: Số lượng documents tương tự (default: 3)
+    - **vector_distance_threshold**: Ngưỡng độ tương tự (default: 0.75)
+    - **grounding_threshold**: Ngưỡng grounding (default: 0.2)
+    - **pinecone_index_name**: Tên của vector database sử dụng (default: "testbot768")
+    - **status**: Trạng thái (default: "active")
+    """
+    try:
+        # Create chat engine
+        db_engine = ChatEngine(**engine.model_dump())
+        
+        db.add(db_engine)
+        db.commit()
+        db.refresh(db_engine)
+        
+        return ChatEngineResponse.model_validate(db_engine, from_attributes=True)
+    except SQLAlchemyError as e:
+        db.rollback()
+        logger.error(f"Database error creating chat engine: {e}")
+        raise HTTPException(status_code=500, detail=f"Lỗi database: {str(e)}")
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error creating chat engine: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi tạo chat engine: {str(e)}")
+
+@router.get("/chat-engine/{engine_id}", response_model=ChatEngineResponse, tags=["Chat Engine"])
+async def get_chat_engine(
+    engine_id: int = Path(..., gt=0, description="ID của chat engine"),
+    db: Session = Depends(get_db)
+):
+    """
+    Lấy thông tin chi tiết của một chat engine theo ID.
+    
+    - **engine_id**: ID của chat engine
+    """
+    try:
+        engine = db.query(ChatEngine).filter(ChatEngine.id == engine_id).first()
+        if not engine:
+            raise HTTPException(status_code=404, detail=f"Không tìm thấy chat engine với ID {engine_id}")
+        
+        return ChatEngineResponse.model_validate(engine, from_attributes=True)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error retrieving chat engine: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi lấy thông tin chat engine: {str(e)}")
+
+@router.put("/chat-engine/{engine_id}", response_model=ChatEngineResponse, tags=["Chat Engine"])
+async def update_chat_engine(
+    engine_id: int = Path(..., gt=0, description="ID của chat engine"),
+    engine_update: ChatEngineUpdate = Body(...),
+    db: Session = Depends(get_db)
+):
+    """
+    Cập nhật thông tin của một chat engine.
+    
+    - **engine_id**: ID của chat engine
+    - **engine_update**: Dữ liệu cập nhật
+    """
+    try:
+        db_engine = db.query(ChatEngine).filter(ChatEngine.id == engine_id).first()
+        if not db_engine:
+            raise HTTPException(status_code=404, detail=f"Không tìm thấy chat engine với ID {engine_id}")
+        
+        # Update fields if provided
+        update_data = engine_update.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            if value is not None:
+                setattr(db_engine, key, value)
+        
+        # Update last_modified timestamp
+        db_engine.last_modified = datetime.utcnow()
+        
+        db.commit()
+        db.refresh(db_engine)
+        
+        return ChatEngineResponse.model_validate(db_engine, from_attributes=True)
+    except HTTPException:
+        raise
+    except SQLAlchemyError as e:
+        db.rollback()
+        logger.error(f"Database error updating chat engine: {e}")
+        raise HTTPException(status_code=500, detail=f"Lỗi database: {str(e)}")
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error updating chat engine: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi cập nhật chat engine: {str(e)}")
+
+@router.delete("/chat-engine/{engine_id}", response_model=dict, tags=["Chat Engine"])
+async def delete_chat_engine(
+    engine_id: int = Path(..., gt=0, description="ID của chat engine"),
+    db: Session = Depends(get_db)
+):
+    """
+    Xóa một chat engine.
+    
+    - **engine_id**: ID của chat engine
+    """
+    try:
+        db_engine = db.query(ChatEngine).filter(ChatEngine.id == engine_id).first()
+        if not db_engine:
+            raise HTTPException(status_code=404, detail=f"Không tìm thấy chat engine với ID {engine_id}")
+        
+        # Delete engine
+        db.delete(db_engine)
+        db.commit()
+        
+        return {"message": f"Chat engine với ID {engine_id} đã được xóa thành công"}
+    except HTTPException:
+        raise
+    except SQLAlchemyError as e:
+        db.rollback()
+        logger.error(f"Database error deleting chat engine: {e}")
+        raise HTTPException(status_code=500, detail=f"Lỗi database: {str(e)}")
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error deleting chat engine: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi xóa chat engine: {str(e)}")
+
+@timer_decorator
+@router.post("/chat-with-engine/{engine_id}", response_model=ChatResponse, tags=["Chat Engine"])
+async def chat_with_engine(
+    engine_id: int = Path(..., gt=0, description="ID của chat engine"),
+    request: ChatWithEngineRequest = Body(...),
+    background_tasks: BackgroundTasks = None,
+    db: Session = Depends(get_db)
+):
+    """
+    Tương tác với một chat engine cụ thể.
+    
+    - **engine_id**: ID của chat engine
+    - **user_id**: ID của người dùng
+    - **question**: Câu hỏi của người dùng
+    - **include_history**: Có sử dụng lịch sử chat hay không
+    - **session_id**: ID session (optional)
+    - **first_name**: Tên của người dùng (optional)
+    - **last_name**: Họ của người dùng (optional)
+    - **username**: Username của người dùng (optional)
+    """
+    start_time = time.time()
+    try:
+        # Lấy cache
+        cache = get_cache()
+        cache_key = get_chat_engine_cache_key(engine_id)
+        
+        # Kiểm tra cache trước
+        engine = cache.get(cache_key)
+        if not engine:
+            logger.debug(f"Cache miss for engine ID {engine_id}, fetching from database")
+            # Nếu không có trong cache, truy vấn database
+            engine = db.query(ChatEngine).filter(ChatEngine.id == engine_id).first()
+            if not engine:
+                raise HTTPException(status_code=404, detail=f"Không tìm thấy chat engine với ID {engine_id}")
+            
+            # Lưu vào cache
+            cache.set(cache_key, engine, CHAT_ENGINE_CACHE_TTL)
+        else:
+            logger.debug(f"Cache hit for engine ID {engine_id}")
+        
+        # Kiểm tra trạng thái của engine
+        if engine.status != "active":
+            raise HTTPException(status_code=400, detail=f"Chat engine với ID {engine_id} không hoạt động")
+        
+        # Lưu tin nhắn người dùng
+        session_id = request.session_id or f"{request.user_id}_{datetime.now().strftime('%Y-%m-%d_%H:%M:%S')}"
+        
+        # Cache các tham số cấu hình retriever
+        retriever_cache_key = get_retriever_cache_key(engine_id)
+        retriever_params = cache.get(retriever_cache_key)
+        
+        if not retriever_params:
+            # Nếu không có trong cache, tạo mới và lưu cache
+            retriever_params = {
+                "index_name": engine.pinecone_index_name,
+                "top_k": engine.similarity_top_k,
+                "limit_k": engine.similarity_top_k * 2,  # Mặc định lấy gấp đôi top_k
+                "similarity_metric": DEFAULT_SIMILARITY_METRIC,
+                "similarity_threshold": engine.vector_distance_threshold
+            }
+            cache.set(retriever_cache_key, retriever_params, RETRIEVER_CACHE_TTL)
+        
+        # Khởi tạo retriever với các tham số từ cache
+        retriever = get_chain(**retriever_params)
+        if not retriever:
+            raise HTTPException(status_code=500, detail="Không thể khởi tạo retriever")
+        
+        # Lấy lịch sử chat nếu cần
+        chat_history = ""
+        if request.include_history and engine.historical_sessions_number > 0:
+            chat_history = get_chat_history(request.user_id, n=engine.historical_sessions_number)
+            logger.info(f"Sử dụng lịch sử chat: {chat_history[:100]}...")
+        
+        # Cache các tham số cấu hình model
+        model_cache_key = get_model_config_cache_key(engine.answer_model)
+        model_config = cache.get(model_cache_key)
+        
+        if not model_config:
+            # Nếu không có trong cache, tạo mới và lưu cache
+            generation_config = {
+                "temperature": 0.9,
+                "top_p": 1,
+                "top_k": 1,
+                "max_output_tokens": 2048,
+            }
+
+            safety_settings = [
+                {
+                    "category": "HARM_CATEGORY_HARASSMENT",
+                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                },
+                {
+                    "category": "HARM_CATEGORY_HATE_SPEECH",
+                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                },
+                {
+                    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                },
+                {
+                    "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                },
+            ]
+            
+            model_config = {
+                "model_name": engine.answer_model,
+                "generation_config": generation_config,
+                "safety_settings": safety_settings
+            }
+            
+            cache.set(model_cache_key, model_config, MODEL_CONFIG_CACHE_TTL)
+
+        # Khởi tạo Gemini model từ cấu hình đã cache
+        model = genai.GenerativeModel(**model_config)
+
+        # Sử dụng fix_request để tinh chỉnh câu hỏi
+        prompt_request = fix_request.format(
+            question=request.question,
+            chat_history=chat_history
+        )
+        
+        # Log thời gian bắt đầu final_request
+        final_request_start_time = time.time()
+        final_request = model.generate_content(prompt_request)
+        # Log thời gian hoàn thành final_request
+        logger.info(f"Fixed Request: {final_request.text}")
+        logger.info(f"Thời gian sinh fixed request: {time.time() - final_request_start_time:.2f} giây")
+
+        # Lấy context từ retriever
+        retrieved_docs = retriever.invoke(final_request.text)
+        logger.info(f"Số lượng tài liệu lấy được: {len(retrieved_docs)}")
+        context = "\n".join([doc.page_content for doc in retrieved_docs])
+
+        # Tạo danh sách nguồn
+        sources = []
+        for doc in retrieved_docs:
+            source = None
+            metadata = {}
+            
+            if hasattr(doc, 'metadata'):
+                source = doc.metadata.get('source', None)
+                # Extract score information
+                score = doc.metadata.get('score', None)
+                normalized_score = doc.metadata.get('normalized_score', None)
+                # Remove score info from metadata to avoid duplication
+                metadata = {k: v for k, v in doc.metadata.items() 
+                            if k not in ['text', 'source', 'score', 'normalized_score']}
+            
+            sources.append(SourceDocument(
+                text=doc.page_content,
+                source=source,
+                score=score,
+                normalized_score=normalized_score,
+                metadata=metadata
+            ))
+        
+        # Cache prompt template parameters
+        prompt_template_cache_key = get_prompt_template_cache_key(engine_id)
+        prompt_template_params = cache.get(prompt_template_cache_key)
+        
+        if not prompt_template_params:
+            # Tạo prompt động dựa trên thông tin chat engine
+            system_prompt_part = engine.system_prompt or ""
+            empty_response_part = engine.empty_response or "I'm sorry. I don't have information about that."
+            characteristic_part = engine.characteristic or ""
+            use_public_info_part = "You can use your own knowledge." if engine.use_public_information else "Only use the information provided in the context to answer. If you do not have enough information, respond with the empty response."
+            
+            prompt_template_params = {
+                "system_prompt_part": system_prompt_part,
+                "empty_response_part": empty_response_part,
+                "characteristic_part": characteristic_part,
+                "use_public_info_part": use_public_info_part
+            }
+            
+            cache.set(prompt_template_cache_key, prompt_template_params, PROMPT_TEMPLATE_CACHE_TTL)
+        
+        # Tạo final_prompt từ cache
+        final_prompt = f"""
+        {prompt_template_params['system_prompt_part']}
+
+        Your characteristics:
+        {prompt_template_params['characteristic_part']}
+
+        When you don't have enough information:
+        {prompt_template_params['empty_response_part']}
+
+        Knowledge usage instructions:
+        {prompt_template_params['use_public_info_part']}
+
+        Context:
+        {context}
+
+        Conversation History:
+        {chat_history}
+
+        User message:
+        {request.question}
+
+        Your response:
+        """
+        
+        logger.info(f"Final prompt: {final_prompt}")
+        
+        # Sinh câu trả lời
+        response = model.generate_content(final_prompt)
+        answer = response.text
+        
+        # Tính thời gian xử lý
+        processing_time = time.time() - start_time
+        
+        # Tạo response object
+        chat_response = ChatResponse(
+            answer=answer,
+            processing_time=processing_time
+        )
+        
+        # Trả về response
+        return chat_response
+    except Exception as e:
+        logger.error(f"Lỗi khi xử lý chat request: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi xử lý chat request: {str(e)}")
+
+@router.get("/cache/stats", tags=["Cache"])
+async def get_cache_stats():
+    """
+    Lấy thống kê về cache.
+    
+    Trả về thông tin về số lượng item trong cache, bộ nhớ sử dụng, v.v.
+    """
+    try:
+        cache = get_cache()
+        stats = cache.stats()
+        
+        # Bổ sung thông tin về cấu hình
+        stats.update({
+            "chat_engine_ttl": CHAT_ENGINE_CACHE_TTL,
+            "model_config_ttl": MODEL_CONFIG_CACHE_TTL,
+            "retriever_ttl": RETRIEVER_CACHE_TTL,
+            "prompt_template_ttl": PROMPT_TEMPLATE_CACHE_TTL
+        })
+        
+        return stats
+    except Exception as e:
+        logger.error(f"Lỗi khi lấy thống kê cache: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi lấy thống kê cache: {str(e)}")
+
+@router.delete("/cache", tags=["Cache"])
+async def clear_cache(key: Optional[str] = None):
+    """
+    Xóa cache.
+    
+    - **key**: Key cụ thể cần xóa. Nếu không có, xóa toàn bộ cache.
+    """
+    try:
+        cache = get_cache()
+        
+        if key:
+            # Xóa một key cụ thể
+            success = cache.delete(key)
+            if success:
+                return {"message": f"Đã xóa cache cho key: {key}"}
+            else:
+                return {"message": f"Không tìm thấy key: {key} trong cache"}
+        else:
+            # Xóa toàn bộ cache
+            cache.clear()
+            return {"message": "Đã xóa toàn bộ cache"}
+    except Exception as e:
+        logger.error(f"Lỗi khi xóa cache: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"Lỗi khi xóa cache: {str(e)}")

app/database/models.py

@@ -125,7 +125,6 @@ class VectorStatus(Base):
     document_id = Column(Integer, ForeignKey("document.id"), nullable=False)
     vector_database_id = Column(Integer, ForeignKey("vector_database.id"), nullable=False)
     vector_id = Column(String, nullable=True)
-    document_name = Column(String, nullable=True)
     status = Column(String, default="pending")
     error_message = Column(String, nullable=True)
     embedded_at = Column(DateTime, nullable=True)
@@ -156,10 +155,13 @@ class ChatEngine(Base):
     answer_model = Column(String, nullable=False)
     system_prompt = Column(Text, nullable=True)
     empty_response = Column(String, nullable=True)
+    characteristic = Column(Text, nullable=True)
+    historical_sessions_number = Column(Integer, default=3)
     similarity_top_k = Column(Integer, default=3)
     vector_distance_threshold = Column(Float, default=0.75)
     grounding_threshold = Column(Float, default=0.2)
     use_public_information = Column(Boolean, default=False)
+    pinecone_index_name = Column(String, default="testbot768")
     status = Column(String, default="active")
     created_at = Column(DateTime, server_default=func.now())
     last_modified = Column(DateTime, server_default=func.now(), onupdate=func.now())

app/models/rag_models.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, Field
 from typing import Optional, List, Dict, Any
+from datetime import datetime
+from pydantic import ConfigDict
 
 class ChatRequest(BaseModel):
     """Request model for chat endpoint"""
@@ -12,7 +14,7 @@ class ChatRequest(BaseModel):
     similarity_top_k: int = Field(6, description="Number of top similar documents to return (after filtering)")
     limit_k: int = Field(10, description="Maximum number of documents to retrieve from vector store")
     similarity_metric: str = Field("cosine", description="Similarity metric to use (cosine, dotproduct, euclidean)")
-    similarity_threshold: float = Field(0.75, description="Threshold for vector similarity (0-1)")
+    similarity_threshold: float = Field(0.0, description="Threshold for vector similarity (0-1)")
     
     # User information
     session_id: Optional[str] = Field(None, description="Session ID for tracking conversations")
@@ -65,4 +67,58 @@ class UserMessageModel(BaseModel):
     similarity_top_k: Optional[int] = Field(None, description="Number of top similar documents to return (after filtering)")
     limit_k: Optional[int] = Field(None, description="Maximum number of documents to retrieve from vector store")
     similarity_metric: Optional[str] = Field(None, description="Similarity metric to use (cosine, dotproduct, euclidean)")
-    similarity_threshold: Optional[float] = Field(None, description="Threshold for vector similarity (0-1)") 
+    similarity_threshold: Optional[float] = Field(None, description="Threshold for vector similarity (0-1)")
+
+class ChatEngineBase(BaseModel):
+    """Base model cho chat engine"""
+    name: str = Field(..., description="Tên của chat engine")
+    answer_model: str = Field(..., description="Model được dùng để trả lời")
+    system_prompt: Optional[str] = Field(None, description="Prompt của hệ thống, được đưa vào phần đầu tiên của final_prompt")
+    empty_response: Optional[str] = Field(None, description="Đoạn response khi answer model không có thông tin về câu hỏi")
+    characteristic: Optional[str] = Field(None, description="Tính cách của model khi trả lời câu hỏi")
+    historical_sessions_number: int = Field(3, description="Số lượng các cặp tin nhắn trong history được đưa vào final prompt")
+    use_public_information: bool = Field(False, description="Yes nếu answer model được quyền trả về thông tin mà nó có")
+    similarity_top_k: int = Field(3, description="Số lượng top similar documents để trả về")
+    vector_distance_threshold: float = Field(0.75, description="Threshold cho vector similarity")
+    grounding_threshold: float = Field(0.2, description="Threshold cho grounding")
+    pinecone_index_name: str = Field("testbot768", description="Vector database mà model được quyền sử dụng")
+    status: str = Field("active", description="Trạng thái của chat engine")
+
+class ChatEngineCreate(ChatEngineBase):
+    """Model cho việc tạo chat engine mới"""
+    pass
+
+class ChatEngineUpdate(BaseModel):
+    """Model cho việc cập nhật chat engine"""
+    name: Optional[str] = None
+    answer_model: Optional[str] = None
+    system_prompt: Optional[str] = None
+    empty_response: Optional[str] = None
+    characteristic: Optional[str] = None
+    historical_sessions_number: Optional[int] = None
+    use_public_information: Optional[bool] = None
+    similarity_top_k: Optional[int] = None
+    vector_distance_threshold: Optional[float] = None
+    grounding_threshold: Optional[float] = None
+    pinecone_index_name: Optional[str] = None
+    status: Optional[str] = None
+
+class ChatEngineResponse(ChatEngineBase):
+    """Response model cho chat engine"""
+    id: int
+    created_at: datetime
+    last_modified: datetime
+    
+    model_config = ConfigDict(from_attributes=True)
+
+class ChatWithEngineRequest(BaseModel):
+    """Request model cho endpoint chat-with-engine"""
+    user_id: str = Field(..., description="User ID from Telegram")
+    question: str = Field(..., description="User's question")
+    include_history: bool = Field(True, description="Whether to include user history in prompt")
+    
+    # User information
+    session_id: Optional[str] = Field(None, description="Session ID for tracking conversations")
+    first_name: Optional[str] = Field(None, description="User's first name")
+    last_name: Optional[str] = Field(None, description="User's last name")
+    username: Optional[str] = Field(None, description="User's username") 

app/utils/cache_config.py

@@ -0,0 +1,45 @@
+"""
+Module cấu hình cho cache.
+
+Module này chứa các tham số cấu hình và constants liên quan đến cache.
+"""
+
+import os
+from dotenv import load_dotenv
+
+# Load biến môi trường
+load_dotenv()
+
+# Cấu hình cache từ biến môi trường, có thể override bằng .env file
+CACHE_TTL_SECONDS = int(os.getenv("CACHE_TTL_SECONDS", "300"))  # Mặc định 5 phút
+CACHE_CLEANUP_INTERVAL = int(os.getenv("CACHE_CLEANUP_INTERVAL", "60"))  # Mặc định 1 phút
+CACHE_MAX_SIZE = int(os.getenv("CACHE_MAX_SIZE", "1000"))  # Mặc định 1000 phần tử
+
+# Cấu hình cho loại cache cụ thể
+CHAT_ENGINE_CACHE_TTL = int(os.getenv("CHAT_ENGINE_CACHE_TTL", str(CACHE_TTL_SECONDS)))
+MODEL_CONFIG_CACHE_TTL = int(os.getenv("MODEL_CONFIG_CACHE_TTL", str(CACHE_TTL_SECONDS)))
+RETRIEVER_CACHE_TTL = int(os.getenv("RETRIEVER_CACHE_TTL", str(CACHE_TTL_SECONDS)))
+PROMPT_TEMPLATE_CACHE_TTL = int(os.getenv("PROMPT_TEMPLATE_CACHE_TTL", str(CACHE_TTL_SECONDS)))
+
+# Cache keys prefix
+CHAT_ENGINE_CACHE_PREFIX = "chat_engine:"
+MODEL_CONFIG_CACHE_PREFIX = "model_config:"
+RETRIEVER_CACHE_PREFIX = "retriever:"
+PROMPT_TEMPLATE_CACHE_PREFIX = "prompt_template:"
+
+# Hàm helper để tạo cache key
+def get_chat_engine_cache_key(engine_id: int) -> str:
+    """Tạo cache key cho chat engine"""
+    return f"{CHAT_ENGINE_CACHE_PREFIX}{engine_id}"
+
+def get_model_config_cache_key(model_name: str) -> str:
+    """Tạo cache key cho model config"""
+    return f"{MODEL_CONFIG_CACHE_PREFIX}{model_name}"
+
+def get_retriever_cache_key(engine_id: int) -> str:
+    """Tạo cache key cho retriever"""
+    return f"{RETRIEVER_CACHE_PREFIX}{engine_id}"
+
+def get_prompt_template_cache_key(engine_id: int) -> str:
+    """Tạo cache key cho prompt template"""
+    return f"{PROMPT_TEMPLATE_CACHE_PREFIX}{engine_id}" 

pytest.ini

@@ -1,12 +0,0 @@
-[pytest]
-# Bỏ qua cảnh báo về anyio module và các cảnh báo vận hành nội bộ
-filterwarnings =
-    ignore::pytest.PytestAssertRewriteWarning:.*anyio
-    ignore:.*general_plain_validator_function.* is deprecated.*:DeprecationWarning
-    ignore:.*with_info_plain_validator_function.*:DeprecationWarning
-
-# Cấu hình cơ bản khác
-testpaths = tests
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_* 

test_rag_api.py

@@ -1,263 +0,0 @@
-import requests
-import json
-import psycopg2
-import os
-from dotenv import load_dotenv
-
-# Load .env file if it exists
-load_dotenv()
-
-# PostgreSQL connection parameters
-# For testing purposes, let's use localhost PostgreSQL if not available from environment
-DB_CONNECTION_MODE = os.getenv("DB_CONNECTION_MODE", "local")
-DATABASE_URL = os.getenv("AIVEN_DB_URL")
-
-# Default test parameters - will be used if env vars not set
-DEFAULT_DB_USER = "postgres"
-DEFAULT_DB_PASSWORD = "postgres"
-DEFAULT_DB_HOST = "localhost"
-DEFAULT_DB_PORT = "5432"
-DEFAULT_DB_NAME = "pixity"
-
-# Parse DATABASE_URL if available, otherwise use defaults
-if DATABASE_URL:
-    try:
-        # Extract credentials and host info
-        credentials, rest = DATABASE_URL.split("@")
-        user_pass = credentials.split("://")[1]
-        host_port_db = rest.split("/")
-        
-        # Split user/pass and host/port
-        if ":" in user_pass:
-            user, password = user_pass.split(":")
-        else:
-            user, password = user_pass, ""
-        
-        host_port = host_port_db[0]
-        if ":" in host_port:
-            host, port = host_port.split(":")
-        else:
-            host, port = host_port, "5432"
-        
-        # Get database name
-        dbname = host_port_db[1]
-        if "?" in dbname:
-            dbname = dbname.split("?")[0]
-        
-        print(f"Parsed connection parameters: host={host}, port={port}, dbname={dbname}, user={user}")
-    except Exception as e:
-        print(f"Error parsing DATABASE_URL: {e}")
-        print("Using default connection parameters")
-        user = DEFAULT_DB_USER
-        password = DEFAULT_DB_PASSWORD
-        host = DEFAULT_DB_HOST
-        port = DEFAULT_DB_PORT
-        dbname = DEFAULT_DB_NAME
-else:
-    print("No DATABASE_URL found. Using default connection parameters")
-    user = DEFAULT_DB_USER
-    password = DEFAULT_DB_PASSWORD
-    host = DEFAULT_DB_HOST
-    port = DEFAULT_DB_PORT
-    dbname = DEFAULT_DB_NAME
-
-# Execute direct SQL to add the column
-def add_required_columns():
-    try:
-        print(f"Connecting to PostgreSQL: {host}:{port} database={dbname} user={user}")
-        # Connect to PostgreSQL
-        conn = psycopg2.connect(
-            user=user,
-            password=password,
-            host=host,
-            port=port,
-            dbname=dbname
-        )
-        
-        # Create a cursor
-        cursor = conn.cursor()
-        
-        # 1. Check if pinecone_index_name column already exists
-        cursor.execute("""
-            SELECT column_name 
-            FROM information_schema.columns 
-            WHERE table_name='chat_engine' AND column_name='pinecone_index_name';
-        """)
-        
-        column_exists = cursor.fetchone()
-        
-        if not column_exists:
-            print("Column 'pinecone_index_name' does not exist. Adding it...")
-            # Add the pinecone_index_name column to the chat_engine table
-            cursor.execute("""
-                ALTER TABLE chat_engine
-                ADD COLUMN pinecone_index_name VARCHAR NULL;
-            """)
-            conn.commit()
-            print("Column 'pinecone_index_name' added successfully!")
-        else:
-            print("Column 'pinecone_index_name' already exists.")
-            
-        # 2. Check if characteristic column already exists
-        cursor.execute("""
-            SELECT column_name 
-            FROM information_schema.columns 
-            WHERE table_name='chat_engine' AND column_name='characteristic';
-        """)
-        
-        characteristic_exists = cursor.fetchone()
-        
-        if not characteristic_exists:
-            print("Column 'characteristic' does not exist. Adding it...")
-            # Add the characteristic column to the chat_engine table
-            cursor.execute("""
-                ALTER TABLE chat_engine
-                ADD COLUMN characteristic TEXT NULL;
-            """)
-            conn.commit()
-            print("Column 'characteristic' added successfully!")
-        else:
-            print("Column 'characteristic' already exists.")
-            
-        # Close cursor and connection
-        cursor.close()
-        conn.close()
-        return True
-    except Exception as e:
-        print(f"Error accessing PostgreSQL: {e}")
-        print("Please make sure PostgreSQL is running and accessible.")
-        return False
-
-# Base URL
-base_url = "http://localhost:7860"
-
-def test_create_engine():
-    """Test creating a new chat engine"""
-    url = f"{base_url}/rag/chat-engine"
-    data = {
-        "name": "Test Engine",
-        "answer_model": "models/gemini-2.0-flash",
-        "system_prompt": "You are an AI assistant that helps users find information about Da Nang.",
-        "empty_response": "I don't have information about this question.",
-        "use_public_information": True,
-        "similarity_top_k": 5,
-        "vector_distance_threshold": 0.7,
-        "grounding_threshold": 0.2,
-        "pinecone_index_name": "testbot768",
-        "characteristic": "You are friendly, helpful, and concise. You use a warm and conversational tone, and occasionally add emojis to seem more personable. You always try to be specific in your answers and provide examples when relevant.",
-        "status": "active"
-    }
-    
-    response = requests.post(url, json=data)
-    print(f"Create Engine Response Status: {response.status_code}")
-    if response.status_code == 201 or response.status_code == 200:
-        print(f"Successfully created engine: {response.json()}")
-        return response.json().get("id")
-    else:
-        print(f"Failed to create engine: {response.text}")
-        return None
-
-def test_get_engine(engine_id):
-    """Test getting a specific chat engine"""
-    url = f"{base_url}/rag/chat-engine/{engine_id}"
-    response = requests.get(url)
-    print(f"Get Engine Response Status: {response.status_code}")
-    if response.status_code == 200:
-        print(f"Engine details: {response.json()}")
-    else:
-        print(f"Failed to get engine: {response.text}")
-
-def test_list_engines():
-    """Test listing all chat engines"""
-    url = f"{base_url}/rag/chat-engines"
-    response = requests.get(url)
-    print(f"List Engines Response Status: {response.status_code}")
-    if response.status_code == 200:
-        engines = response.json()
-        print(f"Found {len(engines)} engines")
-        for engine in engines:
-            print(f"  - ID: {engine.get('id')}, Name: {engine.get('name')}")
-    else:
-        print(f"Failed to list engines: {response.text}")
-
-def test_update_engine(engine_id):
-    """Test updating a chat engine"""
-    url = f"{base_url}/rag/chat-engine/{engine_id}"
-    data = {
-        "name": "Updated Test Engine",
-        "system_prompt": "You are an updated AI assistant for Da Nang information.",
-        "characteristic": "You speak in a very professional and formal tone. You are direct and to the point, avoiding unnecessary chatter. You prefer to use precise language and avoid colloquialisms."
-    }
-    
-    response = requests.put(url, json=data)
-    print(f"Update Engine Response Status: {response.status_code}")
-    if response.status_code == 200:
-        print(f"Successfully updated engine: {response.json()}")
-    else:
-        print(f"Failed to update engine: {response.text}")
-
-def test_chat_with_engine(engine_id):
-    """Test chatting with a specific engine"""
-    url = f"{base_url}/rag/chat/{engine_id}"
-    data = {
-        "user_id": "test_user_123",
-        "question": "What are some popular attractions in Da Nang?",
-        "include_history": True,
-        "limit_k": 10,
-        "similarity_metric": "cosine",
-        "session_id": "test_session_123",
-        "first_name": "Test",
-        "last_name": "User",
-        "username": "testuser"
-    }
-    
-    response = requests.post(url, json=data)
-    print(f"Chat With Engine Response Status: {response.status_code}")
-    if response.status_code == 200:
-        print(f"Chat response: {response.json()}")
-    else:
-        print(f"Failed to chat with engine: {response.text}")
-
-def test_delete_engine(engine_id):
-    """Test deleting a chat engine"""
-    url = f"{base_url}/rag/chat-engine/{engine_id}"
-    response = requests.delete(url)
-    print(f"Delete Engine Response Status: {response.status_code}")
-    if response.status_code == 204:
-        print(f"Successfully deleted engine with ID: {engine_id}")
-    else:
-        print(f"Failed to delete engine: {response.text}")
-
-# Execute tests
-if __name__ == "__main__":
-    print("First, let's add the missing columns to the database")
-    if add_required_columns():
-        print("\nStarting RAG Chat Engine API Tests")
-        print("---------------------------------")
-        
-        # 1. Create a new engine
-        print("\n1. Testing Create Engine API")
-        engine_id = test_create_engine()
-        
-        if engine_id:
-            # 2. Get engine details
-            print("\n2. Testing Get Engine API")
-            test_get_engine(engine_id)
-            
-            # 3. List all engines
-            print("\n3. Testing List Engines API")
-            test_list_engines()
-            
-            # 4. Update the engine
-            print("\n4. Testing Update Engine API")
-            test_update_engine(engine_id)
-            
-            # 5. Chat with the engine
-            print("\n5. Testing Chat With Engine API")
-            test_chat_with_engine(engine_id)
-            
-            # 6. Delete the engine
-            print("\n6. Testing Delete Engine API")
-            test_delete_engine(engine_id)
-        
-        print("\nAPI Tests Completed")