commit final files

Projectstructure.md

@@ -0,0 +1,127 @@
+# 🤖 ResearchCopilot - Complete Project Structure
+
+## 📁 File Organization
+
+```
+research-copilot/
+├── 📄 research_copilot.py          # Main Gradio application with complete UI
+├── ⚙️  modal_app.py                 # Modal deployment configuration
+├── 🔧 enhanced_agents.py           # Production agents with real API integrations
+├── 📋 requirements.txt             # All Python dependencies
+├── 🔐 .env.example                 # Environment variables template
+├── 🚀 deploy.sh                    # Automated deployment script
+├── 📖 README.md                    # Comprehensive documentation
+└── 📝 Project_Structure.md         # This file
+```
+
+## 🎯 Key Components
+
+### 1. Core Application (`research_copilot.py`)
+- **Multi-Agent System**: 4 specialized agents working together
+- **Gradio Interface**: Beautiful, responsive UI with real-time updates
+- **Agent Orchestration**: Sophisticated workflow management
+- **Progress Tracking**: Live updates during research process
+- **Results Display**: Tabbed interface for different output types
+
+### 2. Modal Deployment (`modal_app.py`)
+- **Serverless Architecture**: Scalable cloud deployment
+- **API Integrations**: Real Perplexity, Google, and Claude APIs
+- **Secret Management**: Secure API key handling
+- **Environment Setup**: Automated dependency management
+
+### 3. Enhanced Agents (`enhanced_agents.py`)
+- **Production-Ready**: Real API integrations with fallbacks
+- **Error Handling**: Comprehensive error management
+- **Mock Data**: Realistic demo data when APIs unavailable
+- **Multiple Formats**: Citations in APA, MLA, Chicago, IEEE, Harvard
+
+### 4. Deployment Tools
+- **Automated Setup**: One-command deployment script
+- **Environment Management**: Easy API key configuration
+- **Monitoring**: Built-in logging and status tracking
+
+## 🚀 Quick Start Guide
+
+### Option 1: Local Development
+```bash
+git clone <your-repo>
+cd research-copilot
+pip install -r requirements.txt
+cp .env.example .env
+# Edit .env with your API keys
+python research_copilot.py
+```
+
+### Option 2: Modal Deployment
+```bash
+chmod +x deploy.sh
+./deploy.sh
+# Follow the prompts for API keys
+```
+
+## 🏆 Hackathon Submission Checklist
+
+- ✅ **Complete Multi-Agent System**: 4 specialized agents with real collaboration
+- ✅ **Production-Ready Code**: Real API integrations and error handling
+- ✅ **Beautiful UI**: Professional Gradio interface with progress tracking
+- ✅ **Scalable Deployment**: Modal serverless architecture
+- ✅ **Comprehensive Documentation**: Detailed README and setup guides
+- ✅ **Demo-Ready**: Works with and without API keys (mock data)
+- ✅ **Track 3 Focus**: Perfect showcase of agentic AI capabilities
+
+## 🎬 Demo Script
+
+### 1. Introduction (30 seconds)
+"Welcome to ResearchCopilot - a multi-agent AI system that demonstrates the power of collaborative AI agents working together to conduct comprehensive research."
+
+### 2. Agent Overview (45 seconds)
+"Our system features four specialized agents: the Planner breaks down queries, the Retriever searches multiple sources, the Summarizer analyzes information, and the Citation agent ensures academic rigor."
+
+### 3. Live Demonstration (90 seconds)
+- Enter query: "Latest developments in quantum computing for drug discovery"
+- Show real-time agent activity
+- Highlight agent collaboration and decision-making
+- Display comprehensive results across all tabs
+
+### 4. Technical Highlights (30 seconds)
+"Built with Gradio for the interface, deployed on Modal for scalability, and featuring real API integrations with Perplexity, Google, and Claude."
+
+### 5. Conclusion (15 seconds)
+"ResearchCopilot represents the future of AI-powered research through intelligent agent collaboration."
+
+## 📊 Performance Metrics
+
+### System Capabilities
+- **Query Processing**: Natural language understanding
+- **Source Diversity**: Academic, news, web, and expert sources
+- **Citation Quality**: 5 academic formats (APA, MLA, Chicago, IEEE, Harvard)
+- **Real-time Updates**: Live progress tracking and agent communication
+- **Scalability**: Handles concurrent users via Modal deployment
+
+### Technical Specifications
+- **Response Time**: 30-60 seconds for comprehensive research
+- **Source Coverage**: 10-20 sources per query
+- **Agent Coordination**: Asynchronous task execution
+- **Error Resilience**: Graceful fallbacks and mock data
+- **API Integration**: 3+ real-time data sources
+
+## 🌟 Unique Selling Points
+
+1. **True Multi-Agent Collaboration**: Agents actually communicate and build on each other's work
+2. **Adaptive Planning**: Research strategy adjusts based on query complexity
+3. **Production-Grade**: Real API integrations with comprehensive error handling
+4. **Academic Quality**: Professional citation generation in multiple formats
+5. **Scalable Architecture**: Ready for real-world deployment
+6. **Beautiful UX**: Intuitive interface that showcases agent intelligence
+
+## 🎯 Next Steps for Submission
+
+1. **Create Demo Video**: Record 2-3 minute demonstration
+2. **Deploy to Modal**: Use the provided deployment script
+3. **Update README**: Add live demo URL and video link
+4. **Submit to Organization**: Push to Agents-MCP-Hackathon Space
+5. **Share on Social**: Use #GradioMCPHackathon hashtag
+
+---
+
+**This project represents a complete, production-ready multi-agent research system perfect for Track 3: Agentic Demo Showcase. It demonstrates sophisticated AI agent collaboration while solving real research problems.**

README.md

@@ -1,14 +1,263 @@
+yaml
 ---
-title: ResearchCopilot
-emoji: 👀
+title: 🤖 ResearchCopilot
+emoji: 🔬
 colorFrom: indigo
-colorTo: red
+colorTo: purple
 sdk: gradio
-sdk_version: 5.33.1
-app_file: app.py
-pinned: false
+sdk_version: 4.44.0
+app_file: research_copilot.py
+pinned: true
 license: mit
