Update app.py

app.py

@@ -6,46 +6,91 @@ from datetime import datetime
 from typing import List, Dict, Any, Optional, Union
 import threading
 import re
+import aiohttp
+import asyncio
 
 # Import Groq
 from groq import Groq
 
+class ChutesClient:
+    """Client for interacting with Chutes API"""
+    
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://llm.chutes.ai/v1"
+        
+    async def chat_completions_create(self, **kwargs) -> Dict:
+        """Make async request to Chutes chat completions endpoint"""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        # Prepare the body
+        body = {
+            "model": kwargs.get("model", "openai/gpt-oss-20b"),
+            "messages": kwargs.get("messages", []),
+            "stream": False,  # Non-streaming for simplicity
+            "max_tokens": kwargs.get("max_tokens", 1024),
+            "temperature": kwargs.get("temperature", 0.7)
+        }
+        
+        # Add tool calls if present
+        if "tools" in kwargs and kwargs["tools"]:
+            body["tools"] = kwargs["tools"]
+            body["tool_choice"] = kwargs.get("tool_choice", "auto")
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=body
+            ) as response:
+                if response.status != 200:
+                    raise Exception(f"Chutes API error: {await response.text()}")
+                return await response.json()
+
 class CreativeAgenticAI:
     """
-    Creative Agentic AI Chat Tool using Groq's models with browser search and compound models
+    Creative Agentic AI Chat Tool using Groq and Chutes models with browser search and compound models
     """
     
-    def __init__(self, api_key: str, model: str = "compound-beta"):
+    def __init__(self, groq_api_key: str, chutes_api_key: str, model: str = "compound-beta"):
         """
         Initialize the Creative Agentic AI system.
         
         Args:
-            api_key: Groq API key
-            model: Which Groq model to use
+            groq_api_key: Groq API key
+            chutes_api_key: Chutes API key
+            model: Which model to use
         """
-        self.api_key = api_key
-        if not self.api_key:
-            raise ValueError("No API key provided")
+        self.groq_api_key = groq_api_key
+        self.chutes_api_key = chutes_api_key
+        if not self.groq_api_key and model != "openai/gpt-oss-20b":
+            raise ValueError("No Groq API key provided")
+        if not self.chutes_api_key and model == "openai/gpt-oss-20b":
+            raise ValueError("No Chutes API key provided")
         
-        self.client = Groq(api_key=self.api_key)
         self.model = model
+        self.groq_client = Groq(api_key=self.groq_api_key) if self.groq_api_key else None
+        self.chutes_client = ChutesClient(api_key=self.chutes_api_key) if self.chutes_api_key else None
         self.conversation_history = []
         
         # Available models with their capabilities
         self.available_models = {
-            "compound-beta": {"supports_web_search": True, "supports_browser_search": False},
-            "compound-beta-mini": {"supports_web_search": True, "supports_browser_search": False},
-            "openai/gpt-oss-20b": {"supports_web_search": False, "supports_browser_search": True},
+            "compound-beta": {"supports_web_search": True, "supports_browser_search": False, "api": "groq"},
+            "compound-beta-mini": {"supports_web_search": True, "supports_browser_search": False, "api": "groq"},
+            "openai/gpt-oss-20b": {"supports_web_search": False, "supports_browser_search": True, "api": "chutes"},
         }
         
