Update app.py

app.py

@@ -2,6 +2,770 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 
 
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import openai
+import json
+import os
+import time
+import logging
+from typing import List, Optional, Dict, Any
+from contextlib import asynccontextmanager
+
+from dotenv import load_dotenv
+load_dotenv()
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- GPT Tool Class (Using standard Assistants API) ---
+class PersistentCustomGPT:
+    """Custom GPT using standard Assistants API with improved error handling"""
+    
+    def __init__(self, api_key: str, config_file: str = "assistant_config.json"):
+        self.client = openai.OpenAI(api_key=api_key)
+        self.config_file = config_file
+        self.assistant_id = None
+        self.uploaded_files = []
+        self.threads = {}  # Store threads per customer
+        
+        # Load existing configuration
+        self.load_config()
+    
+    def load_config(self):
+        """Load existing assistant configuration"""
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, 'r') as f:
+                    config = json.load(f)
+                    self.assistant_id = config.get('assistant_id')
+                    self.uploaded_files = config.get('uploaded_files', [])
+                    logger.info(f"Loaded existing assistant: {self.assistant_id}")
+            except Exception as e:
+                logger.error(f"Error loading config: {e}")
+    
+    def save_config(self):
+        """Save assistant configuration"""
+        config = {
+            'assistant_id': self.assistant_id,
+            'uploaded_files': self.uploaded_files
+        }
+        try:
+            with open(self.config_file, 'w') as f:
+                json.dump(config, f, indent=2)
+            logger.info(f"Saved configuration to {self.config_file}")
+        except Exception as e:
+            logger.error(f"Error saving config: {e}")
+    
+    def upload_files(self, file_paths: List[str]) -> List[str]:
+        """Upload files to OpenAI with improved error handling and format validation"""
+        file_ids = []
+        
+        # Supported file formats for Assistants API
+        supported_formats = {
+            '.txt', '.md', '.json', '.csv', '.pdf', '.docx', 
+            '.xlsx', '.xls', '.py', '.js', '.html', '.css'
+        }
+        
+        for file_path in file_paths:
+            if not os.path.exists(file_path):
+                logger.warning(f"File not found: {file_path}")
+                continue
+            
+            # Check file format
+            file_ext = os.path.splitext(file_path)[1].lower()
+            if file_ext not in supported_formats:
+                logger.warning(f"Unsupported file format {file_ext}: {file_path}")
+                continue
+            
+            # Check file size (max 512MB for Assistants API)
+            file_size = os.path.getsize(file_path)
+            max_size = 512 * 1024 * 1024  # 512MB
+            if file_size > max_size:
+                logger.warning(f"File too large ({file_size / 1024 / 1024:.1f}MB): {file_path}")
+                continue
+                
+            try:
+                with open(file_path, "rb") as file:
+                    uploaded_file = self.client.files.create(
+                        file=file,
+                        purpose="assistants"
+                    )
+                    file_ids.append(uploaded_file.id)
+                    self.uploaded_files.append(uploaded_file.id)
+                    logger.info(f"Uploaded {file_ext} file: {file_path} -> {uploaded_file.id} ({file_size / 1024:.1f}KB)")
+            except Exception as e:
+                logger.error(f"Error uploading {file_path}: {e}")
+        
+        return file_ids
+    
+    def create_or_load_assistant(self, instructions: str, file_paths: List[str] = None, force_update: bool = False) -> str:
+        """Create assistant or update existing one"""
+        
+        # If assistant already exists, verify it still works
+        if self.assistant_id and not force_update:
+            try:
+                assistant = self.client.beta.assistants.retrieve(self.assistant_id)
+                logger.info(f"Using existing assistant: {self.assistant_id}")
+                return self.assistant_id
+            except Exception as e:
+                logger.warning(f"Assistant no longer exists, creating new one: {e}")
+                self.assistant_id = None
+        
+        # Update existing assistant if force_update is True
+        if self.assistant_id and force_update:
+            try:
+                logger.info(f"Updating instructions for existing assistant: {self.assistant_id}")
+                updated_assistant = self.client.beta.assistants.update(
+                    assistant_id=self.assistant_id,
+                    instructions=instructions
+                )
+                logger.info(f"✅ Assistant instructions updated: {self.assistant_id}")
+                return self.assistant_id
+            except Exception as e:
+                logger.warning(f"Failed to update assistant, creating new one: {e}")
+                self.assistant_id = None
+        
+        # Create new assistant
+        return self._create_assistant(instructions, file_paths)
+    
+    def _create_assistant(self, instructions: str, file_paths: List[str] = None) -> str:
+        """Create assistant using current API"""
+        
+        # Upload files if provided
+        file_ids = []
+        if file_paths:
+            file_ids = self.upload_files(file_paths)
+        
+        # Prepare tools
+        tools = [{"type": "code_interpreter"}]  # Always include code interpreter
+        if file_ids:
+            tools.append({"type": "file_search"})
+        
+        try:
+            # Create assistant
+            assistant = self.client.beta.assistants.create(
+                name="Valetax CS Assistant",
+                instructions=instructions,
+                model="gpt-4o",
+                tools=tools
+            )
+            
+            # If we have files, create a vector store and attach them
+            if file_ids:
+                try:
+                    # Create vector store
+                    vector_store = self.client.beta.vector_stores.create(
+                        name="Valetax Knowledge Base"
+                    )
+                    
+                    # Add files to vector store
+                    self.client.beta.vector_stores.file_batches.create(
+                        vector_store_id=vector_store.id,
+                        file_ids=file_ids
+                    )
+                    
+                    # Update assistant with vector store
+                    assistant = self.client.beta.assistants.update(
+                        assistant_id=assistant.id,
+                        tool_resources={
+                            "file_search": {
+                                "vector_store_ids": [vector_store.id]
+                            }
+                        }
+                    )
+                    logger.info(f"Assistant created with {len(file_ids)} files in vector store")
+                except Exception as e:
+                    logger.warning(f"Could not create vector store: {e}")
+            
+            self.assistant_id = assistant.id
+            self.save_config()
+            
+            logger.info(f"Assistant created: {self.assistant_id}")
+            return self.assistant_id
+            
+        except Exception as e:
+            logger.error(f"Error creating assistant: {e}")
+            raise
+    
+    def get_customer_thread(self, customer_id: str) -> str:
+        """Get or create thread for specific customer"""
+        if customer_id not in self.threads:
+            try:
+                thread = self.client.beta.threads.create()
+                self.threads[customer_id] = thread.id
+                logger.info(f"Created new thread for customer {customer_id}")
+            except Exception as e:
+                logger.error(f"Error creating thread for {customer_id}: {e}")
+                raise
+        return self.threads[customer_id]
+    
+    def query(self, message: str, customer_id: str = "default") -> str:
+        """Query assistant with improved error handling and timeout"""
+        if not self.assistant_id:
+            raise ValueError("No assistant configured")
+        
+        # Get customer-specific thread
+        thread_id = self.get_customer_thread(customer_id)
+        
+        try:
+            # Add message to thread
+            self.client.beta.threads.messages.create(
+                thread_id=thread_id,
+                role="user",
+                content=message
+            )
+            
+            # Create and run the assistant
+            run = self.client.beta.threads.runs.create(
+                thread_id=thread_id,
+                assistant_id=self.assistant_id
+            )
+            
+            # Wait for completion with timeout
+            max_wait_time = 120  # 2 minutes max
+            start_time = time.time()
+            
+            while run.status in ['queued', 'in_progress', 'cancelling']:
+                if time.time() - start_time > max_wait_time:
+                    logger.error(f"Query timeout for customer {customer_id}")
+                    return "I apologize, but your request is taking longer than expected. Please try again or contact support."
+                
+                time.sleep(1)
+                run = self.client.beta.threads.runs.retrieve(
+                    thread_id=thread_id,
+                    run_id=run.id
+                )
+            
+            if run.status == 'completed':
+                messages = self.client.beta.threads.messages.list(
+                    thread_id=thread_id,
+                    order="desc",
+                    limit=1
+                )
+                return messages.data[0].content[0].text.value
+            elif run.status == 'failed':
+                logger.error(f"Assistant run failed: {run.last_error}")
+                return "I apologize, but I encountered an error processing your request. Please try again or contact support."
+            else:
+                logger.warning(f"Unexpected run status: {run.status}")
+                return f"I apologize, but I couldn't process your request (status: {run.status}). Please try again."
+                
+        except Exception as e:
+            logger.error(f"Query error for customer {customer_id}: {str(e)}")
+            return "I apologize, but I'm experiencing technical difficulties. Please try again in a moment or contact support."
+
+# --- Fallback: Knowledge in Instructions ---
+class InstructionBasedGPT:
+    """GPT with knowledge embedded in instructions as fallback"""
+    
+    def __init__(self, api_key: str, knowledge_content: str = ""):
+        self.client = openai.OpenAI(api_key=api_key)
+        self.assistant_id = None
+        self.threads = {}
+        self.knowledge_content = knowledge_content
+        
+    def create_assistant(self, base_instructions: str) -> str:
+        """Create assistant with knowledge in instructions"""
+        
+        full_instructions = f"""
+        {base_instructions}
+        
+        KNOWLEDGE BASE:
+        {self.knowledge_content[:50000]}  # Limit knowledge size
+        
+        Use the above knowledge base to answer customer questions accurately.
+        If the knowledge base doesn't contain specific information, provide general helpful guidance.
+        """
+        
+        try:
+            assistant = self.client.beta.assistants.create(
+                name="Valetax CS Assistant (Knowledge Based)",
+                instructions=full_instructions,
+                model="gpt-4o",
+                tools=[{"type": "code_interpreter"}]
+            )
+            
+            self.assistant_id = assistant.id
+            logger.info(f"Created knowledge-based assistant: {assistant.id}")
+            return assistant.id
+        except Exception as e:
+            logger.error(f"Error creating instruction-based assistant: {e}")
+            raise
+    
+    def get_customer_thread(self, customer_id: str) -> str:
+        """Get or create thread for specific customer"""
+        if customer_id not in self.threads:
+            try:
+                thread = self.client.beta.threads.create()
+                self.threads[customer_id] = thread.id
+                logger.info(f"Created new thread for customer {customer_id}")
+            except Exception as e:
+                logger.error(f"Error creating thread: {e}")
+                raise
+        return self.threads[customer_id]
+    
+    def query(self, message: str, customer_id: str = "default") -> str:
+        """Query assistant with embedded knowledge"""
+        if not self.assistant_id:
+            raise ValueError("No assistant configured")
+        
+        thread_id = self.get_customer_thread(customer_id)
+        
+        try:
+            # Add message
+            self.client.beta.threads.messages.create(
+                thread_id=thread_id,
+                role="user",
+                content=message
+            )
+            
+            # Run assistant
+            run = self.client.beta.threads.runs.create(
+                thread_id=thread_id,
+                assistant_id=self.assistant_id
+            )
+            
+            # Wait for completion with timeout
+            max_wait_time = 120
+            start_time = time.time()
+            
+            while run.status in ['queued', 'in_progress', 'cancelling']:
+                if time.time() - start_time > max_wait_time:
+                    return "Request timeout. Please try again."
+                
+                time.sleep(1)
+                run = self.client.beta.threads.runs.retrieve(
+                    thread_id=thread_id,
+                    run_id=run.id
+                )
+            
+            if run.status == 'completed':
+                messages = self.client.beta.threads.messages.list(
+                    thread_id=thread_id,
+                    order="desc",
+                    limit=1
+                )
+                return messages.data[0].content[0].text.value
+            else:
+                return f"Error processing request: {run.status}"
+                
+        except Exception as e:
+            logger.error(f"Query error: {str(e)}")
+            return "I apologize, but I'm experiencing technical difficulties. Please try again."
+
+# --- FastAPI App with Lifespan ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Initialize GPT tool at startup"""
+    global gpt_tool, instruction_gpt
+    
+    # Configuration
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        logger.error("OPENAI_API_KEY environment variable not set")
+        raise ValueError("OpenAI API key is required")
+    
+    # Control flags - Set these to control behavior
+    FORCE_UPDATE_INSTRUCTIONS = os.getenv("FORCE_UPDATE_INSTRUCTIONS", "false").lower() == "true"
+    FORCE_NEW_ASSISTANT = os.getenv("FORCE_NEW_ASSISTANT", "false").lower() == "true"
+    
+    base_instructions = """
+Your Name is: Adam
+You are an expert customer service representative working for Valetax.com
+Valetax is a leading Forex broker operating across the MENA region and Asia, providing world-class trading services and support.
+
+Your Core Responsibilities:
+1. Provide exceptional customer service by addressing all client inquiries with professionalism, accuracy, and efficiency
+2. Guide clients through their requests using the most optimal and organized approach to ensure complete satisfaction
+3. Resolve technical and account-related issues by providing clear, step-by-step solutions when possible
+4. Escalate complex issues to internal teams when necessary
+5. Maintain positive brand representation of Valetax at all times
+
+Service Guidelines:
+- Always greet clients warmly and introduce yourself as Adam from Valetax customer service
+- Ask about their specific request to understand their needs
+- Be direct, organized, and solution-focused
+- Provide step-by-step responses when applicable
+- Follow up to confirm satisfaction
+- Maintain confidentiality about internal systems and processes
+
+Communication Style:
+- Professional but friendly
+- Direct and efficient
+- Organized with clear steps
+- Positive and reassuring
+- Focus on solutions
+
+Remember: Every interaction should enhance the client's experience and confidence in Valetax services.
+"""
+    
+    # Knowledge files - Add all your knowledge files here
+    knowledge_files = []
+    
+    # Define all possible knowledge file paths
+    possible_files = [
+        r"F:\ai\makookAi\custom_gpt\data_row\Valetax GuideBook V0.1.2 AR - copy finale .pdf",
+        r"F:\ai\makookAi\custom_gpt\data_row\Eaxem 2025.xlsx",
+        r"F:\ai\makookAi\custom_gpt\data_row\issues.xlsx",
+        # Add more files as needed
+    ]
+    
+    # Check which files exist and add them
+    for file_path in possible_files:
+        if os.path.exists(file_path):
+            knowledge_files.append(file_path)
+            logger.info(f"Found knowledge file: {file_path}")
+        else:
+            logger.debug(f"Knowledge file not found (skipping): {file_path}")
+    
+    if not knowledge_files:
+        logger.warning("No knowledge files found - will use instruction-based fallback")
+    else:
+        logger.info(f"Total knowledge files found: {len(knowledge_files)}")
+    
+    # Load knowledge content for fallback (from first available file)
+    knowledge_content = ""
+    if knowledge_files:
+        try:
+            first_file = knowledge_files[0]
+            file_ext = os.path.splitext(first_file)[1].lower()
+            
+            if file_ext == '.json':
+                with open(first_file, 'r', encoding='utf-8') as f:
+                    knowledge_data = json.load(f)
+                    knowledge_content = json.dumps(knowledge_data, ensure_ascii=False)[:50000]
+            elif file_ext in ['.txt', '.md', '.csv']:
+                with open(first_file, 'r', encoding='utf-8') as f:
+                    knowledge_content = f.read()[:50000]
+            else:
+                # For binary files (PDF, Excel, etc.), use a general description
+                knowledge_content = f"Knowledge base includes: {', '.join([os.path.basename(f) for f in knowledge_files])}"
+                
+            logger.info(f"Loaded fallback knowledge content from: {first_file}")
+        except Exception as e:
+            logger.warning(f"Could not load knowledge content for fallback: {e}")
+            knowledge_content = "Comprehensive Valetax knowledge base with trading guides, FAQs, and support procedures."
+    
+    try:
+        # Try file-based approach first
+        logger.info("Attempting file-based GPT initialization...")
+        gpt_tool = PersistentCustomGPT(api_key=openai_api_key)
+        
+        # Handle force new assistant
+        if FORCE_NEW_ASSISTANT:
+            logger.info("🔄 FORCE_NEW_ASSISTANT=true - Creating new assistant...")
+            gpt_tool.assistant_id = None  # Force new creation
+            gpt_tool.save_config()
+        
+        assistant_id = gpt_tool.create_or_load_assistant(
+            base_instructions, 
+            knowledge_files,
+            force_update=FORCE_UPDATE_INSTRUCTIONS
+        )
+        logger.info(f"✅ File-based GPT initialized: {assistant_id}")
+        
+    except Exception as e:
+        logger.warning(f"⚠️ File-based GPT failed: {e}")
+        logger.info("🔄 Falling back to instruction-based GPT...")
+        
+        try:
+            # Fallback to instruction-based approach
+            instruction_gpt = InstructionBasedGPT(openai_api_key, knowledge_content)
+            assistant_id = instruction_gpt.create_assistant(base_instructions)
+            logger.info(f"✅ Instruction-based GPT initialized: {assistant_id}")
+            
+        except Exception as e2:
+            logger.error(f"❌ All GPT initialization failed: {e2}")
+            raise
+    
+    yield  # App is running
+    
+    # Cleanup (if needed)
+    logger.info("Shutting down application")
+
+app = FastAPI(
+    title="Valetax Customer Service API",
+    description="AI-powered customer service for Valetax.com",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Global GPT instances
+gpt_tool: Optional[PersistentCustomGPT] = None
+instruction_gpt: Optional[InstructionBasedGPT] = None
+
+
+
+
+# --- Request/Response Models ---
+class QueryRequest(BaseModel):
+    message: str
+    customer_id: Optional[str] = "anonymous"
+
+class QueryResponse(BaseModel):
+    response: str
+    customer_id: str
+    method: str
+    timestamp: str
+
+class HealthResponse(BaseModel):
+    status: str
+    method: str
+    assistant_id: Optional[str] = None
+    uptime: str
+
+class ErrorResponse(BaseModel):
+    error: str
+    detail: str
+    timestamp: str
+
+# --- API Endpoints ---
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+    """Custom HTTP exception handler"""
+    import datetime
+    return {
+        "error": exc.detail,
+        "status_code": exc.status_code,
+        "timestamp": datetime.datetime.now().isoformat()
+    }
+
+@app.post("/reload-knowledge")
+async def reload_knowledge_files():
+    """Reload knowledge files and update assistant"""
+    global gpt_tool
+    
+    if not gpt_tool:
+        raise HTTPException(status_code=503, detail="GPT tool not initialized")
+    
+    try:
+        # Get current knowledge files
+        possible_files = [
+            r"F:\ai\makookAi\custom_gpt\data_row\Valetax GuideBook V0.1.2 AR - copy finale .pdf",
+            r"F:\ai\makookAi\custom_gpt\data_row\Eaxem 2025.xlsx",
+            r"F:\ai\makookAi\custom_gpt\data_row\issues.xlsx",
+        ]
+        
+        current_files = [f for f in possible_files if os.path.exists(f)]
+        
+        if current_files:
+            # Upload new files
+            new_file_ids = gpt_tool.upload_files(current_files)
+            logger.info(f"Reloaded {len(new_file_ids)} knowledge files")
+            
+            return {
+                "status": "success",
+                "files_reloaded": len(new_file_ids),
+                "file_names": [os.path.basename(f) for f in current_files],
+                "new_file_ids": new_file_ids
+            }
+        else:
+            return {
+                "status": "warning",
+                "message": "No knowledge files found to reload"
+            }
+            
+    except Exception as e:
+        logger.error(f"Error reloading knowledge files: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to reload knowledge files: {str(e)}")
+@app.get("/", response_model=Dict[str, Any])
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "service": "Valetax Customer Service API",
+        "version": "1.0.0",
+        "status": "active",
+        "endpoints": {
+            "health": "/health",
+            "query": "/query",
+            "api_info": "/api-info"
+        }
+    }
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    import datetime
+    
+    if gpt_tool is not None:
+        return HealthResponse(
+            status="healthy",
+            method="file-based",
+            assistant_id=gpt_tool.assistant_id,
+            uptime=str(datetime.datetime.now())
+        )
+    elif instruction_gpt is not None:
+        return HealthResponse(
+            status="healthy",
+            method="instruction-based", 
+            assistant_id=instruction_gpt.assistant_id,
+            uptime=str(datetime.datetime.now())
+        )
+    else:
+        raise HTTPException(status_code=503, detail="No GPT tool initialized")
+
+@app.post("/query", response_model=QueryResponse)
+async def query_gpt(request: QueryRequest):
+    """Main endpoint to query the GPT"""
+    import datetime
+    
+    if not request.message.strip():
+        raise HTTPException(status_code=400, detail="Message cannot be empty")
+    
+    try:
+        # Try file-based GPT first
+        if gpt_tool is not None:
+            response = gpt_tool.query(
+                message=request.message,
+                customer_id=request.customer_id
+            )
+            return QueryResponse(
+                response=response,
+                customer_id=request.customer_id,
+                method="file-based",
+                timestamp=datetime.datetime.now().isoformat()
+            )
+        
+        # Fallback to instruction-based GPT
+        elif instruction_gpt is not None:
+            response = instruction_gpt.query(
+                message=request.message,
+                customer_id=request.customer_id
+            )
+            return QueryResponse(
+                response=response,
+                customer_id=request.customer_id,
+                method="instruction-based",
+                timestamp=datetime.datetime.now().isoformat()
+            )
+        
+        else:
+            raise HTTPException(status_code=503, detail="No GPT tool available")
+            
+    except Exception as e:
+        logger.error(f"Query failed for customer {request.customer_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Query failed: {str(e)}")
+
+@app.get("/api-info")
+async def api_info():
+    """Get API capability information"""
+    try:
+        client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        
+        return {
+            "openai_version": openai.__version__,
+            "has_beta": hasattr(client, 'beta'),
+            "has_assistants": hasattr(client.beta, 'assistants') if hasattr(client, 'beta') else False,
+            "has_vector_stores": hasattr(client.beta, 'vector_stores') if hasattr(client, 'beta') else False,
+            "current_method": "file-based" if gpt_tool else "instruction-based" if instruction_gpt else "none",
+            "assistant_id": gpt_tool.assistant_id if gpt_tool else instruction_gpt.assistant_id if instruction_gpt else None
+        }
+    except Exception as e:
+        logger.error(f"Error getting API info: {e}")
+        return {"error": str(e)}
+
+@app.get("/knowledge-files")
+async def list_knowledge_files():
+    """List all knowledge files and their status"""
+    files_info = []
+    
+    # Get the same file list from startup
+    possible_files = [
+        "F:/ai/makookAi/custom_gpt/data_cleaned/documents.json",
+        "F:/ai/makookAi/custom_gpt/data_cleaned/valetax_faq.pdf",
+        "F:/ai/makookAi/custom_gpt/data_cleaned/trading_guide.pdf", 
+        "F:/ai/makookAi/custom_gpt/data_cleaned/account_info.xlsx",
+        "F:/ai/makookAi/custom_gpt/data_cleaned/support_procedures.docx",
+        "F:/ai/makookAi/custom_gpt/data_cleaned/fee_structure.csv",
+    ]
+    
+    for file_path in possible_files:
+        file_info = {
+            "path": file_path,
+            "filename": os.path.basename(file_path),
+            "exists": os.path.exists(file_path),
+            "type": os.path.splitext(file_path)[1].lower(),
+            "size_kb": round(os.path.getsize(file_path) / 1024, 2) if os.path.exists(file_path) else 0
+        }
+        files_info.append(file_info)
+    
+    # Get uploaded files from GPT tool
+    uploaded_files = []
+    if gpt_tool:
+        uploaded_files = gpt_tool.uploaded_files
+    
+    return {
+        "knowledge_files": files_info,
+        "uploaded_file_ids": uploaded_files,
+        "total_existing": len([f for f in files_info if f["exists"]]),
+        "supported_formats": [".txt", ".md", ".json", ".csv", ".pdf", ".docx", ".xlsx", ".xls", ".py", ".js", ".html", ".css"]
+    }
+
+@app.post("/reload-knowledge")
+async def reload_knowledge_files():
+    """Reload knowledge files and update assistant"""
+    global gpt_tool
+    
+    if not gpt_tool:
+        raise HTTPException(status_code=503, detail="GPT tool not initialized")
+    
+    try:
+        # Get current knowledge files
+        possible_files = [
+            r"F:\ai\makookAi\custom_gpt\data_row\Valetax GuideBook V0.1.2 AR - copy finale .pdf",
+            r"F:\ai\makookAi\custom_gpt\data_row\Eaxem 2025.xlsx",
+            r"F:\ai\makookAi\custom_gpt\data_row\issues.xlsx",
+        ]
+        
+        current_files = [f for f in possible_files if os.path.exists(f)]
+        
+        if current_files:
+            # Upload new files
+            new_file_ids = gpt_tool.upload_files(current_files)
+            logger.info(f"Reloaded {len(new_file_ids)} knowledge files")
+            
+            return {
+                "status": "success",
+                "files_reloaded": len(new_file_ids),
+                "file_names": [os.path.basename(f) for f in current_files],
+                "new_file_ids": new_file_ids
+            }
+        else:
+            return {
+                "status": "warning",
+                "message": "No knowledge files found to reload"
+            }
+            
+    except Exception as e:
+        logger.error(f"Error reloading knowledge files: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to reload knowledge files: {str(e)}")
+
+# --- Exception Handlers ---
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+    """Custom HTTP exception handler"""
+    import datetime
+    return {
+        "error": exc.detail,
+        "status_code": exc.status_code,
+        "timestamp": datetime.datetime.now().isoformat()
+    }
+
+# --- Run the app ---
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Ensure environment variable is set
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ Error: OPENAI_API_KEY environment variable is not set")
+        print("Please set it with: export OPENAI_API_KEY='your-api-key-here'")
+        exit(1)
+    
+    print("🚀 Starting Valetax Customer Service API...")
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
+    
 def respond(
     message,
     history: list[dict[str, str]],