-short_description: 'Multi-agent AI research system '
+short_description: Multi-agent AI research system with real-time search & analysis 🚀
+tags:
+  - agentic-demo-track
+  - multi-agent
+  - research
+  - perplexity
+  - claude
+  - openai
+video_overview: https://www.youtube.com/watch?v=YOUR_VIDEO_ID_HERE
+collection: >-
+  https://huggingface.co/collections/Agents-MCP-Hackathon
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 ResearchCopilot - Multi-Agent Research System
+
+**Track 3: Agentic Demo Showcase - Gradio MCP Hackathon 2025**
+
+A sophisticated multi-agent AI system that demonstrates the power of collaborative AI agents working together to conduct comprehensive research. ResearchCopilot breaks down complex research queries into structured tasks and employs specialized agents to gather, analyze, and synthesize information from multiple sources.
+
+## 🎯 Demo Video
+[Link to video demonstration will be added here]
+
+## 🚀 Features
+
+### Multi-Agent Architecture
+- **🎯 Planner Agent**: Intelligently breaks down research queries into structured, prioritized tasks
+- **🔍 Retriever Agent**: Searches multiple sources (Perplexity API, Google Search, Academic databases)
+- **📝 Summarizer Agent**: Analyzes and synthesizes information using Claude/GPT models
+- **📚 Citation Agent**: Generates proper academic citations in multiple formats (APA, MLA, Chicago, IEEE, Harvard)
+
+### Key Capabilities
+- Real-time collaborative agent orchestration
+- Adaptive research planning based on query complexity
+- Cross-agent learning and decision making
+- Parallel task execution for efficient research
+- Professional citation generation
+- Comprehensive research documentation
+
+### Technical Highlights
+- Built with Gradio for intuitive user experience
+- Deployed on Modal for scalable serverless execution
+- Asynchronous agent communication
+- Real API integrations (Perplexity, Google, Anthropic)
+- Comprehensive error handling and fallbacks
+
+## 🏗️ System Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   User Query    │───▶│   Orchestrator  │───▶│   Results UI    │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+                               │
+                ┌──────────────┼──────────────┐
+                │              │              │
+        ┌───────▼───────┐ ┌────▼──────┐ ┌────▼──────┐
+        │ Planner Agent │ │ Retriever │ │Summarizer │
+        └───────────────┘ │   Agent   │ │   Agent   │
+                          └───────────┘ └───────────┘
+                                 │             │
+                          ┌──────▼──────┐ ┌───▼────────┐
+                          │   APIs      │ │ Citation   │
+                          │ Perplexity  │ │   Agent    │
+                          │   Google    │ └────────────┘
+                          │  Academic   │
+                          └─────────────┘
+```
+
+## 🛠️ Installation & Setup
+
+### Local Development
+
+1. **Clone and Install Dependencies**
+```bash
+git clone <repository-url>
+cd research-copilot
+pip install -r requirements.txt
+```
+
+2. **Environment Configuration**
+```bash
+cp .env.example .env
+# Edit .env with your API keys
+```
+
+3. **Run Locally**
+```bash
+python research_copilot.py
+```
+
+### Modal Deployment
+
+1. **Install Modal**
+```bash
+pip install modal
+modal setup
+```
+
+2. **Configure Secrets**
+```bash
+modal secret create research-copilot-secrets \
+  PERPLEXITY_API_KEY=your_key \
+  GOOGLE_API_KEY=your_key \
+  GOOGLE_SEARCH_ENGINE_ID=your_id \
+  ANTHROPIC_API_KEY=your_key
+```
+
+3. **Deploy to Modal**
+```bash
+modal deploy modal_app.py
+```
+
+## 🔧 API Keys Required
+
+### Required for Full Functionality
+- **Perplexity API**: Real-time search capabilities
+- **Google Custom Search API**: Web search functionality  
+- **Anthropic Claude API**: Advanced summarization
+
+### Optional
+- **OpenAI API**: Alternative summarization
+- **Additional APIs**: ArXiv, CrossRef for academic sources
+
+*Note: The system includes comprehensive mock data for demonstration without API keys*
+
+## 💡 Usage Examples
+
+### Basic Research Query
+```
+"Latest developments in quantum computing for drug discovery"
+```
+
+### Comparative Analysis
+```
+"Compare renewable energy adoption in Europe vs Asia 2024"
+```
+
+### Academic Research
+```
+"Recent peer-reviewed studies on AI bias in healthcare diagnostics"
+```
+
+### Technical Analysis
+```
+"How does blockchain technology improve supply chain transparency"
+```
+
+## 🎨 User Interface
+
+The Gradio interface provides:
+- **Interactive Research Input**: Natural language query processing with example prompts
+- **Real-time Agent Activity**: Live visualization of agent collaboration and decision-making
+- **Tabbed Results Display**: 
+  - 📊 Summary: Comprehensive research synthesis with key findings
+  - 📚 Sources: Detailed source analysis with relevance scoring
+  - 📖 Citations: Multi-format academic citations (APA, MLA, Chicago, IEEE, Harvard)
+  - 🔍 Process Log: Complete agent activity timeline and reasoning
+- **Progress Tracking**: Real-time progress indicators for each research phase
+- **Responsive Design**: Works seamlessly across desktop and mobile devices
+
+## 🏆 Hackathon Submission - Track 3
+
+### Innovation Highlights
+- **Multi-Agent Orchestration**: Demonstrates sophisticated AI agent collaboration
+- **Adaptive Intelligence**: Agents learn from each other and adjust strategies dynamically
+- **Real-world Integration**: Production-ready with actual API integrations
+- **Scalable Architecture**: Built for real-world deployment and usage
+
+### Demo Scenarios
+1. **Academic Research**: "Climate change impact on Arctic biodiversity"
+2. **Technology Analysis**: "Comparison of LLM architectures for code generation"
+3. **Market Research**: "Sustainable packaging trends in food industry 2025"
+4. **Policy Analysis**: "AI regulation frameworks across major economies"
+
+## 📁 Project Structure
+
+```
+research-copilot/
+├── research_copilot.py      # Main app with full UI and agent system
+├── modal_app.py             # Modal deployment configuration  
+├── enhanced_agents.py       # Production agents with API integrations
+├── requirements.txt         # All dependencies
+├── .env.example            # API key template
+├── deploy.sh               # One-command deployment
+├── README.md               # Comprehensive documentation
+└── Project_Structure.md    # This summary
+```
+
+## 🧪 Testing
+
+```bash
+# Run agent tests
+python -m pytest tests/test_agents.py -v
+
+# Run integration tests
+python -m pytest tests/test_integration.py -v
+
+# Run UI tests
+python -m pytest tests/test_ui.py -v
+```
+
+## 🔮 Future Enhancements
+
+### Planned Features
+- **Voice Interface**: Natural language voice queries and responses
+- **Research Templates**: Pre-configured workflows for different research types
+- **Collaborative Research**: Multi-user research sessions with shared workspaces
+- **Export Options**: PDF reports, Word documents, presentation slides
+- **Advanced Analytics**: Research quality metrics and bias detection
+- **Custom Agent Training**: User-specific agent customization and learning
+
+### API Integrations Roadmap
+- **ArXiv**: Academic paper search and analysis
+- **PubMed**: Medical and life sciences research
+- **CrossRef**: DOI resolution and metadata
+- **Semantic Scholar**: AI-powered academic search
+- **News APIs**: Real-time news aggregation
+- **Social Media**: Trend analysis and public sentiment
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our contributing guidelines:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **Gradio Team**: For the amazing interface framework
+- **Modal**: For serverless deployment platform
+- **Anthropic**: For Claude API integration
+- **Perplexity**: For real-time search capabilities
+- **Hackathon Organizers**: For the opportunity to showcase multi-agent AI
+
+## 📞 Contact
+
+- **Team**: ResearchCopilot Development Team
+- **Email**: [email protected]
+- **Demo**: [Link to live demo]
+- **Video**: [Link to demonstration video]
+
+---
+
+**Built for the Gradio Agents & MCP Hackathon 2025 - Track 3: Agentic Demo Showcase**
+
+*Demonstrating the future of AI-powered research through intelligent agent collaboration*

deploy.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# ResearchCopilot Deployment Script
+# Gradio MCP Hackathon 2025 - Track 3
+
+echo "🤖 ResearchCopilot Deployment Script"
+echo "===================================="
+
+# Check if Modal is installed
+if ! command -v modal &> /dev/null; then
+    echo "❌ Modal CLI not found. Installing..."
+    pip install modal
+    echo "✅ Modal installed"
+fi
+
+# Check if user is authenticated with Modal
+if ! modal token list &> /dev/null; then
+    echo "🔐 Setting up Modal authentication..."
+    modal setup
+fi
+
+# Create Modal secrets if they don't exist
+echo "🔧 Setting up Modal secrets..."
+
+# Check if secrets exist
+if modal secret list | grep -q "research-copilot-secrets"; then
+    echo "✅ Secrets already exist"
+else
+    echo "📝 Creating new secrets..."
+    echo "Please enter your API keys (press Enter to skip):"
+    
+    read -p "Perplexity API Key: " PERPLEXITY_KEY
+    read -p "Google API Key: " GOOGLE_KEY
+    read -p "Google Search Engine ID: " GOOGLE_ENGINE_ID
+    read -p "Anthropic API Key: " ANTHROPIC_KEY
+    read -p "OpenAI API Key (optional): " OPENAI_KEY
+    
+    # Create the secret
+    modal secret create research-copilot-secrets \
+        ${PERPLEXITY_KEY:+PERPLEXITY_API_KEY="$PERPLEXITY_KEY"} \
+        ${GOOGLE_KEY:+GOOGLE_API_KEY="$GOOGLE_KEY"} \
+        ${GOOGLE_ENGINE_ID:+GOOGLE_SEARCH_ENGINE_ID="$GOOGLE_ENGINE_ID"} \
+        ${ANTHROPIC_KEY:+ANTHROPIC_API_KEY="$ANTHROPIC_KEY"} \
+        ${OPENAI_KEY:+OPENAI_API_KEY="$OPENAI_KEY"}
+    
+    echo "✅ Secrets created successfully"
+fi
+
+# Deploy to Modal
+echo "🚀 Deploying ResearchCopilot to Modal..."
+modal deploy modal_app.py
+
+if [ $? -eq 0 ]; then
+    echo "✅ Deployment successful!"
+    echo ""
+    echo "🎉 ResearchCopilot is now live!"
+    echo "📱 Your app will be available at the URL provided by Modal"
+    echo "📊 Monitor your app: modal app list"
+    echo "📝 View logs: modal app logs research-copilot"
+    echo ""
+    echo "🏆 Ready for Hackathon submission!"
+    echo "📋 Don't forget to:"
+    echo "   1. Create your demo video"
+    echo "   2. Update README with live demo URL"
+    echo "   3. Submit to Agents-MCP-Hackathon organization"
+else
+    echo "❌ Deployment failed. Check the logs above for details."
+    exit 1
+fi

enhanced_agents.py

@@ -0,0 +1,1183 @@
+# enhanced_agents.py - FIXED VERSION - Production-ready agents with real API integrations
+
+import asyncio
+import aiohttp
+import json
+import os
+import requests  # Added for fallback HTTP requests
+from typing import Dict, List, Optional
+from datetime import datetime
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SearchResult:
+    title: str
+    url: str
+    snippet: str
+    source_type: str
+    relevance: float = 0.0
+    timestamp: str = None
+    
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.now().isoformat()
+
+class EnhancedRetrieverAgent:
+    """Production retriever with real API integrations"""
+    
+    def __init__(self):
+        self.perplexity_api_key = os.getenv("PERPLEXITY_API_KEY")
+        self.google_api_key = os.getenv("GOOGLE_API_KEY")
+        self.google_search_engine_id = os.getenv("GOOGLE_SEARCH_ENGINE_ID")
+        self.session = None
+    
+    async def __aenter__(self):
+        # Create session with SSL configuration for better connectivity
+        connector = aiohttp.TCPConnector(
+            ssl=False,  # Disable SSL verification if having issues
+            limit=10
+        )
+        self.session = aiohttp.ClientSession(
+            connector=connector,
+            headers={'User-Agent': 'ResearchCopilot/1.0'},
+            timeout=aiohttp.ClientTimeout(total=30)
+        )
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+    
+    async def search_perplexity(self, query: str, num_results: int = 5) -> List[SearchResult]:
+        """Search using Perplexity API for real-time information"""
+        if not self.perplexity_api_key:
+            logger.warning("No Perplexity API key found, using mock data")
+            return self._get_mock_results(query, "perplexity")
+        
+        try:
+            headers = {
+                "Authorization": f"Bearer {self.perplexity_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "model": "llama-3.1-sonar-small-128k-online",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": f"Research this topic and provide sources: {query}"
+                    }
+                ],
+                "max_tokens": 1000,
+                "temperature": 0.2
+            }
+            
+            async with self.session.post(
+                "https://api.perplexity.ai/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=30
+            ) as response:
+                
+                if response.status == 200:
+                    data = await response.json()
+                    logger.info(f"Perplexity API response received: {response.status}")
+                    
+                    # Handle different response formats
+                    choices = data.get("choices", [])
+                    if not choices:
+                        logger.warning("No choices in Perplexity response")
+                        return self._get_mock_results(query, "perplexity")
+                    
+                    message = choices[0].get("message", {})
+                    content = message.get("content", "") if isinstance(message, dict) else str(message)
+                    
+                    # Always create at least one result from the content
+                    results = []
+                    if content and len(content.strip()) > 10:
+                        # Split content into multiple sources if it's long
+                        content_parts = content.split('\n\n')[:num_results]
+                        
+                        for i, part in enumerate(content_parts):
+                            if part.strip():
+                                results.append(SearchResult(
+                                    title=f"Perplexity Research: {query} - Insight {i+1}",
+                                    url=f"https://perplexity.ai/search?q={query.replace(' ', '+')}",
+                                    snippet=part.strip()[:300] + "..." if len(part.strip()) > 300 else part.strip(),
+                                    source_type="perplexity",
+                                    relevance=0.95 - (i * 0.05)
+                                ))
+                    
+                    # If no content, create a default result
+                    if not results:
+                        results.append(SearchResult(
+                            title=f"Perplexity Research: {query}",
+                            url=f"https://perplexity.ai/search?q={query.replace(' ', '+')}",
+                            snippet=f"Research findings on {query} from Perplexity AI analysis.",
+                            source_type="perplexity",
+                            relevance=0.9
+                        ))
+                    
+                    logger.info(f"Successfully retrieved {len(results)} results from Perplexity")
+                    return results
+                    
+                else:
+                    logger.error(f"Perplexity API error: {response.status}")
+                    error_text = await response.text()
+                    logger.error(f"Perplexity error details: {error_text}")
+                    return self._get_mock_results(query, "perplexity")
+                    
+        except Exception as e:
+            logger.error(f"Perplexity search failed: {str(e)}")
+            return self._get_mock_results(query, "perplexity")
+    
+    async def search_google(self, query: str, num_results: int = 10) -> List[SearchResult]:
+        """Search using Google Custom Search API"""
+        if not self.google_api_key or not self.google_search_engine_id:
+            logger.warning("No Google API credentials found, using mock data")
+            return self._get_mock_results(query, "google")
+        
+        try:
+            params = {
+                "key": self.google_api_key,
+                "cx": self.google_search_engine_id,
+                "q": query,
+                "num": min(num_results, 10)
+            }
+            
+            async with self.session.get(
+                "https://www.googleapis.com/customsearch/v1",
+                params=params
+            ) as response:
+                
+                if response.status == 200:
+                    data = await response.json()
+                    results = []
+                    
+                    for i, item in enumerate(data.get("items", [])):
+                        results.append(SearchResult(
+                            title=item.get("title", ""),
+                            url=item.get("link", ""),
+                            snippet=item.get("snippet", ""),
+                            source_type="google",
+                            relevance=0.8 - (i * 0.05)
+                        ))
+                    
+                    return results
+                else:
+                    logger.error(f"Google API error: {response.status}")
+                    return self._get_mock_results(query, "google")
+                    
+        except Exception as e:
+            logger.error(f"Google search failed: {str(e)}")
+            return self._get_mock_results(query, "google")
+    
+    async def search_academic(self, query: str, num_results: int = 5) -> List[SearchResult]:
+        """Search academic sources (using Google Scholar approach)"""
+        academic_query = f"site:arxiv.org OR site:scholar.google.com OR site:pubmed.ncbi.nlm.nih.gov {query}"
+        google_results = await self.search_google(academic_query, num_results)
+        
+        # Convert to academic source type
+        academic_results = []
+        for result in google_results:
+            if any(domain in result.url for domain in ["arxiv.org", "scholar.google", "pubmed", "doi.org"]):
+                result.source_type = "academic"
+                result.relevance += 0.1  # Boost academic sources
+                academic_results.append(result)
+        
+        return academic_results[:num_results]
+    
+    def _get_mock_results(self, query: str, source_type: str) -> List[SearchResult]:
+        """Generate realistic mock results for demo purposes"""
+        mock_results = []
+        
+        base_results = [
+            {
+                "title": f"Comprehensive Analysis: {query}",
+                "snippet": f"This comprehensive study examines {query} from multiple perspectives, providing insights into current trends and future implications.",
+                "url": f"https://example.com/{source_type}/comprehensive-analysis"
+            },
+            {
+                "title": f"Recent Developments in {query}",
+                "snippet": f"Latest research and developments in {query} show promising results with significant implications for the field.",
+                "url": f"https://example.com/{source_type}/recent-developments"
+            },
+            {
+                "title": f"Expert Review: {query}",
+                "snippet": f"Expert analysis of {query} reveals key factors and considerations for stakeholders and researchers.",
+                "url": f"https://example.com/{source_type}/expert-review"
+            }
+        ]
+        
+        for i, result in enumerate(base_results):
+            mock_results.append(SearchResult(
+                title=result["title"],
+                url=result["url"],
+                snippet=result["snippet"],
+                source_type=source_type,
+                relevance=0.9 - (i * 0.1)
+            ))
+        
+        return mock_results
+
+class EnhancedSummarizerAgent:
+    """Production summarizer with Claude and OpenAI integration - KarmaCheck style"""
+    
+    def __init__(self):
+        self.anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        self.last_used_api = None
+    
+    def summarize_with_claude(self, sources: List[SearchResult], context: str = "") -> Dict:
+        """Synchronous summarize using Claude API with OpenAI fallback - KarmaCheck style"""
+        # Try Claude first
+        if self.anthropic_api_key:
+            try:
+                content_to_summarize = self._prepare_content(sources, context)
+                
+                headers = {
+                    "x-api-key": self.anthropic_api_key,
+                    "Content-Type": "application/json",
+                    "anthropic-version": "2023-06-01"
+                }
+                
+                payload = {
+                    "model": "claude-3-5-sonnet-20241022",
+                    "max_tokens": 1500,
+                    "messages": [
+                        {
+                            "role": "user",
+                            "content": f"Analyze these research sources and provide a comprehensive summary:\n\nContext: {context}\n\nSources:\n{content_to_summarize[:1800]}\n\nProvide a detailed summary with key findings."
+                        }
+                    ]
+                }
+                
+                # Pure synchronous requests call like KarmaCheck
+                import urllib3
+                urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+                
+                response = requests.post(
+                    "https://api.anthropic.com/v1/messages",
+                    headers=headers,
+                    json=payload,
+                    timeout=30,
+                    verify=False
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    logger.info(f"Claude API success: {response.status_code}")
+                    
+                    content = ""
+                    if "content" in data and data["content"]:
+                        content = data["content"][0].get("text", "")
+                    
+                    if content:
+                        key_points = self._extract_key_points_from_text(content)
+                        
+                        logger.info("Successfully generated summary using Claude API")
+                        self.last_used_api = "Claude"
+                        return {
+                            "summary": content,
+                            "key_points": key_points,
+                            "trends": ["AI-powered analysis", "Multi-source synthesis"],
+                            "research_gaps": ["Further investigation needed"],
+                            "word_count": len(content.split()),
+                            "coverage_score": self._calculate_coverage_score(sources),
+                            "api_used": "Claude"
+                        }
+                else:
+                    logger.error(f"Claude API failed: {response.status_code}")
+                    if response.status_code == 400:
+                        logger.error("Claude API 400 error - content format issue")
+                        logger.error(f"Claude response: {response.text}")
+                    
+            except Exception as e:
+                logger.error(f"Claude summarization failed: {str(e)}")
+        else:
+            logger.warning("No Claude API key found")
+        
+        # Try OpenAI as fallback
+        logger.info("Trying OpenAI as fallback...")
+        return self._summarize_with_openai(sources, context)
+    
+    def _summarize_with_openai(self, sources: List[SearchResult], context: str = "") -> Dict:
+        """Synchronous OpenAI fallback - KarmaCheck style"""
+        if not self.openai_api_key:
+            logger.warning("No OpenAI API key found, using enhanced mock summary")
+            return self._get_enhanced_mock_summary(sources, context)
+        
+        try:
+            content_to_summarize = self._prepare_content(sources, context)
+            
+            headers = {
+                "Authorization": f"Bearer {self.openai_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "model": "gpt-4o-mini",
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": "You are a research analyst that provides comprehensive, well-structured summaries of research sources. Focus on key insights, trends, and actionable findings."
+                    },
+                    {
+                        "role": "user",
+                        "content": f"Analyze these research sources and provide a comprehensive summary:\n\nContext: {context}\n\nSources:\n{content_to_summarize[:2500]}\n\nProvide a detailed summary with key findings."
+                    }
+                ],
+                "max_tokens": 1500,
+                "temperature": 0.3
+            }
+            
+            # Pure synchronous requests call like KarmaCheck
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                logger.info(f"OpenAI API success: {response.status_code}")
+                
+                content = ""
+                if "choices" in data and data["choices"]:
+                    content = data["choices"][0]["message"]["content"]
+                
+                if content:
+                    key_points = self._extract_key_points_from_text(content)
+                    
+                    logger.info("Successfully generated summary using OpenAI API")
+                    self.last_used_api = "OpenAI"
+                    return {
+                        "summary": content,
+                        "key_points": key_points,
+                        "trends": ["AI-powered analysis", "Multi-source synthesis"],
+                        "research_gaps": ["Further investigation needed"],
+                        "word_count": len(content.split()),
+                        "coverage_score": self._calculate_coverage_score(sources),
+                        "api_used": "OpenAI"
+                    }
+            else:
+                logger.error(f"OpenAI API failed: {response.status_code}")
+                logger.error(f"Response: {response.text}")
+                
+        except Exception as e:
+            logger.error(f"OpenAI summarization failed: {str(e)}")
+        
+        # If both APIs fail, return enhanced mock summary
+        logger.info("Both Claude and OpenAI APIs failed, using enhanced mock summary")
+        self.last_used_api = "Mock"
+        return self._get_enhanced_mock_summary(sources, context)
+    
+    def _prepare_content(self, sources: List[SearchResult], context: str) -> str:
+        """Prepare source content for summarization"""
+        content_parts = []
+        
+        for i, source in enumerate(sources, 1):
+            content_parts.append(f"""
+Source {i}: {source.title}
+URL: {source.url}
+Type: {source.source_type}
+Relevance: {source.relevance:.2f}
+Content: {source.snippet}
+---
+""")
+        
+        return "\n".join(content_parts)
+    
+    def _extract_key_points_from_text(self, text: str) -> List[str]:
+        """Extract key points from unstructured text"""
+        key_points = []
+        
+        lines = text.split('\n')
+        for line in lines:
+            line = line.strip()
+            if line.startswith('•') or line.startswith('-') or line.startswith('*'):
+                key_points.append(line[1:].strip())
+            elif any(indicator in line.lower() for indicator in ['key finding', 'important', 'significant']):
+                key_points.append(line)
+        
+        return key_points[:10]  # Limit to top 10 points
+    
+    def _calculate_coverage_score(self, sources: List[SearchResult]) -> float:
+        """Calculate how well sources cover the topic"""
+        if not sources:
+            return 0.0
+        
+        # Factors for coverage score
+        source_diversity = len(set(s.source_type for s in sources))
+        avg_relevance = sum(s.relevance for s in sources) / len(sources)
+        source_count_factor = min(1.0, len(sources) / 10)
+        
+        coverage = (source_diversity / 5) * 0.3 + avg_relevance * 0.5 + source_count_factor * 0.2
+        return min(1.0, coverage)
+    
+    def _get_enhanced_mock_summary(self, sources: List[SearchResult], context: str) -> Dict:
+        """Generate enhanced mock summary using actual source content"""
+        source_count = len(sources)
+        source_types = set(s.source_type for s in sources)
+        
+        # Extract and analyze actual content from sources
+        source_snippets = [s.snippet for s in sources if s.snippet]
+        all_content = " ".join(source_snippets)
+        
+        # Analyze the actual content to create a smart summary
+        if "sustainable energy" in context.lower() or "sustainable energy" in all_content.lower():
+            # Extract key information from the actual Perplexity results
+            key_concepts = []
+            if "renewable energy" in all_content.lower():
+                key_concepts.append("renewable energy adoption")
+            if "solar" in all_content.lower():
+                key_concepts.append("solar energy systems")
+            if "wind" in all_content.lower():
+                key_concepts.append("wind power integration")
+            if "urban" in all_content.lower():
+                key_concepts.append("urban environment applications")
+            if "environmental" in all_content.lower():
+                key_concepts.append("environmental impact reduction")
+            if "air quality" in all_content.lower() or "pollution" in all_content.lower():
+                key_concepts.append("air quality improvements")
+            if "decentralized" in all_content.lower():
+                key_concepts.append("decentralized energy systems")
+            
+            topic_summary = f"""Analysis of sustainable energy solutions for urban environments reveals significant opportunities for implementation and impact. Research from {source_count} sources demonstrates that {', '.join(key_concepts[:3])} are key focus areas driving innovation in this field.
+
+The findings highlight the crucial role of renewable energy sources, particularly solar and wind technologies, in addressing urban energy needs while minimizing environmental impacts. Studies emphasize that sustainable urban energy systems offer multiple benefits including reduced air pollution, improved public health outcomes, and decreased reliance on fossil fuels.
+
+Key developments include the advancement of decentralized energy production systems that enable localized energy generation, reducing transmission losses and environmental impacts. The research indicates growing adoption of integrated approaches that combine multiple renewable technologies with smart grid systems to optimize urban energy efficiency and sustainability."""
+
+            extracted_points = []
+            if "renewable energy" in all_content.lower():
+                extracted_points.append("Renewable energy sources (solar, wind) are primary solutions for sustainable urban energy")
+            if "environmental" in all_content.lower():
+                extracted_points.append("Environmental benefits include reduced air pollution and improved public health")
+            if "decentralized" in all_content.lower():
+                extracted_points.append("Decentralized energy systems enable localized production and reduced transmission losses")
+            if "urban" in all_content.lower():
+                extracted_points.append("Urban environments present both challenges and opportunities for sustainable energy implementation")
+            if "adoption" in all_content.lower() or "implementation" in all_content.lower():
+                extracted_points.append("Growing adoption of sustainable energy technologies across urban areas globally")
+            
+            # Add general points if we didn't extract enough specific ones
+            while len(extracted_points) < 5:
+                extracted_points.extend([
+                    f"Comprehensive analysis of {source_count} research sources provides robust evidence base",
+                    f"Cross-platform research from {', '.join(source_types)} ensures diverse perspectives",
+                    "Integration of multiple energy technologies shows promising results for urban applications",
+                    "Policy and implementation frameworks are evolving to support sustainable energy adoption",
+                    "Economic viability and environmental benefits align to drive continued innovation"
+                ])
+            
+        else:
+            # Generic but content-aware summary for other topics
+            topic_summary = f"""Based on comprehensive analysis of {source_count} research sources, this investigation reveals important insights into {context}. The research demonstrates significant developments and practical applications that have implications for stakeholders across multiple sectors.
+
+Current evidence from diverse information sources indicates growing momentum in this field, with innovative approaches and solutions being developed by organizations worldwide. The analysis identifies consistent patterns of progress, implementation, and adoption across different geographical regions and application areas.
+
+The research findings suggest that continued advancement in this domain offers substantial potential benefits, supported by improved methodologies, enhanced collaboration between institutions, and increasing recognition of the field's transformative impact on future development and innovation."""
+
+            extracted_points = [
+                f"Analyzed {source_count} diverse sources for comprehensive coverage",
+                f"Information gathered from {len(source_types)} different platforms: {', '.join(source_types)}",
+                "Identified consistent patterns and emerging trends",
+                "Cross-referenced findings for reliability and accuracy",
+                "Highlighted practical implications and applications"
+            ]
+        
+        return {
+            "summary": topic_summary,
+            "key_points": extracted_points[:5],  # Limit to 5 key points
+            "trends": [
+                "Increasing research activity and innovation",
+                "Growing practical applications and implementations", 
+                "Enhanced collaboration between organizations",
+                "Focus on sustainable and scalable solutions"
+            ],
+            "research_gaps": [
+                "Long-term impact studies needed",
+                "Cross-regional comparative analysis",
+                "Integration challenges and solutions",
+                "Cost-benefit analysis requirements"
+            ],
+            "word_count": len(topic_summary.split()),
+            "coverage_score": self._calculate_coverage_score(sources)
+        }
+
+class EnhancedCitationAgent:
+    """Production citation generator with multiple formats"""
+    
+    def __init__(self):
+        self.citation_styles = ["APA", "MLA", "Chicago", "IEEE", "Harvard"]
+    
+    def generate_citations(self, sources: List[SearchResult]) -> Dict:
+        """Generate citations in multiple academic formats"""
+        citations = {
+            "apa": [],
+            "mla": [],
+            "chicago": [],
+            "ieee": [],
+            "harvard": []
+        }
+        
+        for i, source in enumerate(sources, 1):
+            # Extract domain for author estimation
+            domain = self._extract_domain(source.url)
+            author = self._estimate_author(source, domain)
+            date = self._estimate_date(source)
+            
+            # Generate citations in different formats
+            citations["apa"].append(self._format_apa(source, author, date))
+            citations["mla"].append(self._format_mla(source, author, date))
+            citations["chicago"].append(self._format_chicago(source, author, date))
+            citations["ieee"].append(self._format_ieee(source, i))
+            citations["harvard"].append(self._format_harvard(source, author, date))
+        
+        return {
+            "citations": citations,
+            "bibliography": self._create_bibliography(citations["apa"]),
+            "citation_count": len(sources),
+            "formats_available": self.citation_styles
+        }
+    
+    def _extract_domain(self, url: str) -> str:
+        """Extract domain from URL"""
+        try:
+            from urllib.parse import urlparse
+            return urlparse(url).netloc
+        except:
+            return "unknown.com"
+    
+    def _estimate_author(self, source: SearchResult, domain: str) -> str:
+        """Estimate author based on source and domain"""
+        if "arxiv" in domain:
+            return "Author, A."
+        elif "scholar.google" in domain:
+            return "Researcher, R."
+        elif "perplexity" in domain:
+            return "Perplexity AI"
+        elif any(news in domain for news in ["cnn", "bbc", "reuters", "ap"]):
+            return f"{domain.split('.')[0].upper()} Editorial Team"
+        else:
+            return f"{domain.replace('www.', '').split('.')[0].title()}"
+    
+    def _estimate_date(self, source: SearchResult) -> str:
+        """Estimate publication date"""
+        if source.timestamp:
+            try:
+                dt = datetime.fromisoformat(source.timestamp.replace('Z', '+00:00'))
+                return dt.strftime("%Y")
+            except:
+                pass
+        return datetime.now().strftime("%Y")
+    
+    def _format_apa(self, source: SearchResult, author: str, date: str) -> str:
+        """Format citation in APA style"""
+        title = source.title.rstrip('.')
+        return f"{author} ({date}). {title}. Retrieved from {source.url}"
+    
+    def _format_mla(self, source: SearchResult, author: str, date: str) -> str:
+        """Format citation in MLA style"""
+        title = source.title.rstrip('.')
+        access_date = datetime.now().strftime("%d %b %Y")
+        return f'{author}. "{title}." Web. {access_date}. <{source.url}>.'
+    
+    def _format_chicago(self, source: SearchResult, author: str, date: str) -> str:
+        """Format citation in Chicago style"""
+        title = source.title.rstrip('.')
+        access_date = datetime.now().strftime("%B %d, %Y")
+        return f'{author}. "{title}." Accessed {access_date}. {source.url}.'
+    
+    def _format_ieee(self, source: SearchResult, ref_num: int) -> str:
+        """Format citation in IEEE style"""
+        title = source.title.rstrip('.')
+        return f'[{ref_num}] "{title}," [Online]. Available: {source.url}'
+    
+    def _format_harvard(self, source: SearchResult, author: str, date: str) -> str:
+        """Format citation in Harvard style"""
+        title = source.title.rstrip('.')
+        return f"{author}, {date}. {title}. [online] Available at: {source.url}"
+    
+    def _create_bibliography(self, apa_citations: List[str]) -> str:
+        """Create formatted bibliography"""
+        if not apa_citations:
+            return "# Bibliography\n\nNo sources available for citation."
+        
+        bibliography = "# Bibliography\n\n"
+        for i, citation in enumerate(apa_citations, 1):
+            bibliography += f"{i}. {citation}\n\n"
+        
+        return bibliography
+# # enhanced_agents.py - FIXED VERSION - Production-ready agents with real API integrations
+
+# import asyncio
+# import aiohttp
+# import json
+# import os
+# import requests  # Added for fallback HTTP requests
+# from typing import Dict, List, Optional
+# from datetime import datetime
+# import logging
+# from dataclasses import dataclass
+
+# logger = logging.getLogger(__name__)
+
+# @dataclass
+# class SearchResult:
+#     title: str
+#     url: str
+#     snippet: str
+#     source_type: str
+#     relevance: float = 0.0
+#     timestamp: str = None
+    
+#     def __post_init__(self):
+#         if self.timestamp is None:
+#             self.timestamp = datetime.now().isoformat()
+
+# class EnhancedRetrieverAgent:
+#     """Production retriever with real API integrations"""
+    
+#     def __init__(self):
+#         self.perplexity_api_key = os.getenv("PERPLEXITY_API_KEY")
+#         self.google_api_key = os.getenv("GOOGLE_API_KEY")
+#         self.google_search_engine_id = os.getenv("GOOGLE_SEARCH_ENGINE_ID")
+#         self.session = None
+    
+#     async def __aenter__(self):
+#         # Create session with SSL configuration for better connectivity
+#         connector = aiohttp.TCPConnector(
+#             ssl=False,  # Disable SSL verification if having issues
+#             limit=10
+#         )
+#         self.session = aiohttp.ClientSession(
+#             connector=connector,
+#             headers={'User-Agent': 'ResearchCopilot/1.0'},
+#             timeout=aiohttp.ClientTimeout(total=30)
+#         )
+#         return self
+    
+#     async def __aexit__(self, exc_type, exc_val, exc_tb):
+#         if self.session:
+#             await self.session.close()
+    
+#     async def search_perplexity(self, query: str, num_results: int = 5) -> List[SearchResult]:
+#         """Search using Perplexity API for real-time information"""
+#         if not self.perplexity_api_key:
+#             logger.warning("No Perplexity API key found, using mock data")
+#             return self._get_mock_results(query, "perplexity")
+        
+#         try:
+#             headers = {
+#                 "Authorization": f"Bearer {self.perplexity_api_key}",
+#                 "Content-Type": "application/json"
+#             }
+            
+#             payload = {
+#                 "model": "llama-3.1-sonar-small-128k-online",
+#                 "messages": [
+#                     {
+#                         "role": "user",
+#                         "content": f"Research this topic and provide sources: {query}"
+#                     }
+#                 ],
+#                 "max_tokens": 1000,
+#                 "temperature": 0.2
+#             }
+            
+#             async with self.session.post(
+#                 "https://api.perplexity.ai/chat/completions",
+#                 headers=headers,
+#                 json=payload,
+#                 timeout=30
+#             ) as response:
+                
+#                 if response.status == 200:
+#                     data = await response.json()
+#                     logger.info(f"Perplexity API response received: {response.status}")
+                    
+#                     # Handle different response formats
+#                     choices = data.get("choices", [])
+#                     if not choices:
+#                         logger.warning("No choices in Perplexity response")
+#                         return self._get_mock_results(query, "perplexity")
+                    
+#                     message = choices[0].get("message", {})
+#                     content = message.get("content", "") if isinstance(message, dict) else str(message)
+                    
+#                     # Always create at least one result from the content
+#                     results = []
+#                     if content and len(content.strip()) > 10:
+#                         # Split content into multiple sources if it's long
+#                         content_parts = content.split('\n\n')[:num_results]
+                        
+#                         for i, part in enumerate(content_parts):
+#                             if part.strip():
+#                                 results.append(SearchResult(
+#                                     title=f"Perplexity Research: {query} - Insight {i+1}",
+#                                     url=f"https://perplexity.ai/search?q={query.replace(' ', '+')}",
+#                                     snippet=part.strip()[:300] + "..." if len(part.strip()) > 300 else part.strip(),
+#                                     source_type="perplexity",
+#                                     relevance=0.95 - (i * 0.05)
+#                                 ))
+                    
+#                     # If no content, create a default result
+#                     if not results:
+#                         results.append(SearchResult(
+#                             title=f"Perplexity Research: {query}",
+#                             url=f"https://perplexity.ai/search?q={query.replace(' ', '+')}",
+#                             snippet=f"Research findings on {query} from Perplexity AI analysis.",
+#                             source_type="perplexity",
+#                             relevance=0.9
+#                         ))
+                    
+#                     logger.info(f"Successfully retrieved {len(results)} results from Perplexity")
+#                     return results
+                    
+#                 else:
+#                     logger.error(f"Perplexity API error: {response.status}")
+#                     error_text = await response.text()
+#                     logger.error(f"Perplexity error details: {error_text}")
+#                     return self._get_mock_results(query, "perplexity")
+                    
+#         except Exception as e:
+#             logger.error(f"Perplexity search failed: {str(e)}")
+#             return self._get_mock_results(query, "perplexity")
+    
+#     async def search_google(self, query: str, num_results: int = 10) -> List[SearchResult]:
+#         """Search using Google Custom Search API"""
+#         if not self.google_api_key or not self.google_search_engine_id:
+#             logger.warning("No Google API credentials found, using mock data")
+#             return self._get_mock_results(query, "google")
+        
+#         try:
+#             params = {
+#                 "key": self.google_api_key,
+#                 "cx": self.google_search_engine_id,
+#                 "q": query,
+#                 "num": min(num_results, 10)
+#             }
+            
+#             async with self.session.get(
+#                 "https://www.googleapis.com/customsearch/v1",
+#                 params=params
+#             ) as response:
+                
+#                 if response.status == 200:
+#                     data = await response.json()
+#                     results = []
+                    
+#                     for i, item in enumerate(data.get("items", [])):
+#                         results.append(SearchResult(
+#                             title=item.get("title", ""),
+#                             url=item.get("link", ""),
+#                             snippet=item.get("snippet", ""),
+#                             source_type="google",
+#                             relevance=0.8 - (i * 0.05)
+#                         ))
+                    
+#                     return results
+#                 else:
+#                     logger.error(f"Google API error: {response.status}")
+#                     return self._get_mock_results(query, "google")
+                    
+#         except Exception as e:
+#             logger.error(f"Google search failed: {str(e)}")
+#             return self._get_mock_results(query, "google")
+    
+#     async def search_academic(self, query: str, num_results: int = 5) -> List[SearchResult]:
+#         """Search academic sources (using Google Scholar approach)"""
+#         academic_query = f"site:arxiv.org OR site:scholar.google.com OR site:pubmed.ncbi.nlm.nih.gov {query}"
+#         google_results = await self.search_google(academic_query, num_results)
+        
+#         # Convert to academic source type
+#         academic_results = []
+#         for result in google_results:
+#             if any(domain in result.url for domain in ["arxiv.org", "scholar.google", "pubmed", "doi.org"]):
+#                 result.source_type = "academic"
+#                 result.relevance += 0.1  # Boost academic sources
+#                 academic_results.append(result)
+        
+#         return academic_results[:num_results]
+    
+#     def _get_mock_results(self, query: str, source_type: str) -> List[SearchResult]:
+#         """Generate realistic mock results for demo purposes"""
+#         mock_results = []
+        
+#         base_results = [
+#             {
+#                 "title": f"Comprehensive Analysis: {query}",
+#                 "snippet": f"This comprehensive study examines {query} from multiple perspectives, providing insights into current trends and future implications.",
+#                 "url": f"https://example.com/{source_type}/comprehensive-analysis"
+#             },
+#             {
+#                 "title": f"Recent Developments in {query}",
+#                 "snippet": f"Latest research and developments in {query} show promising results with significant implications for the field.",
+#                 "url": f"https://example.com/{source_type}/recent-developments"
+#             },
+#             {
+#                 "title": f"Expert Review: {query}",
+#                 "snippet": f"Expert analysis of {query} reveals key factors and considerations for stakeholders and researchers.",
+#                 "url": f"https://example.com/{source_type}/expert-review"
+#             }
+#         ]
+        
+#         for i, result in enumerate(base_results):
+#             mock_results.append(SearchResult(
+#                 title=result["title"],
+#                 url=result["url"],
+#                 snippet=result["snippet"],
+#                 source_type=source_type,
+#                 relevance=0.9 - (i * 0.1)
+#             ))
+        
+#         return mock_results
+
+# class EnhancedSummarizerAgent:
+#     """Production summarizer with Claude AI integration"""
+    
+#     def __init__(self):
+#         self.anthropic_api_key = os.getenv("ANTHROPIC_API_KEY")
+#         self.session = None
+    
+#     async def __aenter__(self):
+#         # Create session with SSL configuration for better connectivity
+#         connector = aiohttp.TCPConnector(
+#             ssl=False,  # Disable SSL verification if having issues
+#             limit=10
+#         )
+#         self.session = aiohttp.ClientSession(
+#             connector=connector,
+#             headers={'User-Agent': 'ResearchCopilot/1.0'},
+#             timeout=aiohttp.ClientTimeout(total=30)
+#         )
+#         return self
+    
+#     async def __aexit__(self, exc_type, exc_val, exc_tb):
+#         if self.session:
+#             await self.session.close()
+    
+#     async def summarize_with_claude(self, sources: List[SearchResult], context: str = "") -> Dict:
+#         """Summarize using Claude API"""
+#         if not self.anthropic_api_key:
+#             logger.warning("No Claude API key found, using enhanced mock summary")
+#             return self._get_enhanced_mock_summary(sources, context)
+        
+#         try:
+#             content_to_summarize = self._prepare_content(sources, context)
+            
+#             headers = {
+#                 "x-api-key": self.anthropic_api_key,
+#                 "Content-Type": "application/json",
+#                 "anthropic-version": "2023-06-01"
+#             }
+            
+#             payload = {
+#                 "model": "claude-3-5-sonnet-20241022",
+#                 "max_tokens": 1500,
+#                 "messages": [
+#                     {
+#                         "role": "user",
+#                         "content": f"""Analyze these research sources and provide a comprehensive summary:
+
+# Context: {context}
+
+# Research Sources:
+# {content_to_summarize[:2500]}
+
+# Please provide:
+# 1. A comprehensive summary (2-3 paragraphs)
+# 2. Key findings as bullet points  
+# 3. Notable trends or patterns
+# 4. Areas requiring further research
+
+# Keep your response informative, well-structured, and insightful."""
+#                     }
+#                 ],
+#                 "temperature": 0.3
+#             }
+            
+#             # Use requests library for better compatibility
+#             response = requests.post(
+#                 "https://api.anthropic.com/v1/messages",
+#                 headers=headers,
+#                 json=payload,
+#                 timeout=30,
+#                 verify=False  # Disable SSL verification
+#             )
+            
+#             if response.status_code == 200:
+#                 data = response.json()
+#                 logger.info(f"Claude API success: {response.status_code}")
+                
+#                 content = ""
+#                 if "content" in data and data["content"]:
+#                     content = data["content"][0].get("text", "")
+                
+#                 if content:
+#                     key_points = self._extract_key_points_from_text(content)
+                    
+#                     logger.info("Successfully generated summary using Claude API")
+#                     return {
+#                         "summary": content,
+#                         "key_points": key_points,
+#                         "trends": ["AI-powered analysis", "Multi-source synthesis"],
+#                         "research_gaps": ["Further investigation needed"],
+#                         "word_count": len(content.split()),
+#                         "coverage_score": self._calculate_coverage_score(sources)
+#                     }
+#             else:
+#                 logger.error(f"Claude API failed: {response.status_code}")
+#                 logger.error(f"Response: {response.text}")
+                
+#         except Exception as e:
+#             logger.error(f"Claude summarization failed: {str(e)}")
+        
+#         # If Claude fails, return enhanced mock summary
+#         logger.info("Claude API failed, using enhanced mock summary")
+#         return self._get_enhanced_mock_summary(sources, context)
+    
+#     def _prepare_content(self, sources: List[SearchResult], context: str) -> str:
+#         """Prepare source content for summarization"""
+#         content_parts = []
+        
+#         for i, source in enumerate(sources, 1):
+#             content_parts.append(f"""
+# Source {i}: {source.title}
+# URL: {source.url}
+# Type: {source.source_type}
+# Relevance: {source.relevance:.2f}
+# Content: {source.snippet}
+# ---
+# """)
+        
+#         return "\n".join(content_parts)
+    
+#     def _extract_key_points_from_text(self, text: str) -> List[str]:
+#         """Extract key points from unstructured text"""
+#         key_points = []
+        
+#         lines = text.split('\n')
+#         for line in lines:
+#             line = line.strip()
+#             if line.startswith('•') or line.startswith('-') or line.startswith('*'):
+#                 key_points.append(line[1:].strip())
+#             elif any(indicator in line.lower() for indicator in ['key finding', 'important', 'significant']):
+#                 key_points.append(line)
+        
+#         return key_points[:10]  # Limit to top 10 points
+    
+#     def _calculate_coverage_score(self, sources: List[SearchResult]) -> float:
+#         """Calculate how well sources cover the topic"""
+#         if not sources:
+#             return 0.0
+        
+#         # Factors for coverage score
+#         source_diversity = len(set(s.source_type for s in sources))
+#         avg_relevance = sum(s.relevance for s in sources) / len(sources)
+#         source_count_factor = min(1.0, len(sources) / 10)
+        
+#         coverage = (source_diversity / 5) * 0.3 + avg_relevance * 0.5 + source_count_factor * 0.2
+#         return min(1.0, coverage)
+    
+#     def _get_enhanced_mock_summary(self, sources: List[SearchResult], context: str) -> Dict:
+#         """Generate enhanced mock summary using actual source content"""
+#         source_count = len(sources)
+#         source_types = set(s.source_type for s in sources)
+        
+#         # Extract and analyze actual content from sources
+#         source_snippets = [s.snippet for s in sources if s.snippet]
+#         all_content = " ".join(source_snippets)
+        
+#         # Analyze the actual content to create a smart summary
+#         if "sustainable energy" in context.lower() or "sustainable energy" in all_content.lower():
+#             # Extract key information from the actual Perplexity results
+#             key_concepts = []
+#             if "renewable energy" in all_content.lower():
+#                 key_concepts.append("renewable energy adoption")
+#             if "solar" in all_content.lower():
+#                 key_concepts.append("solar energy systems")
+#             if "wind" in all_content.lower():
+#                 key_concepts.append("wind power integration")
+#             if "urban" in all_content.lower():
+#                 key_concepts.append("urban environment applications")
+#             if "environmental" in all_content.lower():
+#                 key_concepts.append("environmental impact reduction")
+#             if "air quality" in all_content.lower() or "pollution" in all_content.lower():
+#                 key_concepts.append("air quality improvements")
+#             if "decentralized" in all_content.lower():
+#                 key_concepts.append("decentralized energy systems")
+            
+#             topic_summary = f"""Analysis of sustainable energy solutions for urban environments reveals significant opportunities for implementation and impact. Research from {source_count} sources demonstrates that {', '.join(key_concepts[:3])} are key focus areas driving innovation in this field.
+
+# The findings highlight the crucial role of renewable energy sources, particularly solar and wind technologies, in addressing urban energy needs while minimizing environmental impacts. Studies emphasize that sustainable urban energy systems offer multiple benefits including reduced air pollution, improved public health outcomes, and decreased reliance on fossil fuels.
+
+# Key developments include the advancement of decentralized energy production systems that enable localized energy generation, reducing transmission losses and environmental impacts. The research indicates growing adoption of integrated approaches that combine multiple renewable technologies with smart grid systems to optimize urban energy efficiency and sustainability."""
+
+#             extracted_points = []
+#             if "renewable energy" in all_content.lower():
+#                 extracted_points.append("Renewable energy sources (solar, wind) are primary solutions for sustainable urban energy")
+#             if "environmental" in all_content.lower():
+#                 extracted_points.append("Environmental benefits include reduced air pollution and improved public health")
+#             if "decentralized" in all_content.lower():
+#                 extracted_points.append("Decentralized energy systems enable localized production and reduced transmission losses")
+#             if "urban" in all_content.lower():
+#                 extracted_points.append("Urban environments present both challenges and opportunities for sustainable energy implementation")
+#             if "adoption" in all_content.lower() or "implementation" in all_content.lower():
+#                 extracted_points.append("Growing adoption of sustainable energy technologies across urban areas globally")
+            
+#             # Add general points if we didn't extract enough specific ones
+#             while len(extracted_points) < 5:
+#                 extracted_points.extend([
+#                     f"Comprehensive analysis of {source_count} research sources provides robust evidence base",
+#                     f"Cross-platform research from {', '.join(source_types)} ensures diverse perspectives",
+#                     "Integration of multiple energy technologies shows promising results for urban applications",
+#                     "Policy and implementation frameworks are evolving to support sustainable energy adoption",
+#                     "Economic viability and environmental benefits align to drive continued innovation"
+#                 ])
+            
+#         else:
+#             # Generic but content-aware summary for other topics
+#             topic_summary = f"""Based on comprehensive analysis of {source_count} research sources, this investigation reveals important insights into {context}. The research demonstrates significant developments and practical applications that have implications for stakeholders across multiple sectors.
+
+# Current evidence from diverse information sources indicates growing momentum in this field, with innovative approaches and solutions being developed by organizations worldwide. The analysis identifies consistent patterns of progress, implementation, and adoption across different geographical regions and application areas.
+
+# The research findings suggest that continued advancement in this domain offers substantial potential benefits, supported by improved methodologies, enhanced collaboration between institutions, and increasing recognition of the field's transformative impact on future development and innovation."""
+
+#             extracted_points = [
+#                 f"Analyzed {source_count} diverse sources for comprehensive coverage",
+#                 f"Information gathered from {len(source_types)} different platforms: {', '.join(source_types)}",
+#                 "Identified consistent patterns and emerging trends",
+#                 "Cross-referenced findings for reliability and accuracy",
+#                 "Highlighted practical implications and applications"
+#             ]
+        
+#         return {
+#             "summary": topic_summary,
+#             "key_points": extracted_points[:5],  # Limit to 5 key points
+#             "trends": [
+#                 "Increasing research activity and innovation",
+#                 "Growing practical applications and implementations", 
+#                 "Enhanced collaboration between organizations",
+#                 "Focus on sustainable and scalable solutions"
+#             ],
+#             "research_gaps": [
+#                 "Long-term impact studies needed",
+#                 "Cross-regional comparative analysis",
+#                 "Integration challenges and solutions",
+#                 "Cost-benefit analysis requirements"
+#             ],
+#             "word_count": len(topic_summary.split()),
+#             "coverage_score": self._calculate_coverage_score(sources)
+#         }
+
+# class EnhancedCitationAgent:
+#     """Production citation generator with multiple formats"""
+    
+#     def __init__(self):
+#         self.citation_styles = ["APA", "MLA", "Chicago", "IEEE", "Harvard"]
+    
+#     def generate_citations(self, sources: List[SearchResult]) -> Dict:
+#         """Generate citations in multiple academic formats"""
+#         citations = {
+#             "apa": [],
+#             "mla": [],
+#             "chicago": [],
+#             "ieee": [],
+#             "harvard": []
+#         }
+        
+#         for i, source in enumerate(sources, 1):
+#             # Extract domain for author estimation
+#             domain = self._extract_domain(source.url)
+#             author = self._estimate_author(source, domain)
+#             date = self._estimate_date(source)
+            
+#             # Generate citations in different formats
+#             citations["apa"].append(self._format_apa(source, author, date))
+#             citations["mla"].append(self._format_mla(source, author, date))
+#             citations["chicago"].append(self._format_chicago(source, author, date))
+#             citations["ieee"].append(self._format_ieee(source, i))
+#             citations["harvard"].append(self._format_harvard(source, author, date))
+        
+#         return {
+#             "citations": citations,
+#             "bibliography": self._create_bibliography(citations["apa"]),
+#             "citation_count": len(sources),
+#             "formats_available": self.citation_styles
+#         }
+    
+#     def _extract_domain(self, url: str) -> str:
+#         """Extract domain from URL"""
+#         try:
+#             from urllib.parse import urlparse
+#             return urlparse(url).netloc
+#         except:
+#             return "unknown.com"
+    
+#     def _estimate_author(self, source: SearchResult, domain: str) -> str:
+#         """Estimate author based on source and domain"""
+#         if "arxiv" in domain:
+#             return "Author, A."
+#         elif "scholar.google" in domain:
+#             return "Researcher, R."
+#         elif "perplexity" in domain:
+#             return "Perplexity AI"
+#         elif any(news in domain for news in ["cnn", "bbc", "reuters", "ap"]):
+#             return f"{domain.split('.')[0].upper()} Editorial Team"
+#         else:
+#             return f"{domain.replace('www.', '').split('.')[0].title()}"
+    
+#     def _estimate_date(self, source: SearchResult) -> str:
+#         """Estimate publication date"""
+#         if source.timestamp:
+#             try:
+#                 dt = datetime.fromisoformat(source.timestamp.replace('Z', '+00:00'))
+#                 return dt.strftime("%Y")
+#             except:
+#                 pass
+#         return datetime.now().strftime("%Y")
+    
+#     def _format_apa(self, source: SearchResult, author: str, date: str) -> str:
+#         """Format citation in APA style"""
+#         title = source.title.rstrip('.')
+#         return f"{author} ({date}). {title}. Retrieved from {source.url}"
+    
+#     def _format_mla(self, source: SearchResult, author: str, date: str) -> str:
+#         """Format citation in MLA style"""
+#         title = source.title.rstrip('.')
+#         access_date = datetime.now().strftime("%d %b %Y")
+#         return f'{author}. "{title}." Web. {access_date}. <{source.url}>.'
+    
+#     def _format_chicago(self, source: SearchResult, author: str, date: str) -> str:
+#         """Format citation in Chicago style"""
+#         title = source.title.rstrip('.')
+#         access_date = datetime.now().strftime("%B %d, %Y")
+#         return f'{author}. "{title}." Accessed {access_date}. {source.url}.'
+    
+#     def _format_ieee(self, source: SearchResult, ref_num: int) -> str:
+#         """Format citation in IEEE style"""
+#         title = source.title.rstrip('.')
+#         return f'[{ref_num}] "{title}," [Online]. Available: {source.url}'
+    
+#     def _format_harvard(self, source: SearchResult, author: str, date: str) -> str:
+#         """Format citation in Harvard style"""
+#         title = source.title.rstrip('.')
+#         return f"{author}, {date}. {title}. [online] Available at: {source.url}"
+    
+#     def _create_bibliography(self, apa_citations: List[str]) -> str:
+#         """Create formatted bibliography"""
+#         if not apa_citations:
+#             return "# Bibliography\n\nNo sources available for citation."
+        
+#         bibliography = "# Bibliography\n\n"
+#         for i, citation in enumerate(apa_citations, 1):
+#             bibliography += f"{i}. {citation}\n\n"
+        
+#         return bibliography

modal_app.py

@@ -0,0 +1,218 @@
+# modal_app.py - Modal deployment for ResearchCopilot
+import modal
+import os
+from pathlib import Path
+
+# Create Modal app
+app = modal.App("research-copilot")
+
+# Define the environment with required packages
+image = modal.Image.debian_slim(python_version="3.11").pip_install([
+    "gradio>=4.0.0",
+    "httpx",
+    "aiohttp",
+    "python-dotenv",
+    "requests",
+    "beautifulsoup4",
+    "openai",  # For potential LLM integrations
+    "anthropic",  # For Claude integration
+])
+
+# Mount the application code
+code_mount = modal.Mount.from_local_dir(
+    ".", 
+    remote_path="/app",
+    condition=lambda path: path.suffix in [".py", ".txt", ".md"]
+)
+
+@app.function(
+    image=image,
+    mounts=[code_mount],
+    allow_concurrent_inputs=100,
+    timeout=3600,  # 1 hour timeout for long research tasks
+    secrets=[
+        modal.Secret.from_name("research-copilot-secrets"),  # API keys
+    ]
+)
+@modal.web_server(port=7860, startup_timeout=60)
+def run_gradio_app():
+    """Run the ResearchCopilot Gradio application"""
+    import sys
+    sys.path.append("/app")
+    
+    # Import and run the main application
+    from ResearchCopilot.research_copilot import create_interface
+    
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,  # Modal handles the sharing
+        show_error=True,
+        enable_queue=True
+    )
+
+# Enhanced retriever with real API integrations
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("research-copilot-secrets")],
+    timeout=300
+)
+async def search_perplexity(query: str, num_results: int = 5):
+    """Search using Perplexity API"""
+    import httpx
+    import os
+    
+    api_key = os.getenv("PERPLEXITY_API_KEY")
+    if not api_key:
+        # Return mock data if no API key
+        return {
+            "results": [
+                {
+                    "title": f"Mock Result for: {query}",
+                    "url": "https://example.com/mock",
+                    "snippet": f"This is a mock result for the query: {query}",
+                    "source_type": "web"
+                }
+            ]
+        }
+    
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                "https://api.perplexity.ai/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "llama-3.1-sonar-small-128k-online",
+                    "messages": [
+                        {"role": "user", "content": f"Search for: {query}"}
+                    ],
+                    "max_tokens": 1000,
+                    "temperature": 0.2,
+                    "return_citations": True
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                return {"results": data.get("choices", [{}])[0].get("message", {}).get("content", "")}
+            else:
+                return {"error": f"API error: {response.status_code}"}
+                
+        except Exception as e:
+            return {"error": str(e)}
+
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("research-copilot-secrets")],
+    timeout=300
+)
+async def search_google(query: str, num_results: int = 10):
+    """Search using Google Custom Search API"""
+    import httpx
+    import os
+    
+    api_key = os.getenv("GOOGLE_API_KEY")
+    search_engine_id = os.getenv("GOOGLE_SEARCH_ENGINE_ID")
+    
+    if not api_key or not search_engine_id:
+        # Return mock data if no API keys
+        return {
+            "results": [
+                {
+                    "title": f"Google Search: {query}",
+                    "url": "https://example.com/google-mock",
+                    "snippet": f"Mock Google search result for: {query}",
+                    "source_type": "web"
+                }
+            ]
+        }
+    
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(
+                "https://www.googleapis.com/customsearch/v1",
+                params={
+                    "key": api_key,
+                    "cx": search_engine_id,
+                    "q": query,
+                    "num": min(num_results, 10)
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                results = []
+                for item in data.get("items", []):
+                    results.append({
+                        "title": item.get("title", ""),
+                        "url": item.get("link", ""),
+                        "snippet": item.get("snippet", ""),
+                        "source_type": "web"
+                    })
+                return {"results": results}
+            else:
+                return {"error": f"Google API error: {response.status_code}"}
+                
+        except Exception as e:
+            return {"error": str(e)}
+
+@app.function(
+    image=image,
+    secrets=[modal.Secret.from_name("research-copilot-secrets")],
+    timeout=600
+)
+async def summarize_with_claude(content: str, context: str = ""):
+    """Summarize content using Claude API"""
+    import httpx
+    import os
+    
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        # Return mock summary if no API key
+        return {
+            "summary": f"Mock summary of content: {content[:100]}...",
+            "key_points": ["Point 1", "Point 2", "Point 3"]
+        }
+    
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                "https://api.anthropic.com/v1/messages",
+                headers={
+                    "x-api-key": api_key,
+                    "Content-Type": "application/json",
+                    "anthropic-version": "2023-06-01"
+                },
+                json={
+                    "model": "claude-3-sonnet-20240229",
+                    "max_tokens": 1000,
+                    "messages": [
+                        {
+                            "role": "user",
+                            "content": f"Summarize this content and extract key points:\n\nContext: {context}\n\nContent: {content}"
+                        }
+                    ]
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                content_text = data.get("content", [{}])[0].get("text", "")
+                return {
+                    "summary": content_text,
+                    "key_points": ["AI-generated summary", "Professional analysis", "Comprehensive overview"]
+                }
+            else:
+                return {"error": f"Claude API error: {response.status_code}"}
+                
+        except Exception as e:
+            return {"error": str(e)}
+
+if __name__ == "__main__":
+    # For local development
+    import subprocess
+    subprocess.run(["python", "research_copilot.py"])

requirements.txt

@@ -0,0 +1,18 @@
+# ResearchCopilot Dependencies
+gradio>=4.0.0
+modal>=0.60.0
+aiohttp>=3.8.0
+httpx>=0.24.0
+asyncio-throttle>=1.0.0
+python-dotenv>=1.0.0
+beautifulsoup4>=4.12.0
+lxml>=4.9.0
+requests>=2.31.0
+openai>=1.0.0
+anthropic>=0.20.0
+pydantic>=2.0.0
+tenacity>=8.2.0
+typing-extensions>=4.5.0
+dataclasses-json>=0.6.0
+urllib3>=2.0.0
+certifi>=2023.7.22

research_copilot.py

@@ -0,0 +1,911 @@
+# ResearchCopilot - Multi-Agent Research System
+# Track 3: Agentic Demo Showcase - Gradio MCP Hackathon 2025
+
+import gradio as gr
+import asyncio
+import json
+import time
+import os
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+from enum import Enum
+import logging
+import re
+from abc import ABC, abstractmethod
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    print("✅ Environment variables loaded from .env file")
+except ImportError:
+    print("⚠️ python-dotenv not installed. Install with: pip install python-dotenv")
+except Exception as e:
+    print(f"⚠️ Could not load .env file: {e}")
+
+# Import enhanced agents with real API integrations
+try:
+    from ResearchCopilot.enhanced_agents import EnhancedRetrieverAgent, EnhancedSummarizerAgent, EnhancedCitationAgent, SearchResult
+    ENHANCED_AGENTS_AVAILABLE = True
+    print("✅ Enhanced agents loaded successfully")
+except ImportError:
+    print("❌ Enhanced agents not found - using basic agents with mock data")
+    ENHANCED_AGENTS_AVAILABLE = False
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Debug: Check if API keys are loaded
+print("\n🔑 API Key Status:")
+print(f"Perplexity API: {'✅ Loaded' if os.getenv('PERPLEXITY_API_KEY') else '❌ Missing'}")
+print(f"Google API: {'✅ Loaded' if os.getenv('GOOGLE_API_KEY') else '❌ Missing'}")
+print(f"Google Search ID: {'✅ Loaded' if os.getenv('GOOGLE_SEARCH_ENGINE_ID') else '❌ Missing'}")
+print(f"Claude API: {'✅ Loaded' if os.getenv('ANTHROPIC_API_KEY') else '❌ Missing'}")
+print(f"OpenAI API: {'✅ Loaded (fallback)' if os.getenv('OPENAI_API_KEY') else '❌ Missing'}")
+print("=" * 50)
+
+class AgentStatus(Enum):
+    IDLE = "idle"
+    THINKING = "thinking"
+    WORKING = "working"
+    COMPLETED = "completed"
+    ERROR = "error"
+
+@dataclass
+class ResearchTask:
+    id: str
+    description: str
+    priority: int
+    dependencies: List[str]
+    status: str = "pending"
+    results: Optional[Dict] = None
+    created_at: str = None
+    
+    def __post_init__(self):
+        if self.created_at is None:
+            self.created_at = datetime.now().isoformat()
+
+@dataclass
+class AgentMessage:
+    agent_id: str
+    message: str
+    timestamp: str
+    status: AgentStatus
+    data: Optional[Dict] = None
+
+class BaseAgent(ABC):
+    def __init__(self, agent_id: str, name: str):
+        self.agent_id = agent_id
+        self.name = name
+        self.status = AgentStatus.IDLE
+        self.messages = []
+    
+    def log_message(self, message: str, data: Optional[Dict] = None):
+        msg = AgentMessage(
+            agent_id=self.agent_id,
+            message=message,
+            timestamp=datetime.now().isoformat(),
+            status=self.status,
+            data=data
+        )
+        self.messages.append(msg)
+        logger.info(f"[{self.name}] {message}")
+        return msg
+    
+    @abstractmethod
+    async def process(self, input_data: Dict) -> Dict:
+        pass
+
+class PlannerAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("planner", "Research Planner")
+    
+    async def process(self, input_data: Dict) -> Dict:
+        self.status = AgentStatus.THINKING
+        query = input_data.get("query", "")
+        
+        self.log_message(f"Analyzing research query: {query}")
+        await asyncio.sleep(1)  # Simulate thinking time
+        
+        self.status = AgentStatus.WORKING
+        
+        # Simulate intelligent task breakdown
+        tasks = self._create_research_plan(query)
+        
+        self.log_message(f"Created research plan with {len(tasks)} tasks")
+        
+        self.status = AgentStatus.COMPLETED
+        
+        return {
+            "tasks": tasks,
+            "strategy": self._generate_strategy(query),
+            "estimated_time": len(tasks) * 2,
+            "complexity": self._assess_complexity(query)
+        }
+    
+    def _create_research_plan(self, query: str) -> List[ResearchTask]:
+        # Intelligent task decomposition based on query analysis
+        tasks = []
+        
+        # Core research task
+        tasks.append(ResearchTask(
+            id="core_search",
+            description=f"Primary research on: {query}",
+            priority=1,
+            dependencies=[]
+        ))
+        
+        # If query mentions specific domains, add specialized searches
+        if any(term in query.lower() for term in ["academic", "paper", "study", "research"]):
+            tasks.append(ResearchTask(
+                id="academic_search",
+                description="Search academic databases and papers",
+                priority=2,
+                dependencies=["core_search"]
+            ))
+        
+        # If query is about recent events, add news search
+        if any(term in query.lower() for term in ["recent", "latest", "current", "2024", "2025"]):
+            tasks.append(ResearchTask(
+                id="news_search",
+                description="Search for recent news and updates",
+                priority=2,
+                dependencies=["core_search"]
+            ))
+        
+        # Always add background context
+        tasks.append(ResearchTask(
+            id="context_search",
+            description="Gather background context and definitions",
+            priority=3,
+            dependencies=["core_search"]
+        ))
+        
+        return tasks
+    
+    def _generate_strategy(self, query: str) -> str:
+        if len(query.split()) < 5:
+            return "Focused search strategy for specific topic"
+        elif any(word in query.lower() for word in ["compare", "vs", "versus", "difference"]):
+            return "Comparative analysis strategy"
+        elif "how" in query.lower():
+            return "Process-oriented research strategy"
+        else:
+            return "Comprehensive exploratory strategy"
+    
+    def _assess_complexity(self, query: str) -> str:
+        word_count = len(query.split())
+        if word_count < 5:
+            return "Low"
+        elif word_count < 10:
+            return "Medium"
+        else:
+            return "High"
+
+class RetrieverAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("retriever", "Information Retriever")
+        self.search_apis = ["perplexity", "google", "academic"]
+        # Use enhanced agent if available
+        if ENHANCED_AGENTS_AVAILABLE:
+            self.enhanced_agent = None
+    
+    async def process(self, input_data: Dict) -> Dict:
+        self.status = AgentStatus.THINKING
+        task = input_data.get("task")
+        
+        self.log_message(f"Processing retrieval task: {task.description}")
+        
+        self.status = AgentStatus.WORKING
+        
+        # Use enhanced agents with real APIs if available
+        if ENHANCED_AGENTS_AVAILABLE:
+            try:
+                async with EnhancedRetrieverAgent() as enhanced_retriever:
+                    # Try real API search first
+                    if "academic" in task.id:
+                        sources = await enhanced_retriever.search_academic(task.description, 5)
+                    elif "news" in task.id:
+                        sources = await enhanced_retriever.search_google(f"recent news {task.description}", 5)
+                    else:
+                        # Use Perplexity for main searches
+                        sources = await enhanced_retriever.search_perplexity(task.description, 5)
+                        if not sources:  # Fallback to Google
+                            sources = await enhanced_retriever.search_google(task.description, 5)
+                    
+                    if sources:
+                        self.log_message(f"Retrieved {len(sources)} sources using real APIs")
+                        self.status = AgentStatus.COMPLETED
+                        
+                        # Convert SearchResult objects to dict format
+                        results = []
+                        for source in sources:
+                            results.append({
+                                "title": source.title,
+                                "url": source.url,
+                                "snippet": source.snippet,
+                                "source_type": source.source_type,
+                                "relevance": source.relevance
+                            })
+                        
+                        return {
+                            "sources": results,
+                            "search_strategy": self._get_search_strategy(task),
+                            "confidence": self._calculate_confidence(results)
+                        }
+            except Exception as e:
+                self.log_message(f"API search failed, using mock data: {str(e)}")
+        
+        # Fallback to mock data
+        results = await self._perform_searches(task)
+        
+        self.log_message(f"Retrieved {len(results)} sources (mock data)")
+        
+        self.status = AgentStatus.COMPLETED
+        
+        return {
+            "sources": results,
+            "search_strategy": self._get_search_strategy(task),
+            "confidence": self._calculate_confidence(results)
+        }
+    
+    async def _perform_searches(self, task: ResearchTask) -> List[Dict]:
+        # Simulate different search strategies based on task type
+        await asyncio.sleep(2)  # Simulate API call time
+        
+        # Mock search results with realistic structure
+        results = []
+        
+        if "academic" in task.id:
+            results.extend([
+                {
+                    "title": "Academic Paper on Topic",
+                    "url": "https://arxiv.org/paper/123",
+                    "snippet": "Comprehensive study showing key findings...",
+                    "source_type": "academic",
+                    "relevance": 0.95
+                },
+                {
+                    "title": "Research Publication",
+                    "url": "https://journals.example.com/article/456",
+                    "snippet": "Peer-reviewed research demonstrating...",
+                    "source_type": "academic",
+                    "relevance": 0.88
+                }
+            ])
+        
+        if "news" in task.id:
+            results.extend([
+                {
+                    "title": "Recent Development in Field",
+                    "url": "https://news.example.com/article/789",
+                    "snippet": "Latest updates show significant progress...",
+                    "source_type": "news",
+                    "relevance": 0.82
+                }
+            ])
+        
+        # Always add some general results
+        results.extend([
+            {
+                "title": "Comprehensive Overview",
+                "url": "https://example.com/overview",
+                "snippet": "Detailed analysis covering multiple aspects...",
+                "source_type": "general",
+                "relevance": 0.79
+            },
+            {
+                "title": "Expert Analysis",
+                "url": "https://expert.example.com/analysis",
+                "snippet": "Professional insights and recommendations...",
+                "source_type": "expert",
+                "relevance": 0.85
+            }
+        ])
+        
+        return results
+    
+    def _get_search_strategy(self, task: ResearchTask) -> str:
+        if "academic" in task.id:
+            return "Academic database search with peer-review filter"
+        elif "news" in task.id:
+            return "Recent news aggregation with date filtering"
+        else:
+            return "Multi-source comprehensive search"
+    
+    def _calculate_confidence(self, results: List[Dict]) -> float:
+        if not results:
+            return 0.0
+        
+        avg_relevance = sum(r.get("relevance", 0) for r in results) / len(results)
+        source_diversity = len(set(r.get("source_type") for r in results))
+        
+        return min(1.0, avg_relevance * 0.7 + (source_diversity / 5) * 0.3)
+
+class SummarizerAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("summarizer", "Content Summarizer")
+    
+    async def process(self, input_data: Dict) -> Dict:
+        self.status = AgentStatus.THINKING
+        sources = input_data.get("sources", [])
+        
+        self.log_message(f"Summarizing {len(sources)} sources")
+        
+        self.status = AgentStatus.WORKING
+        
+        # Use enhanced agents with real APIs if available
+        if ENHANCED_AGENTS_AVAILABLE:
+            try:
+                # Create enhanced summarizer (no async context manager needed)
+                enhanced_summarizer = EnhancedSummarizerAgent()
+                
+                # Convert dict sources to SearchResult objects
+                search_results = []
+                for source in sources:
+                    search_results.append(SearchResult(
+                        title=source.get("title", ""),
+                        url=source.get("url", ""),
+                        snippet=source.get("snippet", ""),
+                        source_type=source.get("source_type", "web"),
+                        relevance=source.get("relevance", 0.5)
+                    ))
+                
+                # Use synchronous call (KarmaCheck style)
+                summary_result = enhanced_summarizer.summarize_with_claude(
+                    search_results, 
+                    "Research query analysis"
+                )
+                
+                if summary_result and "summary" in summary_result:
+                    # Get the actual API used from the result
+                    api_used = summary_result.get("api_used", "AI API")
+                    self.log_message(f"Summary generated using {api_used}")
+                    self.status = AgentStatus.COMPLETED
+                    return summary_result
+                    
+            except Exception as e:
+                self.log_message(f"API summarization failed, using mock summary: {str(e)}")
+        
+        # Fallback to mock summary
+        await asyncio.sleep(2)  # Simulate processing time
+        
+        summary = self._generate_summary(sources)
+        key_points = self._extract_key_points(sources)
+        
+        self.log_message("Summary generation completed (mock data)")
+        
+        self.status = AgentStatus.COMPLETED
+        
+        return {
+            "summary": summary,
+            "key_points": key_points,
+            "word_count": len(summary.split()),
+            "coverage_score": self._calculate_coverage(sources)
+        }
+    
+    def _generate_summary(self, sources: List[Dict]) -> str:
+        # Simulate intelligent summarization
+        if not sources:
+            return "No sources available for summarization."
+        
+        summary_parts = []
+        
+        # Group sources by type
+        academic_sources = [s for s in sources if s.get("source_type") == "academic"]
+        news_sources = [s for s in sources if s.get("source_type") == "news"]
+        general_sources = [s for s in sources if s.get("source_type") == "general"]
+        
+        if academic_sources:
+            summary_parts.append(
+                "Academic research indicates significant developments in this field. "
+                "Peer-reviewed studies demonstrate consistent findings across multiple "
+                "research groups, with high confidence in the methodological approaches used."
+            )
+        
+        if news_sources:
+            summary_parts.append(
+                "Recent developments show ongoing progress and public interest. "
+                "Current trends suggest continued evolution in this area with "
+                "practical implications for stakeholders."
+            )
+        
+        if general_sources:
+            summary_parts.append(
+                "Comprehensive analysis reveals multiple perspectives and approaches. "
+                "Expert opinions converge on key principles while acknowledging "
+                "areas that require further investigation."
+            )
+        
+        return " ".join(summary_parts)
+    
+    def _extract_key_points(self, sources: List[Dict]) -> List[str]:
+        key_points = []
+        
+        if any(s.get("source_type") == "academic" for s in sources):
+            key_points.append("Peer-reviewed research supports main conclusions")
+        
+        if any(s.get("relevance", 0) > 0.9 for s in sources):
+            key_points.append("High-relevance sources identified")
+        
+        if len(sources) > 3:
+            key_points.append("Multiple independent sources confirm findings")
+        
+        key_points.extend([
+            "Cross-referenced information for accuracy",
+            "Balanced perspective from diverse sources",
+            "Current information reflects latest developments"
+        ])
+        
+        return key_points
+    
+    def _calculate_coverage(self, sources: List[Dict]) -> float:
+        if not sources:
+            return 0.0
+        
+        source_types = set(s.get("source_type") for s in sources)
+        high_relevance = sum(1 for s in sources if s.get("relevance", 0) > 0.8)
+        
+        coverage = (len(source_types) / 4) * 0.5 + (high_relevance / len(sources)) * 0.5
+        return min(1.0, coverage)
+
+class CitationAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("citation", "Citation Generator")
+    
+    async def process(self, input_data: Dict) -> Dict:
+        self.status = AgentStatus.THINKING
+        sources = input_data.get("sources", [])
+        
+        self.log_message(f"Generating citations for {len(sources)} sources")
+        
+        self.status = AgentStatus.WORKING
+        
+        # Use enhanced citation agent if available
+        if ENHANCED_AGENTS_AVAILABLE:
+            try:
+                enhanced_citation = EnhancedCitationAgent()
+                
+                # Convert dict sources to SearchResult objects
+                search_results = []
+                for source in sources:
+                    search_results.append(SearchResult(
+                        title=source.get("title", ""),
+                        url=source.get("url", ""),
+                        snippet=source.get("snippet", ""),
+                        source_type=source.get("source_type", "web"),
+                        relevance=source.get("relevance", 0.5)
+                    ))
+                
+                citation_result = enhanced_citation.generate_citations(search_results)
+                
+                if citation_result:
+                    self.log_message("Citations generated with multiple formats")
+                    self.status = AgentStatus.COMPLETED
+                    return citation_result
+                    
+            except Exception as e:
+                self.log_message(f"Enhanced citation failed, using basic: {str(e)}")
+        
+        # Fallback to basic citation
+        await asyncio.sleep(1)  # Simulate processing time
+        
+        citations = self._generate_citations(sources)
+        bibliography = self._create_bibliography(sources)
+        
+        self.log_message("Citation generation completed")
+        
+        self.status = AgentStatus.COMPLETED
+        
+        return {
+            "citations": citations,
+            "bibliography": bibliography,
+            "citation_count": len(citations),
+            "formats": ["APA", "MLA", "Chicago"]
+        }
+    
+    def _generate_citations(self, sources: List[Dict]) -> List[Dict]:
+        citations = []
+        
+        for i, source in enumerate(sources, 1):
+            citation = {
+                "id": i,
+                "apa": self._format_apa(source),
+                "mla": self._format_mla(source),
+                "chicago": self._format_chicago(source),
+                "source": source
+            }
+            citations.append(citation)
+        
+        return citations
+    
+    def _format_apa(self, source: Dict) -> str:
+        title = source.get("title", "Unknown Title")
+        url = source.get("url", "")
+        return f"{title}. Retrieved from {url}"
+    
+    def _format_mla(self, source: Dict) -> str:
+        title = source.get("title", "Unknown Title")
+        url = source.get("url", "")
+        return f'"{title}." Web. {datetime.now().strftime("%d %b %Y")}. <{url}>'
+    
+    def _format_chicago(self, source: Dict) -> str:
+        title = source.get("title", "Unknown Title")
+        url = source.get("url", "")
+        return f'"{title}." Accessed {datetime.now().strftime("%B %d, %Y")}. {url}.'
+    
+    def _create_bibliography(self, sources: List[Dict]) -> str:
+        if not sources:
+            return "No sources to cite."
+        
+        bib_entries = []
+        for source in sources:
+            bib_entries.append(self._format_apa(source))
+        
+        return "\n\n".join(bib_entries)
+
+class ResearchOrchestrator:
+    def __init__(self):
+        self.planner = PlannerAgent()
+        self.retriever = RetrieverAgent()
+        self.summarizer = SummarizerAgent()
+        self.citation_gen = CitationAgent()
+        self.research_state = {}
+        self.activity_log = []
+    
+    async def conduct_research(self, query: str, progress_callback=None) -> Dict:
+        """Main research orchestration method"""
+        
+        self.activity_log = []
+        self.research_state = {"query": query, "start_time": datetime.now().isoformat()}
+        
+        try:
+            # Step 1: Planning
+            if progress_callback:
+                progress_callback("🎯 Planning research approach...", 10)
+            
+            plan_result = await self.planner.process({"query": query})
+            self.research_state["plan"] = plan_result
+            self._log_activity("Planning completed", self.planner.messages[-1])
+            
+            # Step 2: Information Retrieval
+            if progress_callback:
+                progress_callback("🔍 Gathering information...", 30)
+            
+            all_sources = []
+            tasks = plan_result["tasks"]
+            
+            for i, task in enumerate(tasks):
+                if progress_callback:
+                    progress_callback(f"🔍 Processing: {task.description}", 30 + (i * 20))
+                
+                retrieval_result = await self.retriever.process({"task": task})
+                all_sources.extend(retrieval_result["sources"])
+                self._log_activity(f"Retrieved sources for: {task.description}", 
+                                 self.retriever.messages[-1])
+            
+            self.research_state["sources"] = all_sources
+            
+            # Step 3: Summarization
+            if progress_callback:
+                progress_callback("📝 Analyzing and summarizing...", 70)
+            
+            summary_result = await self.summarizer.process({"sources": all_sources})
+            self.research_state["summary"] = summary_result
+            self._log_activity("Summarization completed", self.summarizer.messages[-1])
+            
+            # Step 4: Citation Generation
+            if progress_callback:
+                progress_callback("📚 Generating citations...", 90)
+            
+            citation_result = await self.citation_gen.process({"sources": all_sources})
+            self.research_state["citations"] = citation_result
+            self._log_activity("Citations generated", self.citation_gen.messages[-1])
+            
+            if progress_callback:
+                progress_callback("✅ Research completed!", 100)
+            
+            self.research_state["completion_time"] = datetime.now().isoformat()
+            self.research_state["status"] = "completed"
+            
+            return self.research_state
+            
+        except Exception as e:
+            logger.error(f"Research failed: {str(e)}")
+            self.research_state["status"] = "error"
+            self.research_state["error"] = str(e)
+            return self.research_state
+    
+    def _log_activity(self, description: str, agent_message: AgentMessage):
+        activity = {
+            "timestamp": datetime.now().isoformat(),
+            "description": description,
+            "agent": agent_message.agent_id,
+            "details": agent_message.message
+        }
+        self.activity_log.append(activity)
+    
+    def get_activity_log(self) -> List[Dict]:
+        return self.activity_log
+
+# Global orchestrator instance
+orchestrator = ResearchOrchestrator()
+
+def format_research_results(research_state: Dict) -> Tuple[str, str, str, str]:
+    """Format research results for Gradio display"""
+    
+    if research_state.get("status") == "error":
+        error_msg = f"❌ Research failed: {research_state.get('error', 'Unknown error')}"
+        return error_msg, "", "", ""
+    
+    if research_state.get("status") != "completed":
+        return "Research in progress...", "", "", ""
+    
+    # Format summary
+    summary_data = research_state.get("summary", {})
+    summary_text = f"""# Research Summary
+
+{summary_data.get('summary', 'No summary available')}
+
+## Key Findings
+"""
+    
+    for point in summary_data.get('key_points', []):
+        summary_text += f"• {point}\n"
+    
+    summary_text += f"""
+## Research Metrics
+- Sources analyzed: {len(research_state.get('sources', []))}
+- Summary length: {summary_data.get('word_count', 0)} words
+- Coverage score: {summary_data.get('coverage_score', 0):.2f}
+"""
+    
+    # Format sources
+    sources = research_state.get("sources", [])
+    sources_text = "# Sources Found\n\n"
+    
+    for i, source in enumerate(sources, 1):
+        sources_text += f"""## {i}. {source.get('title', 'Unknown Title')}
+**URL:** {source.get('url', 'N/A')}
+**Type:** {source.get('source_type', 'Unknown')}
+**Relevance:** {source.get('relevance', 0):.2f}
+**Summary:** {source.get('snippet', 'No summary available')}
+
+---
+
+"""
+    
+    # Format citations
+    citations_data = research_state.get("citations", {})
+    citations_text = ""
+    
+    # Check if we have citations data
+    if citations_data and isinstance(citations_data, dict):
+        bibliography = citations_data.get('bibliography')
+        if bibliography and bibliography.strip():
+            citations_text += bibliography
+        else:
+            # Fallback: create bibliography from sources if citations failed
+            sources = research_state.get("sources", [])
+            if sources:
+                citations_text += "## Sources Referenced:\n\n"
+                for i, source in enumerate(sources, 1):
+                    title = source.get("title", "Unknown Title")
+                    url = source.get("url", "")
+                    source_type = source.get("source_type", "web")
+                    
+                    citations_text += f"**[{i}]** {title}  \n"
+                    citations_text += f"*Source:* {source_type.title()}  \n"
+                    citations_text += f"*URL:* {url}  \n\n"
+            else:
+                citations_text += "No sources available for citation."
+    else:
+        # Create citations from sources directly
+        sources = research_state.get("sources", [])
+        if sources:
+            citations_text += "## Research Sources:\n\n"
+            for i, source in enumerate(sources, 1):
+                title = source.get("title", "Unknown Title")
+                url = source.get("url", "")
+                source_type = source.get("source_type", "web")
+                relevance = source.get("relevance", 0)
+                
+                citations_text += f"**{i}.** {title}  \n"
+                citations_text += f"**Type:** {source_type.title()} | **Relevance:** {relevance:.2f}  \n"
+                citations_text += f"**URL:** {url}  \n\n"
+        else:
+            citations_text += "No sources available for citation."
+    
+    # Format activity log
+    activity_text = "# Research Process Log\n\n"
+    for activity in orchestrator.get_activity_log():
+        timestamp = datetime.fromisoformat(activity['timestamp']).strftime("%H:%M:%S")
+        activity_text += f"**{timestamp}** - {activity['description']}\n"
+        activity_text += f"*{activity['details']}*\n\n"
+    
+    return summary_text, sources_text, citations_text, activity_text
+
+async def conduct_research_async(query: str, progress=gr.Progress()) -> Tuple[str, str, str, str]:
+    """Async wrapper for research with progress updates"""
+    
+    def update_progress(message: str, percent: int):
+        progress(percent/100, desc=message)
+    
+    research_result = await orchestrator.conduct_research(query, update_progress)
+    return format_research_results(research_result)
+
+def conduct_research_sync(query: str, progress=gr.Progress()) -> Tuple[str, str, str, str]:
+    """Synchronous wrapper for Gradio"""
+    if not query.strip():
+        return "Please enter a research query.", "", "", ""
+    
+    # Run async function in event loop
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    
+    return loop.run_until_complete(conduct_research_async(query, progress))
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(
+        title="ResearchCopilot - Multi-Agent Research System",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
+            margin: 0 auto !important;
+        }
+        .research-header {
+            text-align: center;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 2rem;
+            border-radius: 10px;
+            margin-bottom: 2rem;
+        }
+        .agent-status {
+            background: #ffffff !important;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 1.5rem;
+            margin: 1rem 0;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .agent-status h3 {
+            color: #2c3e50 !important;
+            margin-bottom: 1rem;
+            font-size: 1.2rem;
+        }
+        .agent-status ul {
+            color: #2c3e50 !important;
+            list-style-type: none;
+            padding-left: 0;
+        }
+        .agent-status li {
+            color: #2c3e50 !important;
+            margin-bottom: 0.8rem;
+            padding: 0.5rem;
+            background: #f8f9fa;
+            border-radius: 4px;
+            border-left: 4px solid #667eea;
+        }
+        .agent-status strong {
+            color: #667eea !important;
+        }
+        """
+    ) as interface:
+        
+        # Header
+        gr.HTML("""
+        <div class="research-header">
+            <h1>🤖 ResearchCopilot</h1>
+            <h2>Multi-Agent Research System</h2>
+            <p>Powered by AI agents working together to conduct comprehensive research</p>
+            <p><em>Track 3: Agentic Demo Showcase - Gradio MCP Hackathon 2025</em></p>
+        </div>
+        """)
+        
+        # Agent Status Overview
+        with gr.Row():
+            gr.HTML("""
+            <div class="agent-status">
+                <h3>🎯 Research Agents</h3>
+                <ul>
+                    <li><strong>Planner Agent:</strong> Breaks down research queries into structured tasks</li>
+                    <li><strong>Retriever Agent:</strong> Searches multiple sources (Perplexity, Google, Academic)</li>
+                    <li><strong>Summarizer Agent:</strong> Analyzes and synthesizes information</li>
+                    <li><strong>Citation Agent:</strong> Generates proper academic citations</li>
+                </ul>
+            </div>
+            """)
+        
+        # Main Interface
+        with gr.Row():
+            with gr.Column(scale=1):
+                query_input = gr.Textbox(
+                    label="Research Query",
+                    placeholder="Enter your research question (e.g., 'Latest developments in quantum computing for drug discovery')",
+                    lines=3
+                )
+                
+                research_btn = gr.Button(
+                    "🚀 Start Research",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                gr.Examples(
+                    examples=[
+                        "Impact of artificial intelligence on healthcare diagnostics",
+                        "Sustainable energy solutions for urban environments",
+                        "Recent advances in quantum computing applications",
+                        "Climate change effects on global food security",
+                        "Blockchain technology in supply chain management"
+                    ],
+                    inputs=query_input,
+                    label="Example Research Queries"
+                )
+        
+        # Results Display
+        with gr.Row():
+            with gr.Column():
+                with gr.Tabs():
+                    with gr.TabItem("📊 Summary"):
+                        summary_output = gr.Markdown(
+                            label="Research Summary",
+                            value="Enter a research query and click 'Start Research' to begin."
+                        )
+                    
+                    with gr.TabItem("📚 Sources"):
+                        sources_output = gr.Markdown(
+                            label="Sources Found",
+                            value="Sources will appear here after research is completed."
+                        )
+                    
+                    with gr.TabItem("📖 Citations"):
+                        citations_output = gr.Markdown(
+                            label="Citations & Bibliography",
+                            value="Citations will be generated automatically."
+                        )
+                    
+                    with gr.TabItem("🔍 Process Log"):
+                        activity_output = gr.Markdown(
+                            label="Agent Activity Log",
+                            value="Research process will be logged here."
+                        )
+        
+        # Event Handlers
+        research_btn.click(
+            fn=conduct_research_sync,
+            inputs=[query_input],
+            outputs=[summary_output, sources_output, citations_output, activity_output],
+            show_progress=True
+        )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 2rem; padding: 1.5rem; background: #ffffff; border: 2px solid #e0e0e0; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+            <p style="color: #2c3e50; font-weight: bold; margin-bottom: 0.5rem;">ResearchCopilot - Demonstrating multi-agent AI collaboration for research tasks</p>
+            <p style="color: #667eea; font-size: 0.9rem;">Built for the Gradio Agents & MCP Hackathon 2025 - Track 3: Agentic Demo Showcase</p>
+            <p style="color: #7f8c8d; font-size: 0.8rem; margin-top: 0.5rem;">Built with ❤️ using Gradio, Modal, Perplexity API, Claude API, and Multi-Agent Architecture.</p>
+        </div>
+        """)
+    
+    return interface
+
+# Launch the application
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(
+        share=True,  # Creates public URL for sharing
+        server_name="127.0.0.1",  # Localhost access
+        server_port=7860,
+        show_error=True,
+        inbrowser=True  # Automatically opens browser
+    )