change for AI thinking

app.py

@@ -3,76 +3,101 @@ from huggingface_hub import InferenceClient
 import time
 import html
 import re
+import traceback
 
 """
 For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
 """
 client = InferenceClient("Trinoid/Data_Management")
 
-def clean_response(text):
-    """Clean up response by removing meta-text, thinking artifacts, and repetitive content"""
-    # Remove thinking phrases
-    thinking_patterns = [
-        r"I need to figure out",
-        r"I'll start by",
-        r"Let me try to",
-        r"I'm trying to understand",
-        r"First, I know that",
-        r"I'll need to look into",
-        r"I'm not entirely sure",
-        r"I believe this is",
-        r"I imagine it involves",
-        r"Okay, so I need to",
-        r"From what I know,",
-        r"One of the main reasons to",
-        r"Another reason to",
-    ]
+# Comprehensive patterns to filter out thinking and meta-commentary
+THINKING_PATTERNS = [
+    r"Okay, so I('m| am) (trying to|going to|attempting to)",
+    r"I need to figure out",
+    r"I'll start by",
+    r"Let me try to",
+    r"I'm trying to understand",
+    r"First, I know that",
+    r"I'll need to look into",
+    r"I'm not entirely sure",
+    r"I believe this is",
+    r"I imagine it involves",
+    r"I think I understand",
+    r"From what I know",
+    r"Let me think about",
+    r"From my understanding",
+    r"As I understand it",
+    r"To answer this question",
+    r"To address this",
+    r"I'll approach this by",
+]
+
+def process_final_response(response_text):
+    """Comprehensive processing of the final response to ensure quality"""
     
-    for pattern in thinking_patterns:
-        text = re.sub(pattern, "", text, flags=re.IGNORECASE)
+    # Early return if response is too short
+    if len(response_text) < 50:
+        return response_text
     
-    # Split into paragraphs for deduplication
-    paragraphs = text.split('\n\n')
+    # 1. Remove thinking patterns
+    for pattern in THINKING_PATTERNS:
+        response_text = re.sub(pattern, "", response_text, flags=re.IGNORECASE)
     
-    # Only keep meaningful paragraphs
+    # 2. Split into paragraphs
+    paragraphs = [p.strip() for p in response_text.split('\n\n') if p.strip()]
+    
+    # 3. Filter meaningless paragraphs
     filtered_paragraphs = []
-    for p in paragraphs:
-        if p and len(p.strip()) > 20:  # Only include non-empty paragraphs with substance
-            filtered_paragraphs.append(p)
+    for para in paragraphs:
+        # Skip too short paragraphs or those that are just meta-commentary
+        if len(para) < 20 or re.search(r"^(In summary|To summarize|In conclusion)", para, re.IGNORECASE):
+            continue
+        filtered_paragraphs.append(para)
     
-    # Remove similar paragraphs (not just exact duplicates)
+    # 4. Remove duplicates and similar paragraphs
     unique_paragraphs = []
-    for i, current_para in enumerate(filtered_paragraphs):
-        is_duplicate = False
-        
-        # Convert to lowercase and remove punctuation for comparison
-        clean_current = re.sub(r'[^\w\s]', '', current_para.lower())
+    for current in filtered_paragraphs:
+        # Clean for comparison
+        clean_current = re.sub(r'[^\w\s]', '', current.lower())
+        words_current = set(clean_current.split())
         
-        for prev_para in unique_paragraphs:
-            # Clean previous paragraph too
-            clean_prev = re.sub(r'[^\w\s]', '', prev_para.lower())
-            
-            # Check for similarity using character overlap
-            # If more than 50% of words match, consider it similar
-            words_current = set(clean_current.split())
-            words_prev = set(clean_prev.split())
+        is_duplicate = False
+        for existing in unique_paragraphs:
+            clean_existing = re.sub(r'[^\w\s]', '', existing.lower())
+            words_existing = set(clean_existing.split())
             
-            if len(words_current) > 0 and len(words_prev) > 0:
-                common_words = words_current.intersection(words_prev)
-                similarity = len(common_words) / min(len(words_current), len(words_prev))
+            if len(words_current) > 3 and len(words_existing) > 3:  # Ignore very short paragraphs
+                # Calculate word overlap as similarity measure
+                overlap = len(words_current.intersection(words_existing))
+                similarity = overlap / min(len(words_current), len(words_existing))
                 
-                if similarity > 0.5:  # If more than 50% similar, it's a duplicate concept
+                if similarity > 0.6:  # 60% threshold for similarity
                     is_duplicate = True
                     break
         
         if not is_duplicate:
-            unique_paragraphs.append(current_para)
+            unique_paragraphs.append(current)
     
-    # Add a summary paragraph if we removed a lot
-    if len(unique_paragraphs) < len(filtered_paragraphs) / 2:
-        unique_paragraphs.append("Note: Some repetitive content has been removed from this response for clarity.")
+    # 5. Structure the response if needed
+    if len(unique_paragraphs) > 2 and not any(p.startswith('#') for p in unique_paragraphs):
+        # Try to add headings if response doesn't have them
+        structured_paragraphs = []
+        
+        # Add main heading
+        if len(unique_paragraphs) > 0:
+            structured_paragraphs.append(f"# Key Differences Between OneDrive for Business and SharePoint Online\n")
+            structured_paragraphs.extend(unique_paragraphs[:2])
+            
+            # Add subheadings for remaining content if appropriate
+            if len(unique_paragraphs) > 2:
+                structured_paragraphs.append(f"\n## When to Use Each Service\n")
+                structured_paragraphs.extend(unique_paragraphs[2:])
+                
+        final_text = "\n\n".join(structured_paragraphs)
+    else:
+        final_text = "\n\n".join(unique_paragraphs)
     
