Delete app.py

app.py

@@ -1,589 +0,0 @@
-import os
-import json
-import time
-import gradio as gr
-from datetime import datetime
-from typing import List, Dict, Any, Optional, Union
-import threading
-
-# Import Groq
-from groq import Groq
-
-class CreativeAgenticAI:
-    """
-    Creative Agentic AI Chat Tool using Groq's compound models
-    """
-    
-    def __init__(self, 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 ('compound-beta' or 'compound-beta-mini')
-        """
-        self.api_key = api_key
-        if not self.api_key:
-            raise ValueError("No API key provided")
-        
-        self.client = Groq(api_key=self.api_key)
-        self.model = model
-        self.conversation_history = []
-        
-    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) -> Dict:
-        """
-        Send a message to the AI and get a response
-        
-        Args:
-            message: User's message
-            include_domains: List of domains to include for web search
-            exclude_domains: List of domains to exclude from web search
-            system_prompt: Custom system prompt
-            temperature: Model temperature (0.0-2.0)
-            max_tokens: Maximum tokens in response
-            
-        Returns:
-            AI response with metadata
-        """
-        # Default system prompt if none provided
-        if not system_prompt:
-            system_prompt = """You are a creative and intelligent AI assistant with agentic capabilities. 
-            You can search the web, analyze information, and provide comprehensive responses. 
-            Be helpful, creative, and engaging while maintaining accuracy."""
-        
-        # 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
-        messages.append({"role": "user", "content": message})
-        
-        # Set up API parameters
-        params = {
-            "messages": messages,
-            "model": self.model,
-            "temperature": temperature,
-            "max_tokens": max_tokens
-        }
-        
-        # Add domain filtering if specified
-        if include_domains and include_domains[0].strip():
-            params["include_domains"] = [domain.strip() for domain in include_domains if domain.strip()]
-        if exclude_domains and exclude_domains[0].strip():
-            params["exclude_domains"] = [domain.strip() for domain in exclude_domains if domain.strip()]
-        
-        try:
-            # Make the API call
-            response = self.client.chat.completions.create(**params)
-            content = response.choices[0].message.content
-            
-            # Extract tool usage information
-            tool_info = self._extract_tool_info(response)
-            
-            # Add to conversation history
-            self.conversation_history.append({"role": "user", "content": message})
-            self.conversation_history.append({"role": "assistant", "content": content})
-            
-            # Create response object
-            response_data = {
-                "content": content,
-                "timestamp": datetime.now().isoformat(),
-                "model": self.model,
-                "tool_usage": tool_info,
-                "parameters": {
-                    "temperature": temperature,
-                    "max_tokens": max_tokens,
-                    "include_domains": include_domains,
-                    "exclude_domains": exclude_domains
-                }
-            }
-            
-            return response_data
-            
-        except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            self.conversation_history.append({"role": "user", "content": message})
-            self.conversation_history.append({"role": "assistant", "content": error_msg})
-            
-            return {
-                "content": error_msg,
-                "timestamp": datetime.now().isoformat(),
-                "model": self.model,
-                "tool_usage": None,
-                "error": str(e)
-            }
-    
-    def _extract_tool_info(self, response) -> Dict:
-        """Extract tool usage information in a JSON serializable format"""
-        tool_info = None
-        if hasattr(response.choices[0].message, 'executed_tools'):
-            tools = response.choices[0].message.executed_tools
-            if tools:
-                tool_info = []
-                for tool in tools:
-                    tool_dict = {
-                        "tool_type": getattr(tool, "type", "unknown"),
-                        "tool_name": getattr(tool, "name", "unknown"),
-                    }
-                    if hasattr(tool, "input"):
-                        tool_dict["input"] = str(tool.input)
-                    if hasattr(tool, "output"):
-                        tool_dict["output"] = str(tool.output)
-                    tool_info.append(tool_dict)
-        return tool_info
-    
-    def clear_history(self):
-        """Clear conversation history"""
-        self.conversation_history = []
-    
-    def get_history_summary(self) -> str:
-        """Get a summary of conversation history"""
-        if not self.conversation_history:
-            return "No conversation history"
-        
-        user_messages = [msg for msg in self.conversation_history if msg["role"] == "user"]
-        assistant_messages = [msg for msg in self.conversation_history if msg["role"] == "assistant"]
-        
-        return f"Conversation: {len(user_messages)} user messages, {len(assistant_messages)} assistant responses"
-
-# Global variables
-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"""
-    global ai_instance, api_key_status
-    
-    if not api_key or len(api_key.strip()) < 10:
-        api_key_status = "Invalid ❌"
-        return "❌ Please enter a valid API key (should be longer than 10 characters)"
-    
-    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_tokens=10
-        )
-        
-        # Create AI instance
-        ai_instance = CreativeAgenticAI(api_key=api_key, model=model)
-        api_key_status = "Valid ✅"
-        
-        return f"✅ API Key Valid! Creative Agentic AI is ready.\n\n**Model:** {model}\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."
-
-def update_model(model: str) -> str:
-    """Update the model selection"""
-    global ai_instance
-    
-    if ai_instance:
-        ai_instance.model = model
-        return f"✅ Model updated to: **{model}**"
-    else:
-        return "⚠️ Please set your API key first"
-
-def chat_with_ai(message: str, 
-                include_domains: str, 
-                exclude_domains: str,
-                system_prompt: str,
-                temperature: float,
-                max_tokens: int,
-                history: List) -> tuple:
-    """Main chat function"""
-    global ai_instance
-    
-    if not ai_instance:
-        error_msg = "⚠️ Please set your Groq API key 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(
-            message=message,
-            include_domains=include_list if include_list else None,
-            exclude_domains=exclude_list if exclude_list else None,
-            system_prompt=system_prompt if system_prompt.strip() else None,
-            temperature=temperature,
-            max_tokens=int(max_tokens)
-        )
-        
-        # Format response
-        ai_response = response["content"]
-        
-        # Add tool usage info if available
-        if response.get("tool_usage"):
-            ai_response += f"\n\n*🔧 Tools used: {len(response['tool_usage'])} tool(s)*"
-        
-        # Add to history
-        history.append([message, ai_response])
-        
-        return history, ""
-        
-    except Exception as e:
-        error_msg = f"❌ Error: {str(e)}"
-        history.append([message, error_msg])
-        return history, ""
-
-def clear_chat_history():
-    """Clear the chat history"""
-    global ai_instance
-    if ai_instance:
-        ai_instance.clear_history()
-    return []
-
-def create_gradio_app():
-    """Create the main Gradio application"""
-    
-    # Custom CSS for better styling
-    css = """
-    .container {
-        max-width: 1200px;
-        margin: 0 auto;
-    }
-    .header {
-        text-align: center;
-        background: linear-gradient(to right, #00ff94, #00b4db);
-        color: white;
-        padding: 20px;
-        border-radius: 10px;
-        margin-bottom: 20px;
-    }
-    .status-box {
-        background-color: #f8f9fa;
-        border: 1px solid #dee2e6;
-        border-radius: 8px;
-        padding: 15px;
-        margin: 10px 0;
-    }
-    .example-box {
-        background-color: #e8f4fd;
-        border-left: 4px solid #007bff;
-        padding: 15px;
-        margin: 10px 0;
-        border-radius: 0 8px 8px 0;
-    }
-    .domain-info {
-        background-color: #fff3cd;
-        border: 1px solid #ffeaa7;
-        border-radius: 8px;
-        padding: 15px;
-        margin: 10px 0;
-    }
-    #neuroscope-accordion {
-        background: linear-gradient(to right, #00ff94, #00b4db); 
-        border-radius: 8px;
-    }
-    """
-    
-    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</h1>
-            <p>Powered by Groq's Compound Models with Web Search & Agentic Capabilities</p>
-        </div>
-        """)
-
-        # NeuroScope AI Section
-        with gr.Group():
-            with gr.Accordion("🤖 NeuroScope AI", open=False, elem_id="neuroscope-accordion"):
-                gr.Markdown("""
-                    - 🧠 Intelligence (Neuro)
-                    - 🔍 Domain filtering (Scope)
-                    - 🤖 AI capabilities (AI)
-                    - ⚡ Precision (Scope implies focused, targeted results)
-                """)
-        with gr.Group():
-            with gr.Accordion("📚 IMPORTANT !!!", open=False, elem_id="neuroscope-accordion"):
-                gr.Markdown("""                
-                ### 🔍 **Web Search Behavior in NeuroScope AI**
-                
-                **No Domains Specified:**
-                
-                  - AI operates with **unrestricted web search capabilities**.
-                  - Compound models autonomously search the **entire internet** for the most relevant and up-to-date information.
-                  - AI has complete freedom to use its **agentic tools** and browse **any website** it finds useful.
-                
-                **Include Domains Specified (e.g., `arxiv.org`, `*.edu`):**
-                
-                  - AI is restricted to search **only the specified domains**.
-                  - Acts as a **strict whitelist**, making the AI **laser-focused** on your chosen sources.
-                  - Ensures information is sourced from **preferred or authoritative domains** (e.g., academic or research-focused).
-                
-                **Exclude Domains Specified (e.g., `wikipedia.org`, `reddit.com`):**
-                
-                  - AI searches the entire web **except the listed domains**.
-                  - Useful for **filtering out unreliable or unwanted sources**.
-                  - Allows broad search with **targeted exclusions**.
-                
-                **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.
-                
-                ---
-                
-                ### 🎭 **Custom System Prompt Feature**
-                
-                Allows complete override of the AI’s **default personality and behavior**.
-                You can redefine the AI to act as:
-                
-                  - A **professional business consultant**
-                  - A **coding mentor**
-                  - A **creative writer**
-                  - A **specific character or persona**
-                - Provides full control to **reshape the AI’s tone, expertise, and conversational style** with a single prompt.
-                """)
-        
-        # API Key Section
-        with gr.Row():
-            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/"
-            )
-            model_selection = gr.Radio(
-                choices=["compound-beta", "compound-beta-mini"],
-                label="🧠 Model Selection",
-                value="compound-beta",
-                info="compound-beta: More powerful | compound-beta-mini: Faster"
-            )
-            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],
-            outputs=[status_display]
-        )
-        
-        model_selection.change(
-            fn=update_model,
-            inputs=[model_selection],
-            outputs=[status_display]
-        )
-        
-        # Main Chat Interface
-        with gr.Tab("💬 Chat"):
-            chatbot = gr.Chatbot(
-                label="Creative AI Assistant",
-                height=500,
-                show_label=True,
-                bubble_full_width=False,
-                show_copy_button=True
-            )
-            
-            with gr.Row():
-                msg = gr.Textbox(
-                    label="Your Message",
-                    placeholder="Type your message here...",
-                    lines=3
-                )
-                with gr.Column():
-                    send_btn = gr.Button("📤 Send", variant="primary")
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-            
-        # Advanced Settings
-        with gr.Accordion("⚙️ Advanced Settings", open=False, elem_id="neuroscope-accordion"):
-            with gr.Row():
-                temperature = gr.Slider(
-                    minimum=0.0,
-                    maximum=2.0,
-                    value=0.7,
-                    step=0.1,
-                    label="🌡️ Temperature",
-                    info="Higher = more creative, Lower = more focused"
-                )
-                max_tokens = gr.Slider(
-                    minimum=100,
-                    maximum=4000,
-                    value=1024,
-                    step=100,
-                    label="📝 Max Tokens",
-                    info="Maximum length of response"
-                )
-                
-            system_prompt = gr.Textbox(
-                label="🎭 Custom System Prompt",
-                placeholder="Override the default system prompt...",
-                lines=2,
-                info="Leave empty to use default creative assistant prompt"
-            )    
-        
-        # Domain Filtering Section
-        with gr.Accordion("🌐 Domain Filtering (for Web Search)", open=False, elem_id="neuroscope-accordion"):
-            gr.Markdown("""
-            <div class="domain-info">
-            <h4>🔍 Domain Filtering Guide</h4>
-            <p>Control which websites the AI can search when answering your questions:</p>
-            <ul>
-                <li><strong>Include Domains:</strong> Only search these domains (comma-separated)</li>
-                <li><strong>Exclude Domains:</strong> Never search these domains (comma-separated)</li>
-                <li><strong>Examples:</strong> arxiv.org, *.edu, github.com, stackoverflow.com</li>
-                <li><strong>Wildcards:</strong> Use *.edu for all educational domains</li>
-            </ul>
-            </div>
-            """)
-            
-            with gr.Row():
-                include_domains = gr.Textbox(
-                    label="✅ Include Domains (comma-separated)",
-                    placeholder="arxiv.org, *.edu, github.com, stackoverflow.com",
-                    info="Only search these domains"
-                )
-                exclude_domains = gr.Textbox(
-                    label="❌ Exclude Domains (comma-separated)", 
-                    placeholder="wikipedia.org, reddit.com, twitter.com",
-                    info="Never search these domains"
-                )
-        with gr.Accordion("🔗 Common Domain Examples", open=False, elem_id="neuroscope-accordion"):
-            gr.Markdown("""
-            **Academic & Research:**
-            - `arxiv.org`, `*.edu`, `scholar.google.com`, `researchgate.net`
-            
-            **Technology & Programming:**
-            - `github.com`, `stackoverflow.com`, `docs.python.org`, `developer.mozilla.org`
-            
-            **News & Media:**
-            - `reuters.com`, `bbc.com`, `npr.org`, `apnews.com`
-            
-            **Business & Finance:**
-            - `bloomberg.com`, `wsj.com`, `nasdaq.com`, `sec.gov`
-            
-            **Science & Medicine:**
-            - `nature.com`, `science.org`, `pubmed.ncbi.nlm.nih.gov`, `who.int`
-            """)
-        
-        # How to Use Section
-        with gr.Accordion("📖 How to Use This 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/)
-            2. **Select a model** - Choose between compound-beta (powerful) or compound-beta-mini (fast)
-            3. **Click Connect** - Validate your key and connect to the AI
-            4. **Start chatting!** - Type your message and get intelligent responses
-            
-            ### 🎯 Key Features
-            - **Agentic AI**: The AI can use tools and search the web autonomously
-            - **Domain Filtering**: Control which websites the AI searches
-            - **Creative Responses**: Optimized for engaging and helpful conversations
-            - **Memory**: Maintains conversation context throughout the session
-            - **Customizable**: Adjust temperature, tokens, and system prompts
-            
-            ### 💡 Tips for Best Results
-            - Be specific in your questions for better responses
-            - Use domain filtering for specialized research
-            - Adjust temperature: higher for creativity, lower for precision
-            - Try different system prompts for different conversation styles
-            """)
-        
-        # Sample Examples Section
-        with gr.Accordion("🎯 Sample Examples to Test", open=False, elem_id="neuroscope-accordion"):
-            gr.Markdown("""
-            <div class="example-box">
-            <h4>🔬 Research & Analysis</h4>
-            <ul>
-                <li>"What are the latest breakthroughs in quantum computing?"</li>
-                <li>"Compare different machine learning frameworks for beginners"</li>
-                <li>"Analyze the current state of renewable energy technology"</li>
-            </ul>
-            
-            <h4>💻 Programming & Tech</h4>
-            <ul>
-                <li>"Write a Python script to analyze CSV data and create visualizations"</li>
-                <li>"Explain the differences between React and Vue.js with examples"</li>
-                <li>"Help me debug this JavaScript code: [paste your code]"</li>
-            </ul>
-            
-            <h4>🎨 Creative Tasks</h4>
-            <ul>
-                <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>
-            </ul>
-            
-            <h4>📊 Business & Analysis</h4>
-            <ul>
-                <li>"What are the current trends in the cryptocurrency market?"</li>
-                <li>"Analyze the pros and cons of remote work for startups"</li>
-                <li>"Create a business plan outline for a food delivery service"</li>
-            </ul>
-            
-            <h4>🌐 With Domain Filtering</h4>
-            <ul>
-                <li>Include "*.edu, arxiv.org": "Latest research on climate change solutions"</li>
-                <li>Include "github.com, stackoverflow.com": "Best practices for API development"</li>
-                <li>Exclude "wikipedia.org, reddit.com": "Professional analysis of market trends"</li>
-            </ul>
-            </div>
-            """)
-        
-        # Event handlers
-        send_btn.click(
-            fn=chat_with_ai,
-            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],
-            outputs=[chatbot, msg]
-        )
-        
-        clear_btn.click(
-            fn=clear_chat_history,
-            outputs=[chatbot]
-        )
-        
-        # Footer
-        with gr.Accordion("🚀 About This Tool", open=True, elem_id="neuroscope-accordion"):
-            gr.Markdown("""
-            A Creative Agentic AI Chat Tool leverages Groq's powerful compound models to provide intelligent, 
-            context-aware responses with web search capabilities. Perfect for research, programming help, 
-            creative writing, and complex problem-solving.
-            
-            **Features:**
-            - 🔍 Web search with domain filtering
-            - 🧠 Advanced AI reasoning with tool usage
-            - 💬 Conversational memory and context
-            - ⚙️ Customizable parameters and prompts
-            - 🎨 Creative and analytical capabilities
-            """)
-    
-    return app
-
-# Main execution
-if __name__ == "__main__":
-    app = create_gradio_app()
-    app.launch(
-        share=True
-    )