Update app.py

app.py

@@ -45,9 +45,9 @@ class CreativeAgenticAI:
         else:
             raise ValueError(f"Invalid provider or missing API key for {provider}")
         
-    async def _chutes_chat_async(self, messages: List[Dict], temperature: float = 0.7, max_tokens: int = 1024, stream: bool = False) -> Dict:
+    async def _chutes_chat_async(self, messages: List[Dict], temperature: float = 0.7, max_tokens: int = 1024) -> str:
         """
-        Async method for Chutes API chat with thinking support
+        Async method for Chutes API chat
         """
         headers = {
             "Authorization": f"Bearer {self.chutes_api_key}",
@@ -57,7 +57,7 @@ class CreativeAgenticAI:
         body = {
             "model": self.model,
             "messages": messages,
-            "stream": stream,
+            "stream": False,  # Set to False for simpler handling
             "max_tokens": max_tokens,
             "temperature": temperature
         }
@@ -69,66 +69,13 @@ class CreativeAgenticAI:
                 json=body
             ) as response:
                 if response.status == 200:
-                    if stream:
-                        thinking_content = ""
-                        final_content = ""
-                        in_thinking = False
-                        
-                        async for line in response.content:
-                            line = line.decode("utf-8").strip()
-                            if line.startswith("data: "):
-                                data = line[6:]
-                                if data == "[DONE]":
-                                    break
-                                try:
-                                    chunk_data = json.loads(data)
-                                    if 'choices' in chunk_data and len(chunk_data['choices']) > 0:
-                                        delta = chunk_data['choices'][0].get('delta', {})
-                                        content = delta.get('content', '')
-                                        
-                                        if content:
-                                            # Check for thinking tags
-                                            if '<thinking>' in content:
-                                                in_thinking = True
-                                                thinking_content += content.replace('<thinking>', '')
-                                            elif '</thinking>' in content:
-                                                thinking_content += content.replace('</thinking>', '')
-                                                in_thinking = False
-                                            elif in_thinking:
-                                                thinking_content += content
-                                            else:
-                                                final_content += content
-                                                
-                                except json.JSONDecodeError:
-                                    continue
-                        
-                        return {
-                            "thinking": thinking_content.strip(),
-                            "content": final_content.strip()
-                        }
-                    else:
-                        result = await response.json()
-                        full_content = result['choices'][0]['message']['content']
-                        
-                        # Extract thinking and final content from non-streaming response
-                        thinking_content = ""
-                        final_content = full_content
-                        
-                        if '<thinking>' in full_content and '</thinking>' in full_content:
-                            start_idx = full_content.find('<thinking>') + len('<thinking>')
-                            end_idx = full_content.find('</thinking>')
-                            thinking_content = full_content[start_idx:end_idx].strip()
-                            final_content = full_content[end_idx + len('</thinking>'):].strip()
-                        
-                        return {
-                            "thinking": thinking_content,
-                            "content": final_content
-                        }
+                    result = await response.json()
+                    return result['choices'][0]['message']['content']
                 else:
                     error_text = await response.text()
                     raise Exception(f"Chutes API error: {response.status} - {error_text}")
 
-    def _chutes_chat_sync(self, messages: List[Dict], temperature: float = 0.7, max_tokens: int = 1024, stream: bool = True) -> Dict:
+    def _chutes_chat_sync(self, messages: List[Dict], temperature: float = 0.7, max_tokens: int = 1024) -> str:
         """
         Synchronous wrapper for Chutes API chat
         """