-    def chat(self, message: str, 
-             include_domains: List[str] = None,
-             exclude_domains: List[str] = None,
-             system_prompt: str = None,
-             temperature: float = 0.7,
-             max_tokens: int = 1024,
-             search_type: str = "auto",
-             force_search: bool = False) -> Dict:
+    async def chat(self, message: str, 
+                  include_domains: List[str] = None,
+                  exclude_domains: List[str] = None,
+                  system_prompt: str = None,
+                  temperature: float = 0.7,
+                  max_tokens: int = 1024,
+                  search_type: str = "auto",
+                  force_search: bool = False) -> Dict:
         """
         Send a message to the AI and get a response with flexible search options
         
@@ -123,8 +168,7 @@ IMPORTANT: When you search the web and find information, you MUST:
             "messages": messages,
             "model": self.model,
             "temperature": temperature,
-            "max_completion_tokens": max_tokens if self._supports_browser_search() else None,
-            "max_tokens": max_tokens if not self._supports_browser_search() else None,
+            "max_tokens": max_tokens,
         }
         
         # Add domain filtering for compound models
@@ -154,9 +198,14 @@ IMPORTANT: When you search the web and find information, you MUST:
             params["tool_choice"] = tool_choice
         
         try:
-            # Make the API call
-            response = self.client.chat.completions.create(**params)
-            content = response.choices[0].message.content
+            # Make the API call based on model
+            if self.available_models[self.model]["api"] == "chutes":
+                response = await self.chutes_client.chat_completions_create(**params)
+            else:
+                params["max_completion_tokens"] = params.pop("max_tokens", None)
+                response = self.groq_client.chat.completions.create(**params)
+            
+            content = response["choices"][0]["message"]["content"]
             
             # Extract tool usage information and enhance it
             tool_info = self._extract_tool_info(response)
@@ -225,18 +274,15 @@ IMPORTANT: When you search the web and find information, you MUST:
                         "tool_name": getattr(tool, "name", "unknown"),
                     }
                     
-                    # Extract search queries and results
                     if hasattr(tool, "input"):
                         tool_input = str(tool.input)
                         tool_dict["input"] = tool_input
-                        # Try to extract search query
                         if "search" in tool_dict["tool_name"].lower():
                             tool_info["search_queries"].append(tool_input)
                     
                     if hasattr(tool, "output"):
                         tool_output = str(tool.output)
                         tool_dict["output"] = tool_output
-                        # Try to extract URLs from output
                         urls = self._extract_urls(tool_output)
                         tool_info["sources_found"].extend(urls)
                     
@@ -268,18 +314,16 @@ IMPORTANT: When you search the web and find information, you MUST:
         """Extract URLs from text"""
         url_pattern = r'https?://[^\s<>"]{2,}'
         urls = re.findall(url_pattern, text)
-        return list(set(urls))  # Remove duplicates
+        return list(set(urls))
     
     def _enhance_citations(self, content: str, tool_info: Dict) -> str:
         """Enhance content with better citation formatting"""
         if not tool_info or not tool_info.get("sources_found"):
             return content
         
-        # Add sources section if not already present
         if "Sources Used:" not in content and "sources:" not in content.lower():
             sources_section = "\n\n---\n\n### 📚 Sources Used:\n"
-            for i, url in enumerate(tool_info["sources_found"][:10], 1):  # Limit to 10 sources
-                # Try to extract domain name for better formatting
+            for i, url in enumerate(tool_info["sources_found"][:10], 1):
                 domain = self._extract_domain(url)
                 sources_section += f"{i}. [{domain}]({url})\n"
             
@@ -292,7 +336,6 @@ IMPORTANT: When you search the web and find information, you MUST:
         try:
             if url.startswith(('http://', 'https://')):
                 domain = url.split('/')[2]
-                # Remove www. prefix if present
                 if domain.startswith('www.'):
                     domain = domain[4:]
                 return domain
@@ -322,27 +365,37 @@ IMPORTANT: When you search the web and find information, you MUST:
 ai_instance = None
 api_key_status = "Not Set"
 
-def validate_api_key(api_key: str, model: str) -> str:
-    """Validate Groq API key and initialize AI instance"""
+async def validate_api_keys(groq_api_key: str, chutes_api_key: str, model: str) -> str:
+    """Validate both Groq and Chutes API keys and initialize AI instance"""
     global ai_instance, api_key_status
     
-    if not api_key or len(api_key.strip()) < 10:
+    if model == "openai/gpt-oss-20b" and not chutes_api_key:
         api_key_status = "Invalid ❌"
-        return "❌ Please enter a valid API key (should be longer than 10 characters)"
+        return "❌ Please enter a valid Chutes API key for the selected model"
+    
+    if model in ["compound-beta", "compound-beta-mini"] and not groq_api_key:
+        api_key_status = "Invalid ❌"
+        return "❌ Please enter a valid Groq API key for the selected model"
     
     try:
-        # Test the API key
-        client = Groq(api_key=api_key)
-        # Try a simple request to validate
-        test_response = client.chat.completions.create(
-            messages=[{"role": "user", "content": "Hello"}],
-            model=model,
-            max_completion_tokens=10 if model in ["openai/gpt-oss-20b", "llama-3.3-70b-versatile", "llama-3.1-70b-versatile", "mixtral-8x7b-32768"] else None,
-            max_tokens=10 if model in ["compound-beta", "compound-beta-mini"] else None
-        )
+        # Test API keys based on model
+        if model == "openai/gpt-oss-20b":
+            chutes_client = ChutesClient(api_key=chutes_api_key)
+            await chutes_client.chat_completions_create(
+                messages=[{"role": "user", "content": "Hello"}],
+                model=model,
+                max_tokens=10
+            )
+        else:
+            groq_client = Groq(api_key=groq_api_key)
+            groq_client.chat.completions.create(
+                messages=[{"role": "user", "content": "Hello"}],
+                model=model,
+                max_tokens=10
+            )
         
         # Create AI instance
-        ai_instance = CreativeAgenticAI(api_key=api_key, model=model)
+        ai_instance = CreativeAgenticAI(groq_api_key=groq_api_key, chutes_api_key=chutes_api_key, model=model)
         api_key_status = "Valid ✅"
         
         model_info = ai_instance.get_model_info()
@@ -354,12 +407,12 @@ def validate_api_key(api_key: str, model: str) -> str:
         
         cap_text = " | ".join(capabilities) if capabilities else "💬 Chat Only"
         
-        return f"✅ API Key Valid! NeuroScope AI is ready.\n\n**Model:** {model}\n**Capabilities:** {cap_text}\n**Status:** Connected and ready for chat!"
+        return f"✅ API Keys Valid! NeuroScope AI is ready.\n\n**Model:** {model}\n**Capabilities:** {cap_text}\n**API:** {model_info.get('api', 'unknown')}\n**Status:** Connected and ready for chat!"
         
     except Exception as e:
         api_key_status = "Invalid ❌"
         ai_instance = None
-        return f"❌ Error validating API key: {str(e)}\n\nPlease check your API key and try again."
+        return f"❌ Error validating API key: {str(e)}\n\nPlease check your API keys and try again."
 
 def update_model(model: str) -> str:
     """Update the model selection"""
@@ -375,9 +428,9 @@ def update_model(model: str) -> str:
             capabilities.append("🔍 Browser Search Tools")
         
         cap_text = " | ".join(capabilities) if capabilities else "💬 Chat Only"
-        return f"✅ Model updated to: **{model}**\n**Capabilities:** {cap_text}"
+        return f"✅ Model updated to: **{model}**\n**Capabilities:** {cap_text}\n**API:** {model_info.get('api', 'unknown')}"
     else:
-        return "⚠️ Please set your API key first"
+        return "⚠️ Please set your API keys first"
 
 def get_search_options(model: str) -> gr.update:
     """Get available search options based on model"""
@@ -392,39 +445,35 @@ def get_search_options(model: str) -> gr.update:
     if model_info.get("supports_browser_search"):
         options.extend(["browser_search", "auto"])
     
-    # Remove duplicates while preserving order
     options = list(dict.fromkeys(options))
-    
     default_value = "auto" if "auto" in options else "none"
     return gr.update(choices=options, value=default_value)
 
-def chat_with_ai(message: str, 
-                include_domains: str, 
-                exclude_domains: str,
-                system_prompt: str,
-                temperature: float,
-                max_tokens: int,
-                search_type: str,
-                force_search: bool,
-                history: List) -> tuple:
+async def chat_with_ai(message: str, 
+                      include_domains: str, 
+                      exclude_domains: str,
+                      system_prompt: str,
+                      temperature: float,
+                      max_tokens: int,
+                      search_type: str,
+                      force_search: bool,
+                      history: List) -> tuple:
     """Main chat function"""
     global ai_instance
     
     if not ai_instance:
-        error_msg = "⚠️ Please set your Groq API key first!"
+        error_msg = "⚠️ Please set your API keys first!"
         history.append([message, error_msg])
         return history, ""
     
     if not message.strip():
         return history, ""
     
-    # Process domain lists
     include_list = [d.strip() for d in include_domains.split(",")] if include_domains.strip() else []
     exclude_list = [d.strip() for d in exclude_domains.split(",")] if exclude_domains.strip() else []
     
     try:
-        # Get AI response
-        response = ai_instance.chat(
+        response = await ai_instance.chat(
             message=message,
             include_domains=include_list if include_list else None,
             exclude_domains=exclude_list if exclude_list else None,
@@ -435,10 +484,8 @@ def chat_with_ai(message: str,
             force_search=force_search
         )
         
-        # Format response
         ai_response = response["content"]
         
-        # Add enhanced tool usage info
         if response.get("tool_usage"):
             tool_info = response["tool_usage"]
             tool_summary = []
@@ -457,7 +504,6 @@ def chat_with_ai(message: str,
             if tool_summary:
                 ai_response += f"\n\n*{' | '.join(tool_summary)}*"
         
-        # Add search type info
         search_info = []
         if response.get("search_type_used") and response["search_type_used"] != "none":
             search_info.append(f"🔍 Search type: {response['search_type_used']}")
@@ -465,7 +511,6 @@ def chat_with_ai(message: str,
         if force_search:
             search_info.append("⚡ Forced search enabled")
         
-        # Add domain filtering info
         if include_list or exclude_list:
             filter_info = []
             if include_list:
@@ -477,7 +522,6 @@ def chat_with_ai(message: str,
         if search_info:
             ai_response += f"\n\n*🌐 Search settings: {' | '.join(search_info)}*"
         
-        # Add to history
         history.append([message, ai_response])
         
         return history, ""
@@ -497,7 +541,6 @@ def clear_chat_history():
 def create_gradio_app():
     """Create the main Gradio application"""
     
-    # Custom CSS for better styling
     css = """
     .container {
         max-width: 1200px;
@@ -553,15 +596,13 @@ def create_gradio_app():
     """
     
     with gr.Blocks(css=css, title="🤖 Creative Agentic AI Chat", theme=gr.themes.Ocean()) as app:
-        # Header
         gr.HTML("""
         <div class="header">
             <h1>🤖 NeuroScope-AI Enhanced</h1>
-            <p>Powered by Groq's Models with Web Search, Browser Search & Agentic Capabilities</p>
+            <p>Powered by Groq and Chutes Models with Web Search, Browser Search & Agentic Capabilities</p>
         </div>
         """)
 
-        # NeuroScope AI Section
         with gr.Group():
             with gr.Accordion("🤖 NeuroScope AI Enhanced", open=False, elem_id="neuroscope-accordion"):
                 gr.Markdown("""
@@ -573,26 +614,22 @@ def create_gradio_app():
                     - 🎯 **Model Flexibility**: Choose the right model for your task
                 """)
                 
-        # IMPORTANT Section with Enhanced Search Info
         with gr.Group():
             with gr.Accordion("🔍 IMPORTANT - Enhanced Search Capabilities!", open=True, elem_id="neuroscope-accordion"):
                 gr.Markdown("""
                 <div class="search-info">
                 <h3>🚀 NEW: Multiple Search Types Available!</h3>
                 
-                <h4>🌐 Web Search Models (Compound Models)</h4>
+                <h4>🌐 Web Search Models (Groq API)</h4>
                 <ul>
                     <li><strong>compound-beta:</strong> Most powerful with domain filtering</li>
                     <li><strong>compound-beta-mini:</strong> Faster with domain filtering</li>
                     <li><strong>Features:</strong> Include/exclude domains, autonomous web search</li>
                 </ul>
                 
-                <h4>🔍 Browser Search Models (Tool-based Models)</h4>
+                <h4>🔍 Browser Search Models (Chutes API)</h4>
                 <ul>
                     <li><strong>openai/gpt-oss-20b:</strong> Fast browser search capabilities</li>
-                    <li><strong>llama-3.3-70b-versatile:</strong> Advanced reasoning with search</li>
-                    <li><strong>llama-3.1-70b-versatile:</strong> Reliable with search tools</li>
-                    <li><strong>mixtral-8x7b-32768:</strong> Large context with search</li>
                     <li><strong>Features:</strong> Real-time browser search, current information</li>
                 </ul>
                 </div>
@@ -609,15 +646,20 @@ def create_gradio_app():
                 </div>
                 """)
         
-        # API Key and Model Selection Section
         with gr.Row():
             with gr.Column(scale=2):
-                api_key = gr.Textbox(
+                groq_api_key = gr.Textbox(
                     label="🔑 Groq API Key",
                     placeholder="Enter your Groq API key here...",
                     type="password",
                     info="Get your API key from: https://console.groq.com/"
                 )
+                chutes_api_key = gr.Textbox(
+                    label="🔑 Chutes API Key",
+                    placeholder="Enter your Chutes API key here...",
+                    type="password",
+                    info="Required for openai/gpt-oss-20b model"
+                )
             with gr.Column(scale=2):
                 model_selection = gr.Radio(
                     choices=[
@@ -632,13 +674,11 @@ def create_gradio_app():
             with gr.Column(scale=1):
                 connect_btn = gr.Button("🔗 Connect", variant="primary", size="lg")
         
-        # Status display
         status_display = gr.Markdown("### 📊 Status: Not connected", elem_classes=["status-box"])
         
-        # Connect button functionality
         connect_btn.click(
-            fn=validate_api_key,
-            inputs=[api_key, model_selection],
+            fn=validate_api_keys,
+            inputs=[groq_api_key, chutes_api_key, model_selection],
             outputs=[status_display]
         )
         
@@ -648,7 +688,6 @@ def create_gradio_app():
             outputs=[status_display]
         )
         
-        # Main Chat Interface
         with gr.Tab("💬 Chat"):
             chatbot = gr.Chatbot(
                 label="Creative AI Assistant with Enhanced Search",
@@ -668,7 +707,6 @@ def create_gradio_app():
                     send_btn = gr.Button("📤 Send", variant="primary")
                     clear_btn = gr.Button("🗑️ Clear", variant="secondary")
             
-        # Search Settings
         with gr.Accordion("🔍 Search Settings", open=False, elem_id="neuroscope-accordion"):
             with gr.Row():
                 search_type = gr.Radio(
@@ -683,14 +721,12 @@ def create_gradio_app():
                     info="Force AI to search even for general questions"
                 )
             
-            # Update search options when model changes
             model_selection.change(
                 fn=get_search_options,
                 inputs=[model_selection],
                 outputs=[search_type]
             )
             
-        # Domain Filtering Section (only for web search models)
         with gr.Accordion("🌐 Domain Filtering (Web Search Models Only)", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             <div class="domain-info">
@@ -717,7 +753,6 @@ def create_gradio_app():
                     info="Never search these domains (compound models only)"
                 )
         
-        # Advanced Settings
         with gr.Accordion("⚙️ Advanced Settings", open=False, elem_id="neuroscope-accordion"):
             with gr.Row():
                 temperature = gr.Slider(
@@ -744,7 +779,6 @@ def create_gradio_app():
                 info="Leave empty to use default creative assistant prompt with enhanced citations"
             )
         
-        # Model Comparison Section
         with gr.Accordion("📊 Model Comparison Guide", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             ### 🔍 Choose Your Model Based on Task:
@@ -752,21 +786,22 @@ def create_gradio_app():
             **For Academic Research & Domain-Specific Search:**
             - `compound-beta` or `compound-beta-mini` with include domains (*.edu, arxiv.org)
             - Best for: Research papers, academic sources, filtered searches
+            - API: Groq
             
             **For Current Events & Real-Time Information:**
-            - `openai/gpt-oss-20b` or `llama-3.3-70b-versatile` with browser search
+            - `openai/gpt-oss-20b` with browser search
             - Best for: News, current events, real-time data
+            - API: Chutes
             
             **For General Knowledge & Creative Tasks:**
             - Any model with search type = "auto" or "none"
             - Best for: Creative writing, general questions, analysis
             
             **For Programming & Technical Documentation:**
-            - `llama-3.1-70b-versatile` with browser search, or compound models with tech domains
+            - `openai/gpt-oss-20b` with browser search, or compound models with tech domains
             - Best for: Code help, documentation, technical guides
             """)
         
