Fixing issues

app.py

@@ -78,13 +78,32 @@ async def lifespan(app: FastAPI):
     
     # Initialize OpenAI client with Groq endpoint
     try:
+        print(f"Configuring OpenAI client with:")
+        print(f"  Base URL: {Config.GROQ_BASE_URL}")
+        print(f"  API Key: {'*' * 10}...{Config.GROQ_API_KEY[-4:] if Config.GROQ_API_KEY else 'None'}")
+        
         app_state.openai_client = AsyncOpenAI(
             api_key=Config.GROQ_API_KEY,
-            base_url=Config.GROQ_BASE_URL
+            base_url=Config.GROQ_BASE_URL,
+            timeout=60.0  # Add timeout
         )
         print("✓ OpenAI client initialized with Groq endpoint")
+        
+        # Test the client with a simple request
+        try:
+            test_response = await app_state.openai_client.chat.completions.create(
+                model="mixtral-8x7b-32768",
+                messages=[{"role": "user", "content": "Hello"}],
+                max_tokens=10
+            )
+            print(f"✓ OpenAI client test successful - Response ID: {test_response.id}")
+        except Exception as test_error:
+            print(f"⚠ OpenAI client test failed: {test_error}")
+            print("  This might cause issues with chat completions")
+            
     except Exception as e:
         print(f"✗ Error initializing OpenAI client: {e}")
+        print(f"  Error type: {type(e)}")
         raise e
     
     # Initialize Qdrant client
@@ -355,9 +374,24 @@ async def health_check():
         except Exception as e:
             embedding_health = {"status": "error", "error": str(e)}
     
+    # Test OpenAI client
+    if app_state.openai_client is None:
+        openai_health = {"status": "not_initialized", "error": "OpenAI client is None"}
+    else:
+        try:
+            # Quick test of OpenAI client
+            test_response = await app_state.openai_client.chat.completions.create(
+                model="mixtral-8x7b-32768",
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=1
+            )
+            openai_health = {"status": "healthy", "test_response_id": test_response.id}
+        except Exception as e:
+            openai_health = {"status": "error", "error": str(e)}
+    
     return {
         "status": "healthy" if app_state.embedding_service is not None else "unhealthy",
-        "openai_client": "connected" if app_state.openai_client else "not configured",
+        "openai_client": openai_health,
         "qdrant": qdrant_status,
         "embedding_service": embedding_health,
         "collection": Config.COLLECTION_NAME,
@@ -379,21 +413,28 @@ async def chat_completions(request: ChatCompletionRequest):
             raise HTTPException(status_code=400, detail="No user message found")
         
         last_user_message = user_messages[-1].content
+        print(f"Processing query: {last_user_message[:100]}...")
         
         # Retrieve relevant chunks
-        relevant_chunks = await RAGService.retrieve_relevant_chunks(last_user_message)
+        try:
+            relevant_chunks = await RAGService.retrieve_relevant_chunks(last_user_message)
+            print(f"Retrieved {len(relevant_chunks)} chunks")
+        except Exception as e:
+            print(f"Error in retrieval: {e}")
+            relevant_chunks = []
         
         # Build context-aware prompt
         if relevant_chunks:
             context_prompt = RAGService.build_context_prompt(last_user_message, relevant_chunks)
-            
-            # Replace the last user message with context-enhanced version
             enhanced_messages = request.messages[:-1] + [Message(role="user", content=context_prompt)]
+            print("Using context-enhanced prompt")
         else:
             enhanced_messages = request.messages
+            print("Using original prompt (no context)")
         
         # Convert to OpenAI format
         openai_messages = [{"role": msg.role, "content": msg.content} for msg in enhanced_messages]
+        print(f"Sending {len(openai_messages)} messages to OpenAI API")
         
         if request.stream:
             return StreamingResponse(
@@ -403,12 +444,22 @@ async def chat_completions(request: ChatCompletionRequest):
         else:
             return await create_chat_completion(openai_messages, request)
             
+    except HTTPException:
+        raise
     except Exception as e:
+        print(f"Unexpected error in chat_completions: {e}")
+        print(f"Error type: {type(e)}")
+        import traceback
+        traceback.print_exc()
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
 async def create_chat_completion(messages: List[Dict], request: ChatCompletionRequest) -> ChatCompletionResponse:
     """Create a non-streaming chat completion"""
     try:
+        print(f"Calling OpenAI API with model: {request.model}")
+        print(f"Messages count: {len(messages)}")
+        print(f"Max tokens: {request.max_tokens}")
+        
         response = await app_state.openai_client.chat.completions.create(
             model=request.model,
             messages=messages,
@@ -418,8 +469,13 @@ async def create_chat_completion(messages: List[Dict], request: ChatCompletionRe
             stream=False
         )
         
+        print(f"Received response from OpenAI API")
+        print(f"Response ID: {response.id}")
+        print(f"Response model: {response.model}")
+        print(f"Choices count: {len(response.choices)}")
+        
         # Convert response to OpenAI format (already compatible)
-        return ChatCompletionResponse(
+        result = ChatCompletionResponse(
             id=response.id,
             created=response.created,
             model=response.model,
@@ -438,7 +494,14 @@ async def create_chat_completion(messages: List[Dict], request: ChatCompletionRe
             } if response.usage else None
         )
         
+        print(f"Successfully created response")
+        return result
+        
     except Exception as e:
+        print(f"Error in create_chat_completion: {e}")
+        print(f"Error type: {type(e)}")
+        import traceback
+        traceback.print_exc()
         raise HTTPException(status_code=500, detail=f"Error calling OpenAI API: {str(e)}")
 
 async def stream_chat_completion(messages: List[Dict], request: ChatCompletionRequest) -> AsyncGenerator[str, None]: