Update app.py

app.py

@@ -26,20 +26,15 @@ class ChutesClient:
             "Content-Type": "application/json"
         }
         
-        # Prepare the body
+        # Prepare the body, excluding tools since Chutes doesn't support the same format
         body = {
             "model": kwargs.get("model", "openai/gpt-oss-20b"),
             "messages": kwargs.get("messages", []),
-            "stream": False,  # Non-streaming for simplicity
+            "stream": False,
             "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",
@@ -80,7 +75,7 @@ class CreativeAgenticAI:
         self.available_models = {
             "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"},
+            "openai/gpt-oss-20b": {"supports_web_search": False, "supports_browser_search": False, "api": "chutes"},
         }
         
     async def chat(self, message: str, 
@@ -125,7 +120,7 @@ IMPORTANT: When you search the web and find information, you MUST:
                 domain_context = f"\nAvoid searching these domains: {', '.join(exclude_domains)}. Search everywhere else on the web."
             
             search_instruction = ""
-            if search_type == "browser_search":
+            if search_type == "browser_search" and self._supports_browser_search():
                 search_instruction = "\nUse browser search tools to find the most current and relevant information from the web."
             elif search_type == "web_search":
                 search_instruction = "\nUse web search capabilities to find relevant information."
@@ -147,11 +142,7 @@ IMPORTANT: When you search the web and find information, you MUST:
         
         # Build messages
         messages = [{"role": "system", "content": system_prompt}]
-        
-        # Add conversation history (last 10 exchanges)
-        messages.extend(self.conversation_history[-20:])  # Last 10 user-assistant pairs
-        
-        # Add current message with context
+        messages.extend(self.conversation_history[-20:])
         enhanced_message = message
         if include_domains or exclude_domains:
             filter_context = []
@@ -178,20 +169,13 @@ IMPORTANT: When you search the web and find information, you MUST:
             if exclude_domains and exclude_domains[0].strip():
                 params["exclude_domains"] = [domain.strip() for domain in exclude_domains if domain.strip()]
         
-        # Add tools based on search type and model capabilities
+        # Add tools only for Groq models that support browser search
         tools = []
         tool_choice = None
-        
-        if search_type == "browser_search" and self._supports_browser_search():
-            tools = [{"type": "browser_search"}]
-            tool_choice = "required" if force_search else "auto"
-        elif search_type == "auto":
-            if self._supports_browser_search():
-                tools = [{"type": "browser_search"}]
+        if self._supports_browser_search():
+            if search_type in ["browser_search", "auto"] or force_search:
+                tools = [{"type": "browser_search", "function": {"name": "browser_search"}}]
                 tool_choice = "required" if force_search else "auto"
-        elif force_search and self._supports_browser_search():
-            tools = [{"type": "browser_search"}]
-            tool_choice = "required"
         
         if tools:
             params["tools"] = tools
@@ -201,14 +185,17 @@ IMPORTANT: When you search the web and find information, you MUST:
             # Make the API call based on model
             if self.available_models[self.model]["api"] == "chutes":
                 response = await self.chutes_client.chat_completions_create(**params)
+                # Handle Chutes response
+                content = response.get("choices", [{}])[0].get("message", {}).get("content", "No response content")
+                tool_calls = response.get("choices", [{}])[0].get("message", {}).get("tool_calls", None)
             else:
                 params["max_completion_tokens"] = params.pop("max_tokens", None)
                 response = self.groq_client.chat.completions.create(**params)
+                content = response.choices[0].message.content
+                tool_calls = response.choices[0].message.tool_calls if hasattr(response.choices[0].message, "tool_calls") else None
             
-            content = response["choices"][0]["message"]["content"]
-            
-            # Extract tool usage information and enhance it
-            tool_info = self._extract_tool_info(response)
+            # Extract tool usage information
+            tool_info = self._extract_tool_info(response, tool_calls)
             
             # Process content to enhance citations
             processed_content = self._enhance_citations(content, tool_info)
@@ -217,8 +204,7 @@ IMPORTANT: When you search the web and find information, you MUST:
             self.conversation_history.append({"role": "user", "content": message})
             self.conversation_history.append({"role": "assistant", "content": processed_content})
             
-            # Create response object
-            response_data = {
+            return {
                 "content": processed_content,
                 "timestamp": datetime.now().isoformat(),
                 "model": self.model,
@@ -233,8 +219,6 @@ IMPORTANT: When you search the web and find information, you MUST:
                 }
             }
             
-            return response_data
-            
         except Exception as e:
             error_msg = f"Error: {str(e)}"
             self.conversation_history.append({"role": "user", "content": message})
@@ -256,7 +240,7 @@ IMPORTANT: When you search the web and find information, you MUST:
         """Check if current model supports browser search tools"""
         return self.available_models.get(self.model, {}).get("supports_browser_search", False)
     
-    def _extract_tool_info(self, response) -> Dict:
+    def _extract_tool_info(self, response, tool_calls) -> Dict:
         """Extract tool usage information in a JSON serializable format"""
         tool_info = {
             "tools_used": [],
@@ -264,8 +248,8 @@ IMPORTANT: When you search the web and find information, you MUST:
             "sources_found": []
         }
         
-        # Check for executed_tools attribute (compound models)
-        if hasattr(response.choices[0].message, 'executed_tools'):
+        # Handle Groq executed_tools
+        if hasattr(response, 'choices') and hasattr(response.choices[0].message, 'executed_tools'):
             tools = response.choices[0].message.executed_tools
             if tools:
                 for tool in tools:
@@ -273,31 +257,27 @@ IMPORTANT: When you search the web and find information, you MUST:
                         "tool_type": getattr(tool, "type", "unknown"),
                         "tool_name": getattr(tool, "name", "unknown"),
                     }
