ADD

- more relevant suggested questions
- better reasoning traces handling
- better interface

app.py

@@ -19,9 +19,12 @@ def process_pdf(pdf_file, embedding_model, chunk_size, chunk_overlap):
         else:
             status, chunks_display, corpus_text = rag.process_document(pdf_file.name, chunk_size, chunk_overlap)
 
-        return status, chunks_display, corpus_text
+        # Generate example questions based on the corpus
+        example_questions = rag.generate_example_questions(num_questions=5)
+
+        return status, chunks_display, corpus_text, example_questions
     except Exception as e:
-        return f"Error: {str(e)}", "", ""
+        return f"Error: {str(e)}", "", "", []
 
 @spaces.GPU
 def perform_query(
@@ -145,10 +148,13 @@ def create_interface():
                 with gr.Accordion("📑 Processed Chunks", open=False):
                     processed_chunks_display = gr.Markdown()
 
+                # State to hold example questions
+                example_questions_state = gr.State([])
+
                 process_btn.click(
                     fn=process_pdf,
                     inputs=[pdf_upload, embedding_model, chunk_size, chunk_overlap],
-                    outputs=[corpus_status, processed_chunks_display, default_corpus_display]
+                    outputs=[corpus_status, processed_chunks_display, default_corpus_display, example_questions_state]
                 )
 
             # Tab 2: Retrieval Configuration
@@ -215,17 +221,25 @@ def create_interface():
                     lines=3
                 )
 
-                examples = gr.Examples(
-                    examples=[
-                        ["What is Retrieval Augmented Generation?"],
-                        ["How does RAG improve language models?"],
-                        ["What are the main components of a RAG system?"],
-                        ["Explain the role of embeddings in RAG."],
-                        ["What are the advantages of using RAG?"],
-                    ],
-                    inputs=query_input,
-                    label="Example Questions"
-                )
+                with gr.Accordion("💡 Example Questions (click to expand)", open=True):
+                    gr.Markdown("*Questions generated based on your corpus content*")
+                    examples_markdown = gr.Markdown(visible=False)
+
+                    # Connect processing to update examples
+                    def format_questions_markdown(questions):
+                        if not questions or len(questions) == 0:
+                            return gr.update(value="", visible=False)
+
+                        md = ""
+                        for i, q in enumerate(questions, 1):
+                            md += f"{i}. {q}\n\n"
+                        return gr.update(value=md, visible=True)
+
+                    example_questions_state.change(
+                        fn=format_questions_markdown,
+                        inputs=[example_questions_state],
+                        outputs=[examples_markdown]
+                    )
 
                 query_btn = gr.Button("🔍 Submit Query", variant="primary", size="lg")
 

rag_system.py

@@ -2,6 +2,7 @@
 
 import os
 import glob
+import re
 from typing import List, Tuple, Optional
 import PyPDF2
 import faiss
@@ -267,7 +268,129 @@ Answer:"""
             else:
                 answer = str(response).strip()
 
+            # Handle reasoning tokens (for models like Qwen)
+            answer = self._process_reasoning_output(answer)
+
             return answer, prompt
 
         except Exception as e:
             return f"Error generating response: {str(e)}", prompt
+
+    def _process_reasoning_output(self, text: str) -> str:
+        """Process output from reasoning models to separate thinking from answer"""
+        # Common patterns for reasoning models
+        # Qwen uses <think>...</think> tags
+        if '<think>' in text and '</think>' in text:
+            # Extract reasoning and answer
+            reasoning_match = re.search(r'<think>(.*?)</think>', text, re.DOTALL)
+            if reasoning_match:
+                reasoning = reasoning_match.group(1).strip()
+                answer = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL).strip()
+
+                return f"""**Answer:**
+
+{answer}
+
+---
+
+<details>
+<summary>🧠 Model Reasoning (click to expand)</summary>
+
+```
+{reasoning}
+```
+
+</details>"""
+
+        # Alternative pattern: text before "Answer:" or similar markers
+        if re.search(r'(Answer:|Final Answer:|Response:)', text, re.IGNORECASE):
+            parts = re.split(r'(Answer:|Final Answer:|Response:)', text, re.IGNORECASE)
+            if len(parts) >= 3:
+                reasoning = parts[0].strip()
+                answer = ''.join(parts[2:]).strip()
+
+                if reasoning and len(reasoning) > 50:  # Only if there's substantial reasoning
+                    return f"""**Answer:**
+
+{answer}
+
+---
+
+<details>
+<summary>🧠 Model Reasoning (click to expand)</summary>
+
+```
+{reasoning}
+```
+
+</details>"""
+
+        # No reasoning pattern found, return as is
+        return text
+
+    def generate_example_questions(self, num_questions: int = 5) -> List[str]:
+        """Generate example questions based on the corpus content"""
+        if not self.is_ready() or not self.chunks:
+            return [
+                "What is the main topic of this document?",
+                "Can you summarize the key points?",
+                "What are the main concepts discussed?",
+            ]
+
+        # Sample some chunks to understand the corpus
+        sample_size = min(10, len(self.chunks))
+        import random
+        sample_chunks = random.sample(self.chunks, sample_size)
+        sample_text = "\n".join(sample_chunks[:3])  # Use first 3 sampled chunks
+
+        # Generate questions using the LLM
+        try:
+            if self.llm_client is None:
+                self.set_llm_model("meta-llama/Llama-3.2-1B-Instruct")
+
+            prompt = f"""Based on the following text excerpts, generate {num_questions} diverse and relevant questions that could be answered using this corpus. Make the questions specific and interesting.
+
+Text excerpts:
+{sample_text[:2000]}
+
+Generate exactly {num_questions} questions, one per line, without numbering:"""
+
+            messages = [{"role": "user", "content": prompt}]
+
+            response = self.llm_client.chat_completion(
+                messages=messages,
+                max_tokens=300,
+                temperature=0.8,
+            )
+
+            # Extract questions
+            if hasattr(response, 'choices') and len(response.choices) > 0:
+                questions_text = response.choices[0].message.content.strip()
+            elif isinstance(response, dict) and 'choices' in response:
+                questions_text = response['choices'][0]['message']['content'].strip()
+            else:
+                questions_text = str(response).strip()
+
+            # Clean up reasoning if present
+            questions_text = re.sub(r'<think>.*?</think>', '', questions_text, flags=re.DOTALL)
+
+            # Parse questions
+            questions = [q.strip() for q in questions_text.split('\n') if q.strip()]
+            # Remove numbering if present
+            questions = [re.sub(r'^\d+[\.\)]\s*', '', q) for q in questions]
+            # Filter out empty or very short questions
+            questions = [q for q in questions if len(q) > 10]
+
+            return questions[:num_questions] if questions else self._default_questions()
+
+        except Exception as e:
+            print(f"Error generating questions: {e}")
+            return self._default_questions()
+
+    def _default_questions(self) -> List[str]:
+        """Return default questions if generation fails"""
+        return [
+            "What is the main topic discussed in this corpus?",
+            "Can you summarize the key concepts?",
+            "What are the main findings or arguments presented?",
+        ]