-        # Domain Examples Section
         with gr.Accordion("🔗 Common Domain Examples", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             **Academic & Research:**
@@ -788,24 +823,23 @@ def create_gradio_app():
             - `*.gov`, `*.org`, `un.org`, `worldbank.org`, `imf.org`
             """)
         
-        # How to Use Section
         with gr.Accordion("📖 How to Use This Enhanced App", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             ### 🚀 Getting Started
-            1. **Enter your Groq API Key** - Get one from [console.groq.com](https://console.groq.com/)
+            1. **Enter your API Keys** - Groq from [console.groq.com](https://console.groq.com/), Chutes for openai/gpt-oss-20b
             2. **Select a model** - Choose based on your search needs:
-               - **Compound models**: For web search with domain filtering
-               - **Tool-based models**: For browser search with real-time data
+               - **Compound models** (Groq): For web search with domain filtering
+               - **openai/gpt-oss-20b** (Chutes): For browser search with real-time data
             3. **Configure search settings** - Choose search type and options
-            4. **Click Connect** - Validate your key and connect to the AI
+            4. **Click Connect** - Validate your keys and connect to the AI
             5. **Start chatting!** - Type your message and get intelligent responses with citations
             
             ### 🎯 Key Features
-            - **Dual Search Capabilities**: Web search + Browser search depending on model
+            - **Dual Search Capabilities**: Web search (compound) + Browser search (Chutes)
             - **Smart Citations**: Automatic source linking and citation formatting
             - **Domain Filtering**: Control which websites the AI searches (compound models)
             - **Real-time Search**: Get current information with browser search tools
-            - **Model Flexibility**: Choose the right model for your specific task
+            - **Model Flexibility**: Choose the right model and API for your task
             - **Enhanced Tool Visibility**: See exactly what search tools were used
             
             ### 💡 Tips for Best Results
@@ -816,7 +850,7 @@ def create_gradio_app():
             - Use "Force Search" for the most current information
             
             **For Current Events:**
-            - Use tool-based models (openai/gpt-oss-20b)
+            - Use openai/gpt-oss-20b (Chutes)
             - Set search type to "browser_search"
             - Enable "Force Search" for real-time data
             
@@ -826,19 +860,18 @@ def create_gradio_app():
             - Use higher temperature (0.8-1.0) for more creativity
             """)
         