@@ -139,7 +86,7 @@ class CreativeAgenticAI:
             asyncio.set_event_loop(loop)
         
         return loop.run_until_complete(
-            self._chutes_chat_async(messages, temperature, max_tokens, stream)
+            self._chutes_chat_async(messages, temperature, max_tokens)
         )
         
     def chat(self, message: str, 
@@ -189,13 +136,10 @@ IMPORTANT: When you search the web and find information, you MUST:
                 
                 Your responses should be well-structured, informative, and properly cited with working links."""
             else:
-                # System prompt for Chutes thinking models
-                system_prompt = """You are a creative and intelligent AI assistant with advanced reasoning capabilities. 
-                Think through problems step-by-step, showing your reasoning process clearly.
+                # Simpler system prompt for Chutes (no web search capabilities)
+                system_prompt = """You are a creative and intelligent AI assistant. 
                 Be helpful, creative, and engaging while maintaining accuracy.
-                Your responses should be well-structured, informative, and comprehensive.
-                
-                When solving complex problems, break them down into steps and explain your thinking process."""
+                Your responses should be well-structured, informative, and comprehensive."""
         
         # Build messages
         messages = [{"role": "system", "content": system_prompt}]
@@ -230,7 +174,6 @@ IMPORTANT: When you search the web and find information, you MUST:
             
             return {
                 "content": error_msg,
-                "thinking": "",
                 "timestamp": datetime.now().isoformat(),
                 "model": self.model,
                 "provider": self.provider,
@@ -272,7 +215,6 @@ IMPORTANT: When you search the web and find information, you MUST:
         # Create response object
         return {
             "content": processed_content,
-            "thinking": "",  # Groq doesn't have thinking process
             "timestamp": datetime.now().isoformat(),
             "model": self.model,
             "provider": "groq",
@@ -286,20 +228,16 @@ IMPORTANT: When you search the web and find information, you MUST:
         }
 
     def _handle_chutes_chat(self, messages: List[Dict], temperature: float, max_tokens: int, original_message: str) -> Dict:
-        """Handle Chutes API chat with thinking support"""
-        result = self._chutes_chat_sync(messages, temperature, max_tokens, stream=True)
-        
-        thinking_content = result.get("thinking", "")
-        final_content = result.get("content", "")
+        """Handle Chutes API chat"""
+        content = self._chutes_chat_sync(messages, temperature, max_tokens)
         
-        # Add to conversation history (only store final content)
+        # Add to conversation history
         self.conversation_history.append({"role": "user", "content": original_message})
-        self.conversation_history.append({"role": "assistant", "content": final_content})
+        self.conversation_history.append({"role": "assistant", "content": content})
         
         # Create response object
         return {
-            "content": final_content,
-            "thinking": thinking_content,
+            "content": content,
             "timestamp": datetime.now().isoformat(),
             "model": self.model,
             "provider": "chutes",
@@ -443,15 +381,14 @@ def validate_api_keys(groq_api_key: str, chutes_api_key: str, provider: str, mod
             test_response = test_ai._chutes_chat_sync(
                 [{"role": "user", "content": "Hello"}], 
                 temperature=0.7, 
-                max_tokens=10,
-                stream=False  # Use non-streaming for validation
+                max_tokens=10
             )
             
             # Create AI instance
             ai_instance = CreativeAgenticAI(chutes_api_key=chutes_api_key, provider="chutes", model=model)
             api_key_status["chutes"] = "Valid ✅"
             
-            return f"✅ Chutes API Key Valid! Creative AI with Thinking is ready.\n\n**Provider:** Chutes\n**Model:** {model}\n**Status:** Connected with thinking model capabilities!"
+            return f"✅ Chutes API Key Valid! Creative AI is ready.\n\n**Provider:** Chutes\n**Model:** {model}\n**Status:** Connected (text generation focused)!"
             
         except Exception as e:
             api_key_status["chutes"] = "Invalid ❌"
@@ -477,9 +414,8 @@ def chat_with_ai(message: str,
                 system_prompt: str,
                 temperature: float,
                 max_tokens: int,
-                history: List,
-                show_thinking: bool = True) -> tuple:
-    """Main chat function with thinking support"""
+                history: List) -> tuple:
+    """Main chat function"""
     global ai_instance, current_provider
     
     if not ai_instance:
@@ -508,20 +444,8 @@ def chat_with_ai(message: str,
             max_tokens=int(max_tokens)
         )
         
-        # Format response with thinking (if available and enabled)
-        ai_response = ""
-        
-        # Add thinking section for Chutes models
-        if current_provider == "chutes" and response.get("thinking") and show_thinking:
-            thinking_content = response["thinking"].strip()
-            if thinking_content:
-                ai_response += f"### 🤔 **Model's Thinking Process:**\n\n"
-                ai_response += f"*The model is reasoning through your question...*\n\n"
-                ai_response += f"```thinking\n{thinking_content}\n```\n\n"
-                ai_response += "---\n\n### 💡 **Final Response:**\n\n"
-        
-        # Add main content
-        ai_response += response["content"]
+        # Format response
+        ai_response = response["content"]
         
         # Add enhanced tool usage info (Groq only)
         if response.get("tool_usage") and current_provider == "groq":
@@ -550,15 +474,8 @@ def chat_with_ai(message: str,
             
             ai_response += f"\n\n*🌐 Domain filtering applied: {' | '.join(filter_info)}*"
         
-        # Add provider and thinking info
-        provider_info = f"🤖 Powered by: {current_provider.title()} ({response.get('model', 'unknown')})"
-        if current_provider == "chutes" and response.get("thinking"):
-            if show_thinking:
-                provider_info += " | 🤔 Thinking process shown"
-            else:
-                provider_info += " | 🤔 Thinking process hidden"
-        
-        ai_response += f"\n\n*{provider_info}*"
+        # Add provider info
+        ai_response += f"\n\n*🤖 Powered by: {current_provider.title()} ({response.get('model', 'unknown')})*"
         
         # Add to history
         history.append([message, ai_response])
@@ -629,13 +546,6 @@ def create_gradio_app():
         padding: 15px;
         margin: 10px 0;
     }
-    .thinking-info {
-        background-color: #e2e3e5;
-        border: 1px solid #d6d8db;
-        border-radius: 8px;
-        padding: 15px;
-        margin: 10px 0;
-    }
     #neuroscope-accordion {
         background: linear-gradient(to right, #00ff94, #00b4db); 
         border-radius: 8px;
@@ -647,65 +557,29 @@ def create_gradio_app():
     }
     """
     
-    with gr.Blocks(css=css, title="🤖 Multi-Provider Creative Agentic AI Chat with Thinking", theme=gr.themes.Ocean()) as app:
+    with gr.Blocks(css=css, title="🤖 Multi-Provider Creative Agentic AI Chat", theme=gr.themes.Ocean()) as app:
         
         # Header
         gr.HTML("""
         <div class="header">
-            <h1>🤖 NeuroScope-AI Enhanced with Thinking Models</h1>
-            <p>Multi-Provider AI Chat Tool - Groq's Compound Models & Chutes Thinking Models</p>
+            <h1>🤖 NeuroScope-AI Enhanced</h1>
+            <p>Multi-Provider AI Chat Tool - Powered by Groq's Compound Models & Chutes API</p>
         </div>
         """)
 
         # Provider Selection
         with gr.Group():
-            with gr.Accordion("🤖 Multi-Provider NeuroScope AI with Thinking", open=False, elem_id="neuroscope-accordion"):
+            with gr.Accordion("🤖 Multi-Provider NeuroScope AI", open=False, elem_id="neuroscope-accordion"):
                 gr.Markdown("""
-                    **Enhanced with Multiple AI Providers & Thinking Models:**
-                    - 🧠 Intelligence (Neuro) - Now supports Groq & Chutes Thinking Models
-                    - 🔍 Advanced capabilities (Scope) - Web search with Groq, reasoning traces with Chutes
-                    - 🤖 AI capabilities (AI) - Multiple model options including thinking models
+                    **Enhanced with Multiple AI Providers:**
+                    - 🧠 Intelligence (Neuro) - Now supports Groq & Chutes
+                    - 🔍 Advanced capabilities (Scope) - Web search with Groq, powerful text generation with Chutes
+                    - 🤖 AI capabilities (AI) - Multiple model options
                     - ⚡ Precision & Speed (Scope) - Choose the best provider for your needs
-                    - 🤔 **NEW**: Thinking process visualization for Chutes models
-                """)
-
-        # Thinking Models Info
-        with gr.Group():
-            with gr.Accordion("🤔 About Chutes Thinking Models", open=False, elem_id="neuroscope-accordion"):
-                gr.Markdown("""
-                <div class="thinking-info">
-                <h3>🧠 What are Thinking Models?</h3>
-                <p><strong>Chutes Thinking Models</strong> are advanced AI systems that show their reasoning process before providing the final answer.</p>
-                
-                <h4>🔍 How They Work:</h4>
-                <ul>
-                    <li><strong>Step-by-Step Reasoning:</strong> Models think through problems systematically</li>
-                    <li><strong>Transparent Process:</strong> You can see exactly how the AI reaches its conclusions</li>
-                    <li><strong>Better Accuracy:</strong> The thinking process often leads to more accurate and well-reasoned responses</li>
-                    <li><strong>Educational Value:</strong> Learn from the AI's problem-solving approach</li>
-                </ul>
-                
-                <h4>🎯 Available Thinking Models:</h4>
-                <ul>
-                    <li><strong>openai/gpt-oss-20b:</strong> Large-scale reasoning and analysis</li>
-                    <li><strong>meta-llama/llama-3.1-8b-instruct:</strong> Efficient thinking and instruction following</li>
-                    <li><strong>anthropic/claude-3-sonnet:</strong> Advanced reasoning and creative thinking</li>
-                </ul>
-                
-                <h4>💡 Best For:</h4>
-                <ul>
-                    <li>Complex problem-solving tasks</li>
-                    <li>Mathematical and logical reasoning</li>
-                    <li>Step-by-step analysis</li>
-                    <li>Educational explanations</li>
-                    <li>Creative writing with detailed planning</li>
-                </ul>
-                </div>
                 """)
 
         # Provider and API Key Section
         with gr.Row():
-                        
             with gr.Column():
                 provider_selection = gr.Radio(
                     choices=["groq", "chutes"],
@@ -730,7 +604,8 @@ def create_gradio_app():
                     info="Get your API key from: https://chutes.ai/",
                     visible=False
                 )
-                
+            
+            with gr.Column():
                 model_selection = gr.Radio(
                     choices=get_available_models("groq"),
                     label="🧠 Groq Models",
@@ -738,14 +613,6 @@ def create_gradio_app():
                     info="compound-beta: More powerful | compound-beta-mini: Faster"
                 )
                 
-                # Thinking toggle for Chutes
-                show_thinking = gr.Checkbox(
-                    label="🤔 Show Thinking Process",
-                    value=True,
-                    info="Display the model's reasoning process (Chutes only)",
-                    visible=False
-                )
-                
                 connect_btn = gr.Button("🔗 Connect", variant="primary", size="lg")
         
         # Status display
@@ -765,29 +632,26 @@ def create_gradio_app():
                 - ✅ **Citation System** - Automatic source linking and references
                 - ⚡ **Ultra-fast inference** - Groq's hardware acceleration
                 - 🧠 **Models**: compound-beta, compound-beta-mini
-                - ❌ **No thinking process** - Direct responses without visible reasoning
                 
-                **🎯 Chutes (Thinking Models)**
+                **🎯 Chutes**
                 - ✅ **Multiple Model Access** - Various open-source and commercial models
-                - ✅ **Thinking Process** - See the model's step-by-step reasoning
-                - ✅ **High-quality reasoning** - Better accuracy through visible thinking
-                - ✅ **Educational Value** - Learn from AI's problem-solving approach
+                - ✅ **Cost-effective** - Competitive pricing
+                - ✅ **High-quality text generation** - Excellent for creative writing and analysis
                 - ⚡ **Good performance** - Reliable and fast responses
-                - 🧠 **Models**: GPT-OSS-20B, Llama 3.1, Claude 3 Sonnet (all with thinking)
+                - 🧠 **Models**: GPT-OSS-20B, Llama 3.1, Claude 3 Sonnet, and more
                 - ❌ **No web search** - Relies on training data only
                 
                 **💡 Use Groq when you need:**
                 - Real-time information and web search
                 - Research with source citations
                 - Domain-specific searches
-                - Ultra-fast responses
+                - Agentic AI capabilities
                 
                 **💡 Use Chutes when you need:**
-                - Complex problem-solving with visible reasoning
-                - Educational explanations
-                - Mathematical and logical analysis
-                - Creative planning with detailed thinking
-                - Understanding AI's reasoning process
+                - Pure text generation and analysis
+                - Creative writing tasks
+                - Cost-effective AI access
+                - Variety of model options
                 </div>
                 """)
         
@@ -802,14 +666,15 @@ def create_gradio_app():
                 gr.update(visible=chutes_visible),  # chutes_api_key
                 gr.update(choices=models, value=models[0] if models else None, 
                          label=f"🧠 {provider.title()} Models"),  # model_selection
-                gr.update(visible=chutes_visible),  # show_thinking
-                gr.update(visible=groq_visible), 
+                gr.update(visible=groq_visible),  # domain filtering sections
+                gr.update(visible=groq_visible),  # include domains
+                gr.update(visible=groq_visible)   # exclude domains
             )
         
         provider_selection.change(
             fn=update_provider_ui,
             inputs=[provider_selection],
-            outputs=[groq_api_key, chutes_api_key, model_selection, show_thinking]  
+            outputs=[groq_api_key, chutes_api_key, model_selection]  # We'll add domain filtering updates later
         )
         
         # Connect button functionality
@@ -822,8 +687,8 @@ def create_gradio_app():
         # Main Chat Interface
         with gr.Tab("💬 Chat"):
             chatbot = gr.Chatbot(
-                label="Multi-Provider Creative AI Assistant with Thinking",
-                height=600,
+                label="Multi-Provider Creative AI Assistant",
+                height=500,
                 show_label=True,
                 bubble_full_width=False,
                 show_copy_button=True
@@ -914,7 +779,7 @@ def create_gradio_app():
                 - `nature.com`, `science.org`, `pubmed.ncbi.nlm.nih.gov`, `who.int`
                 """)
 
-        # Update provider UI function with domain filtering and thinking toggle
+        # Update provider UI function with domain filtering
         def update_provider_ui_complete(provider):
             groq_visible = provider == "groq"
             chutes_visible = provider == "chutes"
@@ -925,27 +790,25 @@ def create_gradio_app():
                 gr.update(visible=chutes_visible),  # chutes_api_key
                 gr.update(choices=models, value=models[0] if models else None, 
                          label=f"🧠 {provider.title()} Models"),  # model_selection
-                gr.update(visible=chutes_visible),  # show_thinking
-                gr.update(visible=groq_visible),  
+                gr.update(visible=groq_visible),  # domain_group
             )
         
         provider_selection.change(
             fn=update_provider_ui_complete,
             inputs=[provider_selection],
-            outputs=[groq_api_key, chutes_api_key, model_selection, show_thinking]
+            outputs=[groq_api_key, chutes_api_key, model_selection]
         )
         
-        # IMPORTANT Section with Citation Info and Thinking
+        # IMPORTANT Section with Citation Info
         with gr.Group():
-            with gr.Accordion("📚 IMPORTANT - Citations & Thinking Models!", open=False, elem_id="neuroscope-accordion"):
+            with gr.Accordion("📚 IMPORTANT - Citations & Multi-Provider Features!", open=False, elem_id="neuroscope-accordion"):
                 gr.Markdown("""
                 <div class="citation-info">
-                <h3>🆕 Multi-Provider Enhancement with Thinking Models</h3>
+                <h3>🆕 Multi-Provider Enhancement</h3>
                 <p>This enhanced version now supports both Groq and Chutes AI providers:</p>
                 <ul>
                     <li><strong>🚀 Groq Integration:</strong> Agentic AI with web search, citations, and tool usage</li>
-                    <li><strong>🎯 Chutes Integration:</strong> Multiple thinking models with visible reasoning processes</li>
-                    <li><strong>🤔 Thinking Process:</strong> See step-by-step reasoning from Chutes models</li>
+                    <li><strong>🎯 Chutes Integration:</strong> Multiple AI models for text generation and analysis</li>
                     <li><strong>🔄 Easy Switching:</strong> Switch between providers based on your needs</li>
                     <li><strong>📊 Provider Comparison:</strong> Clear information about each provider's strengths</li>
                 </ul>
@@ -959,14 +822,13 @@ def create_gradio_app():
                     <li><strong>Search Query Tracking:</strong> Shows what queries were made to find information</li>
                 </ul>
                 
-                <h3>🤔 Chutes Thinking Model Features</h3>
+                <h3>🎯 Chutes Model Access</h3>
                 <p>When using Chutes, you get access to:</p>
                 <ul>
-                    <li><strong>Thinking Process Visualization:</strong> See exactly how the AI reasons through problems</li>
-                    <li><strong>Step-by-Step Analysis:</strong> Watch the model break down complex questions</li>
-                    <li><strong>Toggle Thinking Display:</strong> Choose to show or hide the reasoning process</li>
-                    <li><strong>Educational Value:</strong> Learn from AI's problem-solving approaches</li>
-                    <li><strong>Multiple Thinking Models:</strong> Different models with unique reasoning styles</li>
+                    <li><strong>Multiple Models:</strong> GPT-OSS-20B, Llama 3.1, Claude 3 Sonnet</li>
+                    <li><strong>Cost-Effective:</strong> Competitive pricing for high-quality AI</li>
+                    <li><strong>Specialized Tasks:</strong> Optimized for creative writing and analysis</li>
+                    <li><strong>Reliable Performance:</strong> Consistent and fast responses</li>
                 </ul>
                 </div>
                 
@@ -987,20 +849,10 @@ def create_gradio_app():
                   - Useful for **filtering out unreliable or unwanted sources**.
                   - Allows broad search with **targeted exclusions**.
                 
-                ### 🤔 **Thinking Models Behavior (Chutes Only)**
-                
-                **How Thinking Models Work:**
-                  - Models first **reason through the problem** in a thinking section
-                  - You can see the **step-by-step thought process**
-                  - The model then provides its **final polished answer**
-                  - **Toggle thinking display** on/off as needed
-                
-                **Best Use Cases for Thinking Models:**
-                  - Complex mathematical problems
-                  - Logical reasoning tasks
-                  - Creative writing with planning
-                  - Educational explanations
-                  - Problem-solving scenarios
+                **Both Include and Exclude Domains Specified:**
+                  - **Only the include domains** are used for searching.
+                  - **Exclude list is ignored** because the include list already restricts search scope.
+                  - Guarantees AI pulls content **exclusively from whitelisted domains**, regardless of the excluded ones.
                 
                 ---
                 
@@ -1011,23 +863,21 @@ def create_gradio_app():
                   - A **professional business consultant**
                   - A **coding mentor**
                   - A **creative writer**
-                  - A **step-by-step tutor** (especially effective with thinking models)
                   - A **specific character or persona**
                 - Provides full control to **reshape the AI's tone, expertise, and conversational style** with a single prompt.
                 """)
         
         # How to Use Section