-                    
                     if hasattr(tool, "input"):
                         tool_input = str(tool.input)
                         tool_dict["input"] = tool_input
                         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
                         urls = self._extract_urls(tool_output)
                         tool_info["sources_found"].extend(urls)
-                    
                     tool_info["tools_used"].append(tool_dict)
         
-        # Check for tool_calls attribute (browser search models)
-        if hasattr(response.choices[0].message, 'tool_calls') and response.choices[0].message.tool_calls:
-            for tool_call in response.choices[0].message.tool_calls:
+        # Handle tool_calls for both APIs
+        if tool_calls:
+            for tool_call in tool_calls:
                 tool_dict = {
-                    "tool_type": tool_call.type if hasattr(tool_call, 'type') else "browser_search",
-                    "tool_name": tool_call.function.name if hasattr(tool_call, 'function') else "browser_search",
-                    "tool_id": tool_call.id if hasattr(tool_call, 'id') else None
+                    "tool_type": getattr(tool_call, "type", "browser_search"),
+                    "tool_name": getattr(tool_call, "function", {}).get("name", "browser_search"),
+                    "tool_id": getattr(tool_call, "id", None)
                 }
-                
-                if hasattr(tool_call, 'function') and hasattr(tool_call.function, 'arguments'):
+                if hasattr(tool_call, "function") and hasattr(tool_call.function, "arguments"):
                     try:
                         args = json.loads(tool_call.function.arguments) if isinstance(tool_call.function.arguments, str) else tool_call.function.arguments
                         tool_dict["arguments"] = args
@@ -305,7 +285,6 @@ IMPORTANT: When you search the web and find information, you MUST:
                             tool_info["search_queries"].append(args["query"])
                     except:
                         tool_dict["arguments"] = str(tool_call.function.arguments)
-                
                 tool_info["tools_used"].append(tool_dict)
         
         return tool_info
@@ -326,7 +305,6 @@ IMPORTANT: When you search the web and find information, you MUST:
             for i, url in enumerate(tool_info["sources_found"][:10], 1):
                 domain = self._extract_domain(url)
                 sources_section += f"{i}. [{domain}]({url})\n"
-            
             content += sources_section
         
         return content
@@ -378,7 +356,6 @@ async def validate_api_keys(groq_api_key: str, chutes_api_key: str, model: str)
         return "❌ Please enter a valid Groq API key for the selected model"
     
     try:
-        # 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(
@@ -394,7 +371,6 @@ async def validate_api_keys(groq_api_key: str, chutes_api_key: str, model: str)
                 max_tokens=10
             )
         
-        # Create AI instance
         ai_instance = CreativeAgenticAI(groq_api_key=groq_api_key, chutes_api_key=chutes_api_key, model=model)
         api_key_status = "Valid ✅"
         
@@ -599,7 +575,7 @@ def create_gradio_app():
         gr.HTML("""
         <div class="header">
             <h1>🤖 NeuroScope-AI Enhanced</h1>
-            <p>Powered by Groq and Chutes Models with Web Search, Browser Search & Agentic Capabilities</p>
+            <p>Powered by Groq and Chutes Models with Web Search and Agentic Capabilities</p>
         </div>
         """)
 
@@ -608,9 +584,9 @@ def create_gradio_app():
                 gr.Markdown("""
                     **Enhanced with Multiple Search Capabilities:**
                     - 🧠 **Intelligence** (Neuro): Advanced AI reasoning across multiple models
-                    - 🔍 **Precision Search** (Scope): Domain filtering + Browser search tools
+                    - 🔍 **Precision Search** (Scope): Domain filtering (Groq models)
                     - 🤖 **AI Capabilities** (AI): Agentic behavior with tool usage
-                    - ⚡ **Dual Search**: Web search (compound models) + Browser search (other models)
+                    - ⚡ **Dual APIs**: Web search (Groq) + Basic chat (Chutes)
                     - 🎯 **Model Flexibility**: Choose the right model for your task
                 """)
                 