-        # Sample Examples Section
         with gr.Accordion("🎯 Sample Examples to Test Enhanced Search", open=False, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             <div class="example-box">
             <h4>🔬 Research & Analysis (Test Different Models)</h4>
             
-            **Compound Model + Domain Filtering:**
+            **Compound Model + Domain Filtering (Groq):**
             - Query: "What are the latest breakthroughs in quantum computing?"
             - Model: compound-beta
             - Include domains: "arxiv.org, *.edu, nature.com"
             - Search type: web_search
             
-            **Browser Search Model:**
+            **Browser Search Model (Chutes):**
             - Same query with openai/gpt-oss-20b
             - Search type: browser_search
             - Force search: enabled
@@ -847,12 +880,12 @@ def create_gradio_app():
             
             **Real-time News:**
             - Query: "What happened in AI industry this week?"
-            - Model: openai/gpt-oss-20b
+            - Model: openai/gpt-oss-20b (Chutes)
             - Search type: browser_search
             - Force search: enabled
             
             **Compare with Web Search:**
-            - Same query with compound-beta
+            - Same query with compound-beta (Groq)
             - Include domains: "reuters.com, bbc.com, techcrunch.com"
             
             <h4>💻 Programming & Tech (Model Comparison)</h4>
@@ -861,7 +894,7 @@ def create_gradio_app():
             - Query: "How to implement OAuth 2.0 in Python Flask?"
             - Try with both model types:
               - compound-beta with "github.com, docs.python.org, stackoverflow.com"
-              - openai/gpt-oss-20b with browser_search
+              - openai/gpt-oss-20b (Chutes) with browser_search
             
             <h4>🎨 Creative Tasks (No Search Needed)</h4>
             - Query: "Write a short story about AI and humans working together"
@@ -872,18 +905,17 @@ def create_gradio_app():
             
             **Financial Data (Real-time):**
             - Query: "Current cryptocurrency market trends"
-            - Model: openai/gpt-oss-20b
+            - Model: openai/gpt-oss-20b (Chutes)
             - Search type: browser_search
             - Force search: enabled
             
             **Business Analysis (Filtered):**
             - Query: "Cryptocurrency adoption in enterprise"
-            - Model: compound-beta
+            - Model: compound-beta (Groq)
             - Include domains: "bloomberg.com, wsj.com, harvard.edu"
             </div>
             """)
         
-        # Event handlers
         send_btn.click(
             fn=chat_with_ai,
             inputs=[msg, include_domains, exclude_domains, system_prompt, temperature, max_tokens, search_type, force_search, chatbot],
@@ -901,31 +933,30 @@ def create_gradio_app():
             outputs=[chatbot]
         )
         
-        # Footer
         with gr.Accordion("🚀 About This Enhanced NeuroScope AI", open=True, elem_id="neuroscope-accordion"):
             gr.Markdown("""
             **Enhanced Creative Agentic AI Chat Tool** with dual search capabilities:
             
             ### 🆕 **New in This Version:**
-            - 🔍 **Browser Search Integration**: Real-time search with tool-based models
-            - 🌐 **Dual Search System**: Web search (compound) + Browser search (tool-based)
-            - 🎯 **Model Flexibility**: 6 different models for different tasks
+            - 🔍 **Browser Search Integration**: Real-time search with Chutes API
+            - 🌐 **Dual Search System**: Web search (Groq) + Browser search (Chutes)
+            - 🎯 **Model Flexibility**: Multiple models across two APIs
             - ⚡ **Force Search Option**: Make AI search even for general questions  
             - 🔧 **Enhanced Tool Visibility**: See exactly what search tools were used
-            - 📊 **Model Comparison Guide**: Choose the right model for your task
+            - 📊 **Model Comparison Guide**: Choose the right model and API for your task
             
             ### 🏆 **Core Features:**
             - 🔗 **Automatic Source Citations**: Every response includes clickable links to sources
             - 📚 **Sources Used Section**: Dedicated section showing all websites referenced  
             - 🌐 **Smart Domain Filtering**: Control search scope (compound models)
-            - 🔍 **Real-time Browser Search**: Current information (tool-based models)
+            - 🔍 **Real-time Browser Search**: Current information (Chutes model)
             - 💬 **Conversational Memory**: Maintains context throughout the session
             - ⚙️ **Full Customization**: Adjust all parameters and prompts
             - 🎨 **Creative & Analytical**: Optimized for both creative and research tasks
             
             ### 🛠️ **Technical Details:**
-            - **Compound Models**: compound-beta, compound-beta-mini (web search + domain filtering)
-            - **Tool-based Models**: openai/gpt-oss-20b, llama models, mixtral (browser search tools)
+            - **Compound Models (Groq)**: compound-beta, compound-beta-mini (web search + domain filtering)
+            - **Tool-based Model (Chutes)**: openai/gpt-oss-20b (browser search tools)
             - **Automatic Search Type Detection**: AI chooses best search method
             - **Enhanced Error Handling**: Robust error management and user feedback
             - **Real-time Status Updates**: Live feedback on model capabilities and search settings
@@ -937,7 +968,5 @@ def create_gradio_app():
 if __name__ == "__main__":
     app = create_gradio_app()
     app.launch(
-        share=True,
-        server_name="0.0.0.0",
-        server_port=7860
+        share=True
     )