-        with gr.Accordion("📖 How to Use This Enhanced Multi-Provider App with Thinking", open=False, elem_id="neuroscope-accordion"):
+        with gr.Accordion("📖 How to Use This Enhanced Multi-Provider App", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             ### 🚀 Getting Started
-            1. **Choose your AI Provider** - Select between Groq (web search + agentic) or Chutes (thinking models)
+            1. **Choose your AI Provider** - Select between Groq (web search + agentic) or Chutes (text generation)
             2. **Enter your API Key** - 
                - Groq: Get one from [console.groq.com](https://console.groq.com/)
                - Chutes: Get one from [chutes.ai](https://chutes.ai/)
             3. **Select a model** - Choose from provider-specific model options
-            4. **Configure thinking display** - For Chutes, decide if you want to see the reasoning process
-            5. **Click Connect** - Validate your key and connect to the AI
-            6. **Start chatting!** - Type your message and get intelligent responses
+            4. **Click Connect** - Validate your key and connect to the AI
+            5. **Start chatting!** - Type your message and get intelligent responses
             
             ### 🎯 Key Features
             **🚀 Groq Features:**
@@ -1037,11 +887,10 @@ def create_gradio_app():
             - **Ultra-fast**: Groq's hardware-accelerated inference
             
             **🎯 Chutes Features:**
-            - **Thinking Models**: See the model's step-by-step reasoning process
-            - **Multiple Models**: Access to GPT-OSS-20B, Llama 3.1, Claude 3 Sonnet
-            - **Educational**: Learn from AI's problem-solving approaches
-            - **Toggle Thinking**: Show/hide the reasoning process as needed
-            - **High Quality**: Excellent reasoning and analysis capabilities
+            - **Multiple Models**: Access to various open-source and commercial models
+            - **Cost-Effective**: Competitive pricing for AI access
+            - **High Quality**: Excellent text generation and analysis
+            - **Model Variety**: Choose the best model for your specific task
             
             **🔄 Universal Features:**
             - **Memory**: Maintains conversation context throughout the session
@@ -1055,83 +904,73 @@ def create_gradio_app():
             - Check the "Sources Used" section for all references
             - Try different domain combinations to see varied results
             
-            **For Chutes (Thinking Models):**
-            - Ask complex, multi-step questions to see rich thinking processes
-            - Use for educational purposes - the thinking is very instructive
-            - Try mathematical problems, logical puzzles, or creative planning tasks
-            - Toggle thinking display based on whether you want to see the process
-            - Different models have different thinking styles - experiment!
+            **For Chutes:**
+            - Experiment with different models for different tasks
+            - Use higher temperatures for creative tasks
+            - Leverage the variety of available models (GPT, Llama, Claude)
+            - Perfect for tasks that don't require real-time information
             
             **General:**
             - Adjust temperature: higher for creativity, lower for precision
             - Try different system prompts for different conversation styles
             - Use the provider that best fits your current task
-            - For learning: use Chutes with thinking display enabled
-            - For research: use Groq with appropriate domain filtering
             """)
         
         # Sample Examples Section
-        with gr.Accordion("🎯 Sample Examples to Test Both Providers & Thinking", open=False, elem_id="neuroscope-accordion"):
+        with gr.Accordion("🎯 Sample Examples to Test Both Providers", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             <div class="example-box">
             <h4>🆚 Provider Comparison Examples</h4>
             <p>Try the same prompts with both providers to see the difference:</p>
             
-            <h4>🤔 Perfect for Thinking Models (Chutes)</h4>
+            <h4>🔬 Research & Analysis</h4>
             <ul>
-                <li><strong>Math & Logic:</strong> "Solve this step by step: If a train travels 120 miles in 2 hours, and then 180 miles in 3 hours, what's the average speed for the entire journey?"</li>
-                <li><strong>Problem Solving:</strong> "I have a budget of $1000 for a home office setup. Help me plan the best allocation across desk, chair, computer, and lighting."</li>
-                <li><strong>Creative Planning:</strong> "Plan a short story about a time traveler who accidentally changes history. Walk through the plot structure."</li>
-                <li><strong>Analysis:</strong> "Compare and contrast the pros and cons of remote work vs office work, considering productivity, collaboration, and work-life balance."</li>
+                <li><strong>Groq (with web search):</strong> "What are the latest breakthroughs in quantum computing in 2024?"</li>
+                <li><strong>Chutes (knowledge-based):</strong> "Explain the fundamental principles of quantum computing"</li>
+                <li><strong>Groq with domains:</strong> Same question with "arxiv.org, *.edu" in include domains</li>
             </ul>
             
-            <h4>🔬 Research & Real-time Info (Groq)</h4>
+            <h4>💻 Programming & Tech</h4>
             <ul>
-                <li><strong>Current Events:</strong> "What are the latest developments in AI research in 2024?"</li>
-                <li><strong>Tech Updates:</strong> "What are the newest features in React 19?"</li>
-                <li><strong>Market Analysis:</strong> "Current trends in cryptocurrency markets with sources"</li>
-                <li><strong>Scientific Updates:</strong> "Recent breakthroughs in quantum computing research"</li>
+                <li><strong>Groq:</strong> "What are the current best practices for React 18 in 2024?"</li>
+                <li><strong>Chutes:</strong> "Write a comprehensive React component with hooks and best practices"</li>
+                <li><strong>Groq filtered:</strong> Same with "github.com, stackoverflow.com" included</li>
             </ul>
             
-            <h4>💻 Programming & Tech (Compare Both)</h4>
+            <h4>🎨 Creative Tasks (Great for Chutes)</h4>
             <ul>
-                <li><strong>Groq:</strong> "What are the current best practices for React 18 in 2024?" (with web search)</li>
-                <li><strong>Chutes:</strong> "Explain how to build a React component with useState, and walk through your reasoning for the design choices"</li>
+                <li>"Write a short story about AI and humans working together"</li>
+                <li>"Create a marketing plan for a sustainable fashion brand"</li>
+                <li>"Generate ideas for a mobile app that helps with mental health"</li>
+                <li>"Write a poem about the beauty of code"</li>
             </ul>
             
-            <h4>🎨 Creative Tasks (Great for Thinking Models)</h4>
+            <h4>📊 Business & Analysis</h4>
             <ul>
-                <li>"Write a marketing strategy for a new eco-friendly product, showing your planning process"</li>
-                <li>"Create a study plan for learning Python in 3 months, explaining your reasoning for each phase"</li>
-                <li>"Design a mobile app concept for meditation, walking through your design thinking"</li>
+                <li><strong>Groq:</strong> "What are the current trends in cryptocurrency markets?"</li>
+                <li><strong>Chutes:</strong> "Analyze the pros and cons of different investment strategies"</li>
+                <li><strong>Groq filtered:</strong> Crypto question with "bloomberg.com, wsj.com" included</li>
             </ul>
             
-            <h4>🧠 Model-Specific Testing (Chutes Thinking)</h4>
+            <h4>🧠 Model-Specific Testing (Chutes)</h4>
             <ul>
-                <li><strong>GPT-OSS-20B:</strong> "Explain quantum entanglement in simple terms, showing your thought process for making it accessible"</li>
-                <li><strong>Llama 3.1:</strong> "Debug this Python code and explain your debugging approach: [code with intentional errors]"</li>
-                <li><strong>Claude 3 Sonnet:</strong> "Analyze this business scenario and provide strategic recommendations, showing your analytical framework"</li>
-            </ul>
-            
-            <h4>📊 Side-by-Side Comparisons</h4>
-            <ul>
-                <li><strong>Same Question, Different Providers:</strong> Ask "How do neural networks work?" to both providers</li>
-                <li><strong>Groq Result:</strong> Fast response with potential web sources and current information</li>
-                <li><strong>Chutes Result:</strong> Detailed thinking process showing how the model breaks down the explanation</li>
+                <li><strong>GPT-OSS-20B:</strong> "Explain complex scientific concepts in simple terms"</li>
+                <li><strong>Llama 3.1:</strong> "Help me debug this Python code and explain the solution"</li>
+                <li><strong>Claude 3 Sonnet:</strong> "Analyze this business scenario and provide strategic recommendations"</li>
             </ul>
             </div>
             """)
         
-        # Event handlers - Updated to include thinking toggle
+        # Event handlers
         send_btn.click(
             fn=chat_with_ai,
-            inputs=[msg, include_domains, exclude_domains, system_prompt, temperature, max_tokens, chatbot, show_thinking],
+            inputs=[msg, include_domains, exclude_domains, system_prompt, temperature, max_tokens, chatbot],
             outputs=[chatbot, msg]
         )
         
         msg.submit(
             fn=chat_with_ai,
-            inputs=[msg, include_domains, exclude_domains, system_prompt, temperature, max_tokens, chatbot, show_thinking],
+            inputs=[msg, include_domains, exclude_domains, system_prompt, temperature, max_tokens, chatbot],
             outputs=[chatbot, msg]
         )
         
@@ -1141,16 +980,16 @@ def create_gradio_app():
         )
         
         # Footer
-        with gr.Accordion("🚀 About This Enhanced Multi-Provider Tool with Thinking", open=True, elem_id="neuroscope-accordion"):
+        with gr.Accordion("🚀 About This Enhanced Multi-Provider Tool", open=True, elem_id="neuroscope-accordion"):
             gr.Markdown("""
-            **Enhanced Multi-Provider Creative Agentic AI Chat Tool** with thinking model support:
+            **Enhanced Multi-Provider Creative Agentic AI Chat Tool** with dual API support:
             
-            **🆕 New Thinking Model Features:**
-            - 🤔 **Thinking Process Visualization**: See step-by-step reasoning from Chutes models
-            - 🧠 **Multiple Thinking Models**: GPT-OSS-20B, Llama 3.1, Claude 3 Sonnet with reasoning
-            - 🔄 **Toggle Thinking Display**: Choose to show or hide the reasoning process
-            - 📚 **Educational Value**: Learn from AI's problem-solving approaches
-            - 🎯 **Better Accuracy**: Thinking process often leads to more accurate responses
+            **🆕 New Multi-Provider Features:**
+            - 🚀 **Groq Integration**: Agentic AI with web search, citations, and tool usage
+            - 🎯 **Chutes Integration**: Multiple AI models for diverse text generation tasks
+            - 🔄 **Provider Switching**: Easy switching between different AI providers
+            - 📊 **Provider Comparison**: Clear information about each provider's strengths
+            - 🧠 **Multiple Models**: Access to various AI models through both providers
             
             **🚀 Groq Features:**
             - 🔗 **Automatic Source Citations**: Every response includes clickable links to sources
@@ -1162,11 +1001,10 @@ def create_gradio_app():
             - 🧠 Advanced AI reasoning with tool usage
             
             **🎯 Chutes Features:**
-            - 🤖 **Multiple Thinking Models**: Various AI models with visible reasoning
+            - 🤖 **Multiple AI Models**: GPT-OSS-20B, Llama 3.1, Claude 3 Sonnet
             - 💰 **Cost-Effective**: Competitive pricing for AI access
-            - 🎨 **Creative Excellence**: Optimized for reasoning and analysis tasks
-            - ⚡ **Reliable Performance**: Consistent and thoughtful responses
-            - 📖 **Learning Tool**: Perfect for understanding AI reasoning
+            - 🎨 **Creative Excellence**: Optimized for writing and analysis tasks
+            - ⚡ **Reliable Performance**: Consistent and fast responses
             
             **🔄 Universal Features:**
             - 💬 Conversational memory and context
@@ -1176,14 +1014,7 @@ def create_gradio_app():
             
             **💡 Choose Your Provider:**
             - **Use Groq** when you need real-time information, web search, and citations
-            - **Use Chutes** when you want to see the thinking process, need complex reasoning, or want educational explanations
-            - **Toggle thinking display** in Chutes to customize your experience
-            
-            **🎓 Perfect for:**
-            - Students learning problem-solving approaches
-            - Developers wanting to understand AI reasoning
-            - Researchers needing both current information (Groq) and deep analysis (Chutes)
-            - Anyone curious about how AI thinks through problems
+            - **Use Chutes** when you need pure text generation, creative writing, or cost-effective AI access
             """)
     
     return app