@@ -627,10 +603,10 @@ def create_gradio_app():
                     <li><strong>Features:</strong> Include/exclude domains, autonomous web search</li>
                 </ul>
                 
-                <h4>🔍 Browser Search Models (Chutes API)</h4>
+                <h4>💬 Chat Model (Chutes API)</h4>
                 <ul>
-                    <li><strong>openai/gpt-oss-20b:</strong> Fast browser search capabilities</li>
-                    <li><strong>Features:</strong> Real-time browser search, current information</li>
+                    <li><strong>openai/gpt-oss-20b:</strong> Fast conversational capabilities</li>
+                    <li><strong>Features:</strong> General chat, no browser search</li>
                 </ul>
                 </div>
                 
@@ -638,10 +614,9 @@ def create_gradio_app():
                 <h3>🔗 Enhanced Citation System</h3>
                 <p>All models now include:</p>
                 <ul>
-                    <li><strong>Automatic Source Citations:</strong> Clickable links to sources</li>
+                    <li><strong>Automatic Source Citations:</strong> Clickable links to sources (Groq models)</li>
                     <li><strong>Sources Used Section:</strong> Dedicated section showing all websites</li>
                     <li><strong>Search Type Indication:</strong> Shows which search method was used</li>
-                    <li><strong>Tool Usage Display:</strong> Transparent about AI's research process</li>
                 </ul>
                 </div>
                 """)
@@ -669,7 +644,7 @@ def create_gradio_app():
                     ],
                     label="🧠 Model Selection",
                     value="compound-beta",
-                    info="Choose based on your search needs"
+                    info="Choose based on your needs"
                 )
             with gr.Column(scale=1):
                 connect_btn = gr.Button("🔗 Connect", variant="primary", size="lg")
@@ -710,7 +685,7 @@ def create_gradio_app():
         with gr.Accordion("🔍 Search Settings", open=False, elem_id="neuroscope-accordion"):
             with gr.Row():
                 search_type = gr.Radio(
-                    choices=["auto", "web_search", "browser_search", "none"],
+                    choices=["auto", "web_search", "none"],
                     label="🎯 Search Type",
                     value="auto",
                     info="Choose search method (auto = model decides)"
@@ -718,7 +693,7 @@ def create_gradio_app():
                 force_search = gr.Checkbox(
                     label="⚡ Force Search",
                     value=False,
-                    info="Force AI to search even for general questions"
+                    info="Force AI to search even for general questions (Groq models only)"
                 )
             
             model_selection.change(
@@ -788,18 +763,15 @@ def create_gradio_app():
             - Best for: Research papers, academic sources, filtered searches
             - API: Groq
             
-            **For Current Events & Real-Time Information:**
-            - `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
+            - `openai/gpt-oss-20b` for fast conversational responses
+            - Best for: Creative writing, general questions
+            - API: Chutes
             
             **For Programming & Technical Documentation:**
-            - `openai/gpt-oss-20b` with browser search, or compound models with tech domains
+            - `compound-beta` with tech domains
             - Best for: Code help, documentation, technical guides
+            - API: Groq
             """)
         
         with gr.Accordion("🔗 Common Domain Examples", open=False, elem_id="neuroscope-accordion"):
@@ -827,20 +799,19 @@ def create_gradio_app():
             gr.Markdown("""
             ### 🚀 Getting Started
             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:
+            2. **Select a model** - Choose based on your needs:
                - **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
+               - **openai/gpt-oss-20b** (Chutes): For general conversational tasks
+            3. **Configure search settings** - Choose search type and options (Groq models only)
             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 (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
+            - **Dual APIs**: Web search (Groq) + Basic chat (Chutes)
+            - **Smart Citations**: Automatic source linking and citation formatting (Groq models)
+            - **Domain Filtering**: Control which websites the AI searches (Groq models)
             - **Model Flexibility**: Choose the right model and API for your task
-            - **Enhanced Tool Visibility**: See exactly what search tools were used
+            - **Enhanced Tool Visibility**: See search tools used (Groq models)
             
             ### 💡 Tips for Best Results
             
@@ -849,13 +820,8 @@ def create_gradio_app():
             - Include academic domains (*.edu, arxiv.org) for scholarly sources
             - Use "Force Search" for the most current information
             
-            **For Current Events:**
-            - Use openai/gpt-oss-20b (Chutes)
-            - Set search type to "browser_search"
-            - Enable "Force Search" for real-time data
-            
             **For Creative Tasks:**
-            - Any model works well
+            - Use openai/gpt-oss-20b (Chutes) or any model
             - Set search type to "none" for purely creative responses
             - Use higher temperature (0.8-1.0) for more creativity
             """)
