better adapted for interview questions

README.md

@@ -8,9 +8,16 @@ app_file: app_hf.py
 pinned: false
 ---
 
-# RAG API with Hugging Face Spaces
+# Enhanced RAG API with Interview-Style Question Support
 
-This is a RAG (Retrieval-Augmented Generation) API deployed on Hugging Face Spaces.
+This is an enhanced RAG (Retrieval-Augmented Generation) API deployed on Hugging Face Spaces with hybrid AI support for interview-style questions.
+
+## Features
+
+- **DeepSeek-Powered**: Uses DeepSeek as the primary response generator for all questions
+- **Enhanced Responses**: DeepSeek provides more engaging, first-person responses
+- **Fallback Support**: Gracefully falls back to Cohere if DeepSeek is unavailable
+- **Context-Aware**: Uses retrieved documents to provide specific examples and details
 
 ## API Endpoints
 
@@ -24,8 +31,39 @@ This is a RAG (Retrieval-Augmented Generation) API deployed on Hugging Face Spac
 }
 ```
 
+## Environment Variables
+
+Create a `.env` file with the following variables:
+
+```env
+# Cohere API key (required for basic RAG functionality)
+COHEREAPIKEY=your_cohere_api_key_here
+
+# DeepSeek API key (required for enhanced interview-style question handling)
+DEEPKEY=your_deepseek_api_key_here
+```
+
 ## Local Development
+
 1. Clone this repository
 2. Install dependencies: `pip install -r requirements_hf.txt`
-3. Set up environment variables in `.env`
-4. Run: `python app_hf.py`
+3. Set up environment variables in `.env` (see above)
+4. Run the main application: `python app_hf.py`
+5. Or test the system: `python test_interview_questions.py`
+
+## Response Generation
+
+The system uses DeepSeek as the primary response generator for all questions, providing:
+
+- **Engaging First-Person Responses**: Answers as if Julien is speaking directly
+- **Context-Aware Answers**: Uses retrieved documents for specific examples
+- **Professional Tone**: Maintains appropriate level of formality
+- **Comprehensive Coverage**: Handles technical, personal, and general questions
+
+### Question Examples:
+- "What is your educational background?"
+- "Tell me about a challenging project you worked on..."
+- "What programming languages do you know?"
+- "Describe your experience with machine learning..."
+- "What are your research interests?"
+- "Walk me through your journey in computer science..."

app_hf.py

@@ -43,7 +43,7 @@ def handle_query():
         print(f"Received query: {query}")
 
         search_results = query_system.search(query, k=5)
-        response_text = query_system.generate_response(query, search_results)
+        response_text = query_system.generate_hybrid_response(query, search_results)
 
         sources_for_response = [
             {

queryrun.py

@@ -8,18 +8,22 @@ from dotenv import load_dotenv
 from langchain_community.docstore.document import Document
 # Corrected import based on the deprecation warning
 from langchain_community.docstore.in_memory import InMemoryDocstore
-# from openai import OpenAI  # DeepSeek API no longer used
+from openai import OpenAI  # DeepSeek API for interview-style questions
 
 # Load environment variables
 load_dotenv()
 cohere_api_key = os.getenv("COHEREAPIKEY")
-# api_key = os.getenv("DEEPKEY")  # DeepSeek API key no longer needed
-
-# DeepSeek client initialization commented out
-# client = OpenAI(
-#     api_key=api_key,
-#     base_url="https://api.deepseek.com/v1"
-# )
+deepseek_api_key = os.getenv("DEEPKEY")  # DeepSeek API key for enhanced responses
+
+# DeepSeek client initialization
+if deepseek_api_key:
+    deepseek_client = OpenAI(
+        api_key=deepseek_api_key,
+        base_url="https://api.deepseek.com/v1"
+    )
+else:
+    deepseek_client = None
+    print("Warning: DEEPKEY not found. DeepSeek features will be disabled.")
 
 # Initialize Cohere client
 if not cohere_api_key:
@@ -238,6 +242,44 @@ class FAISSQuerySystem:
             traceback.print_exc()
             raise
 
+    def is_interview_style_question(self, query):
+        """Detect if the query is an interview-style question that would benefit from DeepSeek"""
+        query_lower = query.lower()
+        
+        # Interview-style question patterns
+        interview_patterns = [
+            "tell me about", "can you tell me", "describe", "explain",
+            "what makes you", "why did you", "how did you", "what inspired",
+            "walk me through", "give me an example", "share a story",
+            "what was your role", "what challenges", "what was it like",
+            "how do you approach", "what's your experience with",
+            "what skills", "what technologies", "what projects",
+            "what's your background", "what's your journey",
+            "what are your strengths", "what are you passionate about",
+            "what motivates you", "what's your philosophy",
+            "how would you", "what would you do if",
+            "describe a time when", "tell me about a project where"
+        ]
+        
+        # Check for interview patterns
+        for pattern in interview_patterns:
+            if pattern in query_lower:
+                return True
+        
+        # Check for question words that suggest interview context
+        question_words = ["why", "how", "what", "when", "where", "which", "who"]
+        if any(query_lower.startswith(word) for word in question_words):
+            # Additional context clues for interview questions
+            interview_context = [
+                "experience", "project", "work", "study", "research", "develop",
+                "create", "build", "learn", "achieve", "accomplish", "solve",
+                "challenge", "problem", "team", "collaborate", "lead", "manage"
+            ]
+            if any(context in query_lower for context in interview_context):
+                return True
+        
+        return False
+
     def preprocess_query(self, query):
         """Preprocess query to improve retrieval and context understanding"""
         if not isinstance(query, str):
@@ -329,6 +371,92 @@ class FAISSQuerySystem:
         results.sort(key=lambda x: x['score'], reverse=True)
         return results
 
+    def generate_deepseek_response(self, query, context_docs):
+        """Generate response using DeepSeek as the primary response generator"""
+        if not deepseek_client:
+            print("DeepSeek client not available, falling back to Cohere")
+            return self.generate_response(query, context_docs)
+        
+        if not context_docs:
+            try:
+                response = deepseek_client.chat.completions.create(
+                    model="deepseek-chat",
+                    messages=[
+                        {
+                            "role": "system", 
+                            "content": "You are Julien Serbanescu, a computer science student and AI researcher. Answer questions about your background, projects, and experience in a professional, engaging manner. Be specific and provide concrete examples when possible. If you don't have specific information, acknowledge this and suggest how the user might rephrase their question."
+                        },
+                        {
+                            "role": "user", 
+                            "content": f"I could not find relevant documents in my knowledge base to answer your question: '{query}'. Please provide a general response about your background and suggest how the user might rephrase their question."
+                        }
+                    ],
+                    temperature=0.7,
+                    max_tokens=1000
+                )
+                return response.choices[0].message.content
+            except Exception as e:
+                print(f"Error calling DeepSeek without documents: {e}")
+                return "I could not find relevant documents and encountered an error trying to respond."
+
+        # Format context documents for DeepSeek
+        context_text = ""
+        for i, doc in enumerate(context_docs[:5]):  # Limit to top 5 docs for DeepSeek
+            content = doc['content']
+            if not isinstance(content, str):
+                try:
+                    content = str(content)
+                except UnicodeEncodeError:
+                    import unicodedata
+                    content = unicodedata.normalize('NFKD', str(content))
+            
+            source = doc['metadata'].get('source', 'Unknown')
+            context_text += f"\n--- Source {i+1} ({source}) ---\n{content[:2000]}\n"
+
+        try:
+            response = deepseek_client.chat.completions.create(
+                model="deepseek-chat",
+                messages=[
+                    {
+                        "role": "system", 
+                        "content": f"""You are Julien Serbanescu, a computer engineering student and AI researcher. Answer the user's question based on the provided context documents about your background, projects, and experience. 
+
+Context about Julien Serbanescu:
+{context_text}
+
+Guidelines:
+- Answer as if you are Julien speaking in first person
+- Be specific and provide concrete examples from the context
+- Use a professional but engaging tone
+- If the context doesn't contain enough information, acknowledge this and provide what you can
+- Structure your response clearly with specific examples
+- Show enthusiasm and passion for your work
+- For technical questions, provide detailed explanations
+- For general questions, give comprehensive but concise answers"""
+                    },
+                    {
+                        "role": "user", 
+                        "content": query
+                    }
+                ],
+                temperature=0.7,
+                max_tokens=1500
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"Error calling DeepSeek: {e}")
+            # Fallback to Cohere
+            return self.generate_response(query, context_docs)
+
+    def generate_hybrid_response(self, query, context_docs):
+        """Generate response using DeepSeek as primary, with Cohere fallback"""
+        if deepseek_client:
+            print("Using DeepSeek for enhanced response...")
+            return self.generate_deepseek_response(query, context_docs)
+        else:
+            print("DeepSeek not available, using Cohere fallback...")
+            return self.generate_response(query, context_docs)
+
     def generate_response(self, query, context_docs):
         """Generate RAG response using Cohere's chat API"""
         if not context_docs:
@@ -412,7 +540,7 @@ def main():
 
                 if not docs:
                     print("Could not find relevant documents in the knowledge base.")
-                    response = query_system.generate_response(query, [])
+                    response = query_system.generate_hybrid_response(query, [])
                     print("\nResponse:")
                     print("-" * 50)
                     print(response)
@@ -421,9 +549,9 @@ def main():
 
                 print(f"Found {len(docs)} relevant document chunks.")
 
-                # 2. Generate and display response using RAG
+                # 2. Generate and display response using hybrid RAG
                 print("Generating response based on documents...")
-                response = query_system.generate_response(query, docs)
+                response = query_system.generate_hybrid_response(query, docs)
                 print("\nResponse:")
                 print("-" * 50)
                 print(response)

requirements_downloader.txt

@@ -5,3 +5,4 @@ requests>=2.31.0
 pathlib2>=2.3.7; python_version < "3.4"
 
 
+

test_interview_questions.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Test script to demonstrate the enhanced QA system with interview-style question handling.
+This script tests both regular questions and interview-style questions to show the difference.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# Add the current directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from queryrun import FAISSQuerySystem
+
+def test_questions():
+    """Test various types of questions to demonstrate the DeepSeek-enhanced system"""
+    
+    # Load environment variables
+    load_dotenv()
+    
+    # Test questions
+    test_cases = [
+        {
+            "type": "General Question",
+            "question": "What is Julien's educational background?"
+        },
+        {
+            "type": "Interview Question",
+            "question": "Tell me about a challenging project you worked on and how you overcame the difficulties."
+        },
+        {
+            "type": "Technical Question", 
+            "question": "What programming languages does Julien know?"
+        },
+        {
+            "type": "Experience Question",
+            "question": "Describe your experience with machine learning and what excites you most about AI research."
+        },
+        {
+            "type": "Research Question",
+            "question": "What are Julien's research interests?"
+        },
+        {
+            "type": "Personal Question",
+            "question": "Walk me through your journey in computer science and what motivated you to pursue this field."
+        }
+    ]
+    
+    try:
+        print("Initializing RAG system...")
+        query_system = FAISSQuerySystem()
+        print("RAG system ready!\n")
+        
+        for i, test_case in enumerate(test_cases, 1):
+            print(f"{'='*80}")
+            print(f"TEST CASE {i}: {test_case['type']}")
+            print(f"Question: {test_case['question']}")
+            print(f"{'='*80}")
+            
+            # Search for relevant documents
+            print("\nSearching for relevant documents...")
+            docs = query_system.search(test_case['question'], k=5)
+            print(f"Found {len(docs)} relevant documents")
+            
+            # Generate response using DeepSeek (with Cohere fallback)
+            print("\nGenerating response with DeepSeek...")
+            response = query_system.generate_hybrid_response(test_case['question'], docs)
+            
+            print(f"\nResponse:")
+            print("-" * 60)
+            print(response)
+            print("-" * 60)
+            
+            # Show sources
+            if docs:
+                print(f"\nSources used:")
+                for j, doc in enumerate(docs[:3], 1):  # Show top 3 sources
+                    print(f"  {j}. {doc['metadata'].get('source', 'Unknown')} (score: {doc['score']:.4f})")
+            
+            print(f"\n{'-'*80}\n")
+            
+    except Exception as e:
+        print(f"Error during testing: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    test_questions()