-    return '\n\n'.join(unique_paragraphs)
+    return final_text.strip()
 
 def respond(
     message,
@@ -82,25 +107,36 @@ def respond(
     temperature,
     top_p,
 ):
-    # Create a more structured system prompt with strict instructions about repetition
-    enhanced_system_message = f"""
+    # Create a more effective system prompt
+    enhanced_system_message = f"""You are an expert in Microsoft 365 services including SharePoint, OneDrive, Teams, and the Microsoft 365 compliance ecosystem.
+
 {system_message}
 
-CRITICAL INSTRUCTIONS FOR YOUR RESPONSES:
-1. PROVIDE DIRECT, AUTHORITATIVE, AND COMPLETE ANSWERS ABOUT MICROSOFT 365 AND DATA MANAGEMENT.
-2. DO NOT USE PHRASES LIKE "I think", "I believe", "I'm not sure", "I'll try to", "First, I need to".
-3. DO NOT INCLUDE YOUR THINKING PROCESS IN RESPONSES.
-4. USE CLEAR STRUCTURE WITH HEADINGS AND BULLET POINTS WHERE APPROPRIATE.
-5. NEVER REPEAT THE SAME INFORMATION IN DIFFERENT WORDS.
-6. MENTION EACH CONCEPT EXACTLY ONCE - DO NOT ELABORATE ON THE SAME IDEA MULTIPLE TIMES.
-7. WHEN ANSWERING QUESTIONS ABOUT DOCUMENT MANAGEMENT, PROVIDE SPECIFIC DETAILS ABOUT THE ACTUAL TOOLS AND FEATURES.
-8. LIMIT YOUR RESPONSE LENGTH TO WHAT IS NECESSARY - BE CONCISE.
-9. WHEN GIVING EXAMPLES, PROVIDE ONE CLEAR EXAMPLE RATHER THAN MULTIPLE SIMILAR ONES.
-10. ANSWER AS A MICROSOFT 365 EXPERT WITH AUTHORITATIVE KNOWLEDGE.
-"""
+FORMAT YOUR RESPONSE USING:
+- Clear, direct language
+- Markdown formatting with headings and bullet points
+- Concise, factual information
+- Specific technical details where appropriate
+
+CRITICAL RESPONSE REQUIREMENTS:
+1. Start IMMEDIATELY with the answer - no preamble or self-reference
+2. NEVER say phrases like "I think", "I believe", "I'm not sure", "I'll try to"
+3. NEVER reveal your thought process or planning
+4. Be AUTHORITATIVE and PRECISE
+5. Present EACH KEY POINT EXACTLY ONCE
+6. Focus on GOVERNANCE & TECHNICAL details for Microsoft 365
+7. Keep total response under 2000 characters
+8. Use 2-3 paragraphs maximum
+9. Provide concrete governance recommendations
+
+If comparing services:
+- List key DIFFERENCES first
+- THEN explain when to use each
+- End with GOVERNANCE recommendations"""
 
     messages = [{"role": "system", "content": enhanced_system_message}]
 
+    # Add history and current message
     for val in history:
         if val[0]:
             messages.append({"role": "user", "content": val[0]})
@@ -109,14 +145,14 @@ CRITICAL INSTRUCTIONS FOR YOUR RESPONSES:
 
     messages.append({"role": "user", "content": message})
 
-    # Track generation state
-    thinking_steps = []
+    # Initialize state variables
     full_response = ""
+    thinking_steps = []
     start_time = time.time()
-    last_token_time = time.time()
+    generation_complete = False
     
     try:
-        # Use chat completion
+        # Generate response
         for message in client.chat_completion(
             messages,
             max_tokens=max_tokens,
@@ -125,49 +161,46 @@ CRITICAL INSTRUCTIONS FOR YOUR RESPONSES:
             top_p=top_p,
         ):
             token = message.choices[0].delta.content
+            
+            # Skip empty tokens
             if not token:
-                # Check for long pause between tokens (potential stall)
-                current_time = time.time()
-                if current_time - last_token_time > 5:  # 5 second timeout
-                    if full_response:
-                        break
+                # Check for completion
+                if message.choices[0].finish_reason == "stop":
+                    generation_complete = True
                 continue
-                
-            last_token_time = time.time()
+            
+            # Append token to response
             full_response += token
             
-            # Save thinking steps for display only
-            current_time = time.time()
-            if current_time - start_time > 2 or len(full_response) % 200 == 0:
-                start_time = current_time
+            # Store thinking step snapshot every 250 chars
+            if len(full_response) % 250 == 0:
                 thinking_steps.append(full_response)
                 
-            # Format with thinking history as HTML
-            if thinking_steps and len(thinking_steps) > 1:
+            # Format and display response
+            thinking_html = ""
+            if thinking_steps:
                 thinking_html = '<div class="thinking-wrapper"><details><summary>Show thinking process</summary><div class="thinking-steps">'
-                for i, step in enumerate(thinking_steps[:-1]):
+                for i, step in enumerate(thinking_steps):
                     safe_step = html.escape(step)
                     thinking_html += f'<div class="thinking-step">Step {i+1}: {safe_step}</div>'
                 thinking_html += '</div></details></div>'
-                
-                # Always yield the full current response (no cleaning during generation)
-                yield f"{thinking_html}{full_response}"
-            else:
-                yield full_response
+            
+            # Yield the response
+            yield f"{thinking_html}{full_response}"
+        
+        # Check if we need to post-process the response
+        processed_response = process_final_response(full_response)
         
-        # Clean up the final response to remove thinking artifacts
-        if "I'm trying to understand" in full_response or "I need to figure out" in full_response:
-            cleaned_response = clean_response(full_response)
+        # If the processing made significant changes, show both versions
+        if len(processed_response) < len(full_response) * 0.8 or len(processed_response) > 100:
             thinking_html = '<div class="thinking-wrapper"><details><summary>Show original response</summary><div class="thinking-steps">'
             thinking_html += f'<div class="thinking-step">{html.escape(full_response)}</div>'
             thinking_html += '</div></details></div>'
+            yield f"{thinking_html}{processed_response}"
             
-            yield f"{thinking_html}{cleaned_response}"
-    
     except Exception as e:
-        # Handle exceptions gracefully
-        error_message = f"I apologize, but I encountered an error while generating a response. Please try rephrasing your question or asking something else."
-        yield error_message
+        error_msg = f"I apologize, but I encountered an error while generating a response. Error details: {str(e)}"
+        yield error_msg
 
 
 # Custom CSS for Plant Wisdom.AI styling
@@ -205,83 +238,35 @@ custom_css = """
     margin-right: 15%;
     border: 1px solid #e0ede0;
     color: #2c3338;
-    transition: opacity 0.5s ease;
 }
 
-.submit-btn {
-    background-color: #2e7d32 !important;
-    color: white !important;
-    border-radius: 8px !important;
-    padding: 12px 24px !important;
-    font-weight: 600 !important;
-    font-size: 16px !important;
-    transition: all 0.3s ease !important;
-    border: none !important;
+.message.assistant p {
+    margin-bottom: 12px;
 }
 
-.submit-btn:hover {
-    background-color: #1b5e20 !important;
-    transform: translateY(-1px) !important;
-    box-shadow: 0 4px 8px rgba(0,0,0,0.1) !important;
+.message.assistant h1 {
+    font-size: 1.4em;
+    margin-top: 0;
+    margin-bottom: 16px;
+    color: #2e7d32;
 }
 
-.submit-btn:active {
-    transform: translateY(0) !important;
+.message.assistant h2 {
+    font-size: 1.2em;
+    margin-top: 16px;
+    margin-bottom: 12px;
+    color: #2e7d32;
 }
 
-.slider-container {
-    background-color: #f8faf8;
-    padding: 20px;
-    border-radius: 12px;
+.message.assistant ul, .message.assistant ol {
     margin: 12px 0;
-    border: 1px solid #e0ede0;
-}
-
-.textbox {
-    border: 2px solid #e0ede0 !important;
-    border-radius: 8px !important;
-    padding: 12px !important;
-    font-size: 16px !important;
-    transition: all 0.3s ease !important;
-    background-color: #ffffff !important;
-}
-
-.textbox:focus {
-    border-color: #2e7d32 !important;
-    outline: none !important;
-    box-shadow: 0 0 0 3px rgba(46,125,50,0.1) !important;
-}
-
-.title {
-    color: #2c3338 !important;
-    font-size: 32px !important;
-    font-weight: 700 !important;
-    margin-bottom: 16px !important;
+    padding-left: 24px;
 }
 
-.description {
-    color: #505a62 !important;
-    font-size: 18px !important;
-    line-height: 1.6 !important;
-    margin-bottom: 24px !important;
-}
-
-.additional-inputs {
-    background-color: #f8faf8;
-    border: 1px solid #e0ede0;
-    border-radius: 12px;
-    padding: 20px;
-    margin-top: 24px;
-}
-
-.chatbot {
-    height: 600px !important;
-    border: 1px solid #e0ede0;
-    border-radius: 12px;
-    background-color: #ffffff;
+.message.assistant li {
+    margin-bottom: 6px;
 }
 
-/* Thinking process styling */
 .thinking-wrapper {
     margin-bottom: 12px;
 }
@@ -415,12 +400,12 @@ Follow any privacy or ethical guidelines, and do not disclose personally identif
 IMPORTANT: If a question has been asked before in the conversation, acknowledge this and either refer back to the previous answer or provide additional context. Do not simply repeat the same answer verbatim.""",
             label="System message"
         ),
-        gr.Slider(minimum=1, maximum=2048, value=1200, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=2.0, value=0.4, step=0.1, label="Temperature"),
+        gr.Slider(minimum=1, maximum=2048, value=1000, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=2.0, value=0.35, step=0.05, label="Temperature"),
         gr.Slider(
             minimum=0.1,
             maximum=1.0,
-            value=0.7,
+            value=0.6,
             step=0.05,
             label="Top-p (nucleus sampling)",
         ),