@@ -863,7 +829,7 @@ def create_gradio_app():
         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>
+            <h4>🔬 Research & Analysis</h4>
             
             **Compound Model + Domain Filtering (Groq):**
             - Query: "What are the latest breakthroughs in quantum computing?"
@@ -871,48 +837,35 @@ def create_gradio_app():
             - Include domains: "arxiv.org, *.edu, nature.com"
             - Search type: web_search
             
-            **Browser Search Model (Chutes):**
-            - Same query with openai/gpt-oss-20b
-            - Search type: browser_search
-            - Force search: enabled
-            
-            <h4>📰 Current Events (Browser Search Excellence)</h4>
+            <h4>💬 General Knowledge (Chutes):**
+            - Query: "Tell me about quantum computing"
+            - Model: openai/gpt-oss-20b
+            - Search type: none
             
-            **Real-time News:**
-            - Query: "What happened in AI industry this week?"
-            - Model: openai/gpt-oss-20b (Chutes)
-            - Search type: browser_search
-            - Force search: enabled
+            <h4>💻 Programming & Tech</h4>
             
-            **Compare with Web Search:**
-            - Same query with compound-beta (Groq)
-            - Include domains: "reuters.com, bbc.com, techcrunch.com"
-            
-            <h4>💻 Programming & Tech (Model Comparison)</h4>
-            
-            **Technical Documentation:**
+            **Technical Documentation (Groq):**
             - 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 (Chutes) with browser_search
+            - Model: compound-beta
+            - Include domains: "github.com, docs.python.org, stackoverflow.com"
+            - Search type: web_search
+            
+            **Code Help (Chutes):**
+            - Same query with openai/gpt-oss-20b
+            - Search type: none
             
-            <h4>🎨 Creative Tasks (No Search Needed)</h4>
+            <h4>🎨 Creative Tasks</h4>
             - Query: "Write a short story about AI and humans working together"
             - Any model with search_type: "none"
             - Higher temperature (0.8-1.0)
             
-            <h4>📊 Business Analysis (Filtered vs Real-time)</h4>
+            <h4>📊 Business Analysis</h4>
             
-            **Financial Data (Real-time):**
-            - Query: "Current cryptocurrency market trends"
-            - Model: openai/gpt-oss-20b (Chutes)
-            - Search type: browser_search
-            - Force search: enabled
-            
-            **Business Analysis (Filtered):**
+            **Business Analysis (Filtered, Groq):**
             - Query: "Cryptocurrency adoption in enterprise"
-            - Model: compound-beta (Groq)
+            - Model: compound-beta
             - Include domains: "bloomberg.com, wsj.com, harvard.edu"
+            - Search type: web_search
             </div>
             """)
         
@@ -935,29 +888,28 @@ def create_gradio_app():
         
         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:
+            **Enhanced Creative Agentic AI Chat Tool** with dual API support:
             
             ### 🆕 **New in This Version:**
-            - 🔍 **Browser Search Integration**: Real-time search with Chutes API
-            - 🌐 **Dual Search System**: Web search (Groq) + Browser search (Chutes)
+            - 💬 **Chutes API Integration**: For openai/gpt-oss-20b model
+            - 🌐 **Dual API System**: Web search (Groq) + Basic chat (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 and API for your task
+            - ⚡ **Force Search Option**: Make AI search for Groq models  
+            - 🔧 **Enhanced Tool Visibility**: See search tools used (Groq models)
+            - 📊 **Model Comparison Guide**: Choose the right model and API
             
             ### 🏆 **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 (Chutes model)
+            - 🔗 **Automatic Source Citations**: Clickable links to sources (Groq models)
+            - 📚 **Sources Used Section**: Dedicated section for websites (Groq models)
+            - 🌐 **Smart Domain Filtering**: Control search scope (Groq models)
             - 💬 **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 (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
+            - **Chat Model (Chutes)**: openai/gpt-oss-20b (basic conversational capabilities)
+            - **Automatic Search Type Detection**: AI chooses best search method (Groq models)
             - **Enhanced Error Handling**: Robust error management and user feedback
             - **Real-time Status Updates**: Live feedback on model capabilities and search settings
             """)
@@ -968,5 +920,7 @@ def create_gradio_app():
 if __name__ == "__main__":
     app = create_gradio_app()
     app.launch(
-        share=True
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860
     )