Create v1.txt

v1.txt

@@ -0,0 +1,846 @@
+import os
+import json
+import time
+import gradio as gr
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional, Union
+
+# Import Groq - we'll install it in requirements.txt
+from groq import Groq
+
+class PersonalAIResearchAssistant:
+    """
+    Personal AI Research Assistant (PARA) using Groq's compound models with agentic capabilities.
+    """
+    
+    def __init__(self, api_key: str, 
+                 knowledge_base_path: str = "knowledge_base.json",
+                 model: str = "compound-beta"):
+        """
+        Initialize the PARA system.
+        
+        Args:
+            api_key: Groq API key
+            knowledge_base_path: Path to store persistent knowledge
+            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.knowledge_base_path = Path(knowledge_base_path)
+        self.knowledge_base = self._load_knowledge_base()
+        
+    def _load_knowledge_base(self) -> Dict:
+        """Load existing knowledge base or create a new one"""
+        if self.knowledge_base_path.exists():
+            with open(self.knowledge_base_path, 'r') as f:
+                return json.load(f)
+        else:
+            # Initialize with empty collections
+            kb = {
+                "topics": {},
+                "research_digests": [],
+                "code_analyses": [],
+                "concept_connections": [],
+                "metadata": {
+                    "created_at": datetime.now().isoformat(),
+                    "last_updated": datetime.now().isoformat()
+                }
+            }
+            self._save_knowledge_base(kb)
+            return kb
+    
+    def _save_knowledge_base(self, kb: Dict = None) -> None:
+        """Save the knowledge base to disk"""
+        if kb is None:
+            kb = self.knowledge_base
+            
+        # Update metadata
+        kb["metadata"]["last_updated"] = datetime.now().isoformat()
+        
+        with open(self.knowledge_base_path, 'w') as f:
+            json.dump(kb, f, indent=2)
+    
+    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'):
+            # Convert ExecutedTool objects to dictionaries
+            tools = response.choices[0].message.executed_tools
+            if tools:
+                tool_info = []
+                for tool in tools:
+                    # Extract only serializable data
+                    tool_dict = {
+                        "tool_type": getattr(tool, "type", "unknown"),
+                        "tool_name": getattr(tool, "name", "unknown"),
+                    }
+                    # Add any other relevant attributes in a serializable form
+                    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 research_digest(self, topic: str, 
+                        include_domains: List[str] = None,
+                        exclude_domains: List[str] = None,
+                        max_results: int = 5) -> Dict:
+        """
+        Generate a research digest on a specific topic
+        
+        Args:
+            topic: The research topic to investigate
+            include_domains: List of domains to include (e.g., ["arxiv.org", "*.edu"])
+            exclude_domains: List of domains to exclude
+            max_results: Maximum number of key findings to include
+            
+        Returns:
+            Research digest including key findings and references
+        """
+        # Build the prompt
+        prompt = f"""Generate a research digest on the topic: {topic}
+        
+        Please find the most recent and relevant information, focusing on:
+        1. Key findings or breakthroughs
+        2. Current trends and methodologies
+        3. Influential researchers or organizations
+        4. Practical applications
+        
+        Structure your response as a concise summary with {max_results} key points maximum.
+        Include source information where possible.
+        """
+        
+        # Set up API parameters
+        params = {
+            "messages": [
+                {"role": "system", "content": "You are a research assistant tasked with finding and summarizing the latest information on specific topics."},
+                {"role": "user", "content": prompt}
+            ],
+            "model": self.model
+        }
+        
+        # Add domain filtering if specified
+        if include_domains and include_domains[0].strip():
+            params["include_domains"] = [domain.strip() for domain in include_domains]
+        if exclude_domains and exclude_domains[0].strip():
+            params["exclude_domains"] = [domain.strip() for domain in exclude_domains]
+            
+        # Make the API call
+        response = self.client.chat.completions.create(**params)
+        content = response.choices[0].message.content
+        
+        # Extract tool usage information in a serializable format
+        tool_info = self._extract_tool_info(response)
+        
+        # Create digest entry
+        digest = {
+            "topic": topic,
+            "timestamp": datetime.now().isoformat(),
+            "content": content,
+            "tool_usage": tool_info,
+            "parameters": {
+                "include_domains": include_domains,
+                "exclude_domains": exclude_domains,
+            }
+        }
+        
+        # Add to knowledge base
+        self.knowledge_base["research_digests"].append(digest)
+        
+        # Update topic entry in knowledge base
+        if topic not in self.knowledge_base["topics"]:
+            self.knowledge_base["topics"][topic] = {
+                "first_researched": datetime.now().isoformat(),
+                "research_count": 1,
+                "related_topics": []
+            }
+        else:
+            self.knowledge_base["topics"][topic]["research_count"] += 1
+            self.knowledge_base["topics"][topic]["last_researched"] = datetime.now().isoformat()
+        
+        # Save updated knowledge base
+        self._save_knowledge_base()
+        
+        return digest
+    
+    def evaluate_code(self, code_snippet: str, language: str = "python", 
+                     analysis_type: str = "full") -> Dict:
+        """
+        Evaluate a code snippet for issues and suggest improvements
+        
+        Args:
+            code_snippet: The code to evaluate
+            language: Programming language of the code
+            analysis_type: Type of analysis to perform ('full', 'security', 'performance', 'style')
+            
+        Returns:
+            Analysis results including issues and suggestions
+        """
+        # Build the prompt
+        prompt = f"""Analyze the following {language} code:
+        
+        ```{language}
+        {code_snippet}
+        ```
+        
+        Please perform a {analysis_type} analysis, including:
+        1. Identifying any bugs or potential issues
+        2. Security vulnerabilities (if applicable)
+        3. Performance considerations
+        4. Style and best practices
+        5. Suggested improvements
+        
+        If possible, execute the code to verify functionality.
+        """
+        
+        # Make the API call
+        response = self.client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": f"You are a code analysis expert specializing in {language}."},
+                {"role": "user", "content": prompt}
+            ],
+            model=self.model
+        )
+        
+        content = response.choices[0].message.content
+        
+        # Extract tool usage information in a serializable format
+        tool_info = self._extract_tool_info(response)
+        
+        # Create code analysis entry
+        analysis = {
+            "code_snippet": code_snippet,
+            "language": language,
+            "analysis_type": analysis_type,
+            "timestamp": datetime.now().isoformat(),
+            "content": content,
+            "tool_usage": tool_info
+        }
+        
+        # Add to knowledge base
+        self.knowledge_base["code_analyses"].append(analysis)
+        self._save_knowledge_base()
+        
+        return analysis
+    
+    def connect_concepts(self, concept_a: str, concept_b: str) -> Dict:
+        """
+        Identify connections between two seemingly different concepts
+        
+        Args:
+            concept_a: First concept
+            concept_b: Second concept
+            
+        Returns:
+            Analysis of connections between the concepts
+        """
+        # Build the prompt
+        prompt = f"""Explore the connections between these two concepts:
+        
+        Concept A: {concept_a}
+        Concept B: {concept_b}
+        
+        Please identify:
+        1. Direct connections or shared principles
+        2. Historical influences between them
+        3. Common applications or use cases
+        4. How insights from one field might benefit the other
+        5. Potential for innovative combinations
+        
+        Search for the most up-to-date information that might connect these concepts.
+        """
+        
+        # Make the API call
+        response = self.client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a cross-disciplinary research assistant specialized in finding connections between different fields and concepts."},
+                {"role": "user", "content": prompt}
+            ],
+            model=self.model
+        )
+        
+        content = response.choices[0].message.content
+        
+        # Extract tool usage information in a serializable format
+        tool_info = self._extract_tool_info(response)
+        
+        # Create connection entry
+        connection = {
+            "concept_a": concept_a,
+            "concept_b": concept_b,
+            "timestamp": datetime.now().isoformat(),
+            "content": content,
+            "tool_usage": tool_info
+        }
+        
+        # Add to knowledge base
+        self.knowledge_base["concept_connections"].append(connection)
+        
+        # Update topic entries
+        for concept in [concept_a, concept_b]:
+            if concept not in self.knowledge_base["topics"]:
+                self.knowledge_base["topics"][concept] = {
+                    "first_researched": datetime.now().isoformat(),
+                    "research_count": 1,
+                    "related_topics": [concept_a if concept == concept_b else concept_b]
+                }
+            else:
+                if concept_a if concept == concept_b else concept_b not in self.knowledge_base["topics"][concept]["related_topics"]:
+                    self.knowledge_base["topics"][concept]["related_topics"].append(
+                        concept_a if concept == concept_b else concept_b
+                    )
+        
+        self._save_knowledge_base()
+        
+        return connection
+    
+    def ask_knowledge_base(self, query: str) -> Dict:
+        """
+        Query the accumulated knowledge base
+        
+        Args:
+            query: Question about topics in the knowledge base
+            
+        Returns:
+            Response based on accumulated knowledge
+        """
+        # Create a temporary context from the knowledge base
+        context = {
+            "topics_researched": list(self.knowledge_base["topics"].keys()),
+            "research_count": len(self.knowledge_base["research_digests"]),
+            "code_analyses_count": len(self.knowledge_base["code_analyses"]),
+            "concept_connections_count": len(self.knowledge_base["concept_connections"]),
+            "last_updated": self.knowledge_base["metadata"]["last_updated"]
+        }
+        
+        # Add recent research digests (limited to keep context manageable)
+        recent_digests = self.knowledge_base["research_digests"][-3:] if self.knowledge_base["research_digests"] else []
+        context["recent_research"] = recent_digests
+        
+        # Build the prompt
+        prompt = f"""Query: {query}
+        
+        Please answer based on the following knowledge base context:
+        {json.dumps(context, indent=2)}
+        
+        If the knowledge base doesn't contain relevant information, please indicate this and suggest how we might research this topic.
+        """
+        
+        # Make the API call
+        response = self.client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a research assistant with access to a personal knowledge base. Answer questions based on the accumulated knowledge."},
+                {"role": "user", "content": prompt}
+            ],
+            model=self.model
+        )
+        
+        content = response.choices[0].message.content
+        
+        return {
+            "query": query,
+            "timestamp": datetime.now().isoformat(),
+            "response": content,
+            "knowledge_base_state": context
+        }
+
+    def generate_weekly_report(self) -> Dict:
+        """
+        Generate a weekly summary of research and insights
+        
+        Returns:
+            Weekly report of activity and key findings
+        """
+        # Get weekly statistics
+        one_week_ago = datetime.now().isoformat()  # Simplified, should subtract 7 days
+        
+        # Count activities in the last week
+        recent_research = [d for d in self.knowledge_base["research_digests"] 
+                          if d["timestamp"] > one_week_ago]
+        recent_code = [c for c in self.knowledge_base["code_analyses"] 
+                      if c["timestamp"] > one_week_ago]
+        recent_connections = [c for c in self.knowledge_base["concept_connections"] 
+                             if c["timestamp"] > one_week_ago]
+        
+        # Build context for the report
+        context = {
+            "period": "weekly",
+            "research_count": len(recent_research),
+            "code_analyses_count": len(recent_code),
+            "concept_connections_count": len(recent_connections),
+            "topics_explored": list(set([r["topic"] for r in recent_research])),
+            "recent_research": recent_research[:3],  # Include only top 3
+            "recent_connections": recent_connections[:3]
+        }
+        
+        # Build the prompt
+        prompt = f"""Generate a weekly research summary based on the following activity:
+        
+        {json.dumps(context, indent=2)}
+        
+        Please include:
+        1. Overview of research activity
+        2. Key findings and insights
+        3. Emerging patterns or trends
+        4. Suggestions for further exploration
+        
+        Format as a concise weekly report.
+        """
+        
+        # Make the API call
+        response = self.client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a research assistant generating a weekly summary of research activities and findings."},
+                {"role": "user", "content": prompt}
+            ],
+            model=self.model
+        )
+        
+        content = response.choices[0].message.content
+        
+        report = {
+            "type": "weekly_report",
+            "timestamp": datetime.now().isoformat(),
+            "content": content,
+            "stats": context
+        }
+        
+        return report
+    
+    def get_kb_stats(self):
+        """Get statistics about the knowledge base"""
+        return {
+            "topics_count": len(self.knowledge_base["topics"]),
+            "research_count": len(self.knowledge_base["research_digests"]),
+            "code_analyses_count": len(self.knowledge_base["code_analyses"]),
+            "concept_connections_count": len(self.knowledge_base["concept_connections"]),
+            "created": self.knowledge_base["metadata"]["created_at"],
+            "last_updated": self.knowledge_base["metadata"]["last_updated"],
+            "topics": list(self.knowledge_base["topics"].keys())
+        }
+
+# Global variables for the Gradio app
+para_instance = None
+api_key_status = "Not Set"
+
+# Helper functions for Gradio
+def validate_api_key(api_key):
+    """Validate Groq API key"""
+    global para_instance, api_key_status
+    
+    if not api_key or len(api_key.strip()) < 10:
+        return "❌ Please enter a valid API key"
+    
+    try:
+        # Try to initialize with minimal actions
+        client = Groq(api_key=api_key)
+        # Create PARA instance
+        para_instance = PersonalAIResearchAssistant(
+            api_key=api_key,
+            knowledge_base_path="para_knowledge.json"
+        )
+        api_key_status = "Valid ✅"
+        
+        # Get KB stats
+        stats = para_instance.get_kb_stats()
+        kb_info = f"**Knowledge Base Stats:**\n\n" \
+                 f"- Topics: {stats['topics_count']}\n" \
+                 f"- Research Digests: {stats['research_count']}\n" \
+                 f"- Code Analyses: {stats['code_analyses_count']}\n" \
+                 f"- Concept Connections: {stats['concept_connections_count']}\n" \
+                 f"- Last Updated: {stats['last_updated'][:10]}\n\n" \
+                 f"**Topics Explored:** {', '.join(stats['topics'][:10])}" + \
+                 ("..." if len(stats['topics']) > 10 else "")
+        
+        return f"✅ API Key Valid! PARA is ready.\n\n{kb_info}"
+    except Exception as e:
+        api_key_status = "Invalid ❌"
+        para_instance = None
+        return f"❌ Error: {str(e)}"
+
+def check_api_key():
+    """Check if API key is set"""
+    if para_instance is None:
+        return "Please set your Groq API key first"
+    return None
+
+def update_model_selection(model_choice):
+    """Update model selection"""
+    global para_instance
+    
+    if para_instance:
+        para_instance.model = model_choice
+        return f"Model updated to: {model_choice}"
+    else:
+        return "Set API key first"
+
+def research_topic(topic, include_domains, exclude_domains):
+    """Research a topic with domain filters"""
+    # Check if API key is set
+    check_result = check_api_key()
+    if check_result:
+        return check_result
+    
+    if not topic:
+        return "Please enter a topic to research"
+    
+    # Process domain lists
+    include_list = [d.strip() for d in include_domains.split(",")] if include_domains else []
+    exclude_list = [d.strip() for d in exclude_domains.split(",")] if exclude_domains else []
+    
+    try:
+        # Perform research
+        result = para_instance.research_digest(
+            topic=topic,
+            include_domains=include_list if include_list and include_list[0] else None,
+            exclude_domains=exclude_list if exclude_list and exclude_list[0] else None
+        )
+        
+        # Format response
+        response = f"# Research: {topic}\n\n{result['content']}"
+        
+        # Add tool usage info if available
+        if result.get("tool_usage"):
+            response += f"\n\n*Tool Usage Information Available*"
+            
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def analyze_code(code_snippet, language, analysis_type):
+    """Analyze code with Groq"""
+    # Check if API key is set
+    check_result = check_api_key()
+    if check_result:
+        return check_result
+    
+    if not code_snippet:
+        return "Please enter code to analyze"
+    
+    try:
+        # Perform analysis
+        result = para_instance.evaluate_code(
+            code_snippet=code_snippet,
+            language=language,
+            analysis_type=analysis_type
+        )
+        
+        # Format response
+        response = f"# Code Analysis ({language}, {analysis_type})\n\n{result['content']}"
+        
+        # Add tool usage info if available
+        if result.get("tool_usage"):
+            response += f"\n\n*Tool Usage Information Available*"
+            
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def connect_concepts_handler(concept_a, concept_b):
+    """Connect two concepts"""
+    # Check if API key is set
+    check_result = check_api_key()
+    if check_result:
+        return check_result
+    
+    if not concept_a or not concept_b:
+        return "Please enter both concepts"
+    
+    try:
+        # Find connections
+        result = para_instance.connect_concepts(
+            concept_a=concept_a,
+            concept_b=concept_b
+        )
+        
+        # Format response
+        response = f"# Connection: {concept_a} & {concept_b}\n\n{result['content']}"
+        
+        # Add tool usage info if available
+        if result.get("tool_usage"):
+            response += f"\n\n*Tool Usage Information Available*"
+            
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def query_knowledge_base(query):
+    """Query the knowledge base"""
+    # Check if API key is set
+    check_result = check_api_key()
+    if check_result:
+        return check_result
+    
+    if not query:
+        return "Please enter a query"
+    
+    try:
+        # Query knowledge base
+        result = para_instance.ask_knowledge_base(query=query)
+        
+        # Format response
+        response = f"# Knowledge Base Query: {query}\n\n{result['response']}"
+        
+        # Add KB stats
+        stats = result.get("knowledge_base_state", {})
+        if stats:
+            topics = stats.get("topics_researched", [])
+            response += f"\n\n*Knowledge Base contains {len(topics)} topics: {', '.join(topics[:5])}" + \
+                       ("..." if len(topics) > 5 else "") + "*"
+            
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def generate_report_handler():
+    """Generate weekly report"""
+    # Check if API key is set
+    check_result = check_api_key()
+    if check_result:
+        return check_result
+    
+    try:
+        # Generate report
+        result = para_instance.generate_weekly_report()
+        
+        # Format response
+        response = f"# Weekly Research Report\n\n{result['content']}"
+        
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Create the Gradio interface
+def create_gradio_app():
+    # Define CSS for styling
+    css = """
+    .title-container {
+        text-align: center;
+        margin-bottom: 20px;
+    }
+    .container {
+        margin: 0 auto;
+        max-width: 1200px;
+    }
+    .tab-content {
+        padding: 20px;
+        border-radius: 10px;
+        background-color: #f9f9f9;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="PARA - Personal AI Research Assistant") as app:
+        gr.Markdown(
+            """
+            <div class="title-container">
+            # 🧠 PARA - Personal AI Research Assistant
+            *Powered by Groq's Compound Beta models for intelligent research*
+            </div>
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=4):
+                api_key_input = gr.Textbox(
+                    label="Groq API Key", 
+                    placeholder="Enter your Groq API key here...",
+                    type="password"
+                )
+            with gr.Column(scale=2):
+                model_choice = gr.Radio(
+                    ["compound-beta", "compound-beta-mini"],
+                    label="Model Selection",
+                    value="compound-beta"
+                )
+            with gr.Column(scale=1):
+                validate_btn = gr.Button("Validate & Connect")
+        
+        api_status = gr.Markdown("### Status: Not connected")
+        
+        # Connect validation button
+        validate_btn.click(
+            fn=validate_api_key,
+            inputs=[api_key_input],
+            outputs=[api_status]
+        )
+        
+        # Connect model selection
+        model_choice.change(
+            fn=update_model_selection,
+            inputs=[model_choice],
+            outputs=[api_status]
+        )
+        
+        # Tabs for different features
+        with gr.Tabs() as tabs:
+            # Research Tab
+            with gr.Tab("Research Topics"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        research_topic_input = gr.Textbox(
+                            label="Research Topic",
+                            placeholder="Enter a topic to research..."
+                        )
+                    with gr.Column(scale=1):
+                        include_domains = gr.Textbox(
+                            label="Include Domains (comma-separated)",
+                            placeholder="arxiv.org, *.edu, example.com"
+                        )
+                        exclude_domains = gr.Textbox(
+                            label="Exclude Domains (comma-separated)",
+                            placeholder="wikipedia.org, twitter.com"
+                        )
+                research_btn = gr.Button("Research Topic")
+                research_output = gr.Markdown("Results will appear here...")
+                
+                research_btn.click(
+                    fn=research_topic,
+                    inputs=[research_topic_input, include_domains, exclude_domains],
+                    outputs=[research_output]
+                )
+                
+                gr.Markdown("""
+                ### Examples:
+                - "Latest developments in quantum computing"
+                - "Climate change mitigation strategies"
+                - "Advancements in protein folding algorithms"
+                
+                *Include domains like "arxiv.org, *.edu" for academic sources*
+                """)
+            
+            # Code Analysis Tab
+            with gr.Tab("Code Analysis"):
+                code_input = gr.Code(
+                    label="Code Snippet",
+                    language="python",
+                    lines=10
+                )
+                with gr.Row():
+                    language_select = gr.Dropdown(
+                        ["python", "javascript", "java", "c++", "go", "rust", "typescript", "sql", "bash"],
+                        label="Language",
+                        value="python"
+                    )
+                    analysis_type = gr.Dropdown(
+                        ["full", "security", "performance", "style"],
+                        label="Analysis Type",
+                        value="full"
+                    )
+                analyze_btn = gr.Button("Analyze Code")
+                analysis_output = gr.Markdown("Results will appear here...")
+                
+                analyze_btn.click(
+                    fn=analyze_code,
+                    inputs=[code_input, language_select, analysis_type],
+                    outputs=[analysis_output]
+                )
+                
+                gr.Markdown("""
+                ### Example Python Code:
+                ```python
+                def fibonacci(n):
+                    if n <= 0:
+                        return []
+                    elif n == 1:
+                        return [0]
+                    else:
+                        result = [0, 1]
+                        for i in range(2, n):
+                            result.append(result[i-1] + result[i-2])
+                        return result
+                
+                print(fibonacci(10))
+                ```
+                """)
+            
+            # Concept Connections Tab
+            with gr.Tab("Connect Concepts"):
+                with gr.Row():
+                    concept_a = gr.Textbox(
+                        label="Concept A",
+                        placeholder="First concept or field..."
+                    )
+                    concept_b = gr.Textbox(
+                        label="Concept B",
+                        placeholder="Second concept or field..."
+                    )
+                connect_btn = gr.Button("Find Connections")
+                connection_output = gr.Markdown("Results will appear here...")
+                
+                connect_btn.click(
+                    fn=connect_concepts_handler,
+                    inputs=[concept_a, concept_b],
+                    outputs=[connection_output]
+                )
+                
+                gr.Markdown("""
+                ### Example Concept Pairs:
+                - "quantum computing" and "machine learning"
+                - "blockchain" and "supply chain management"
+                - "gene editing" and "ethics"
+                """)
+            
+            # Knowledge Base Tab
+            with gr.Tab("Knowledge Base"):
+                kb_query = gr.Textbox(
+                    label="Query Knowledge Base",
+                    placeholder="Ask about topics in your knowledge base..."
+                )
+                kb_btn = gr.Button("Query Knowledge Base")
+                kb_output = gr.Markdown("Results will appear here...")
+                
+                kb_btn.click(
+                    fn=query_knowledge_base,
+                    inputs=[kb_query],
+                    outputs=[kb_output]
+                )
+                
+                report_btn = gr.Button("Generate Weekly Report")
+                report_output = gr.Markdown("Report will appear here...")
+                
+                report_btn.click(
+                    fn=generate_report_handler,
+                    inputs=[],
+                    outputs=[report_output]
+                )
+                
+                gr.Markdown("""
+                ### Example Queries:
+                - "What have we learned about quantum computing?"
+                - "Summarize our research on AI safety"
+                - "What connections exist between the topics we've studied?"
+                """)
+        
+        gr.Markdown("""
+        ## About PARA
+        
+        PARA (Personal AI Research Assistant) leverages Groq's compound models with agentic capabilities to help you research topics, analyze code, find connections between concepts, and build a personalized knowledge base.
+        
+        **How it works:**
+        1. Set your Groq API key
+        2. Choose between compound-beta (more powerful) and compound-beta-mini (faster)
+        3. Use the tabs to access different features
+        4. Your research is automatically saved to a knowledge base for future reference
+        
+        **Features:**
+        - Web search with domain filtering
+        - Code execution and analysis
+        - Concept connections discovery
+        - Persistent knowledge base
+        - Weekly research reports
+        """)
+    
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_gradio_app()
+    app.launch()