first commit

.gitignore

@@ -1,13 +0,0 @@
-.env
-myenv/
-venv/
-
-__pycache__/
-*.py[cod]
-*.pyo
-*.pyd
-*.log
-
-agentic_implementation/*.json
-agentic_implementation/*.db
-logs/

README.md

@@ -1,19 +1,13 @@
 ---
-tag: "mcp-server-track"
 title: MailQuery
 emoji: 💬
 colorFrom: yellow
 colorTo: purple
 sdk: gradio
 sdk_version: 5.0.1
-app_file: agentic_implementation/email_mcp_server_oauth.py
+app_file: app.py
 pinned: false
 short_description: Answer any questions you have about the content of your mail
 ---
 
-
-Our Google authentication verification is currently pending. If you would like to proceed with testing, we can add you as a test user. To facilitate this, please complete the Google Form provided below.
-
-https://forms.gle/FRWwhhMeKaiXDAJQ9
-
-Link to the vide demo: https://www.youtube.com/watch?v=Ie8kdGU6bjY
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

agentic_implementation/README_OAuth.md

@@ -1,258 +0,0 @@
-# Gmail MCP Server with OAuth Authentication
-
-This is an enhanced version of the Gmail MCP (Model Context Protocol) server that uses **OAuth 2.0 authentication** instead of requiring users to provide email credentials for each query.
-
-## 🚀 Key Features
-
-- **OAuth 2.0 Authentication**: Secure authentication flow using Google's OAuth system
-- **One-time Setup**: Authenticate once, use anywhere
-- **Automatic Token Refresh**: Handles token expiration automatically
-- **Encrypted Storage**: Credentials are encrypted and stored securely
-- **No More Password Sharing**: No need to provide email/password to Claude
-
-## 📋 Prerequisites
-
-1. **Google Account**: You need a Gmail account
-2. **Google Cloud Project**: Free to create
-3. **Python 3.8+**: Required for running the server
-
-## 🛠️ Setup Instructions
-
-### Step 1: Install Dependencies
-
-```bash
-pip install -r requirements_oauth.txt
-```
-
-### Step 2: Run the Interactive Setup
-
-The setup script will guide you through the entire process:
-
-```bash
-python setup_oauth.py
-```
-
-This will walk you through:
-1. Creating a Google Cloud project
-2. Enabling the Gmail API
-3. Setting up OAuth consent screen
-4. Creating OAuth credentials
-5. Testing the authentication flow
-
-### Step 3: Start the MCP Server
-
-```bash
-python email_mcp_server_oauth.py
-```
-
-The server will start and show you:
-- Authentication status
-- MCP endpoint URL
-- Web interface URL
-
-## 🔧 Claude Desktop Configuration
-
-Add this configuration to your Claude Desktop MCP settings:
-
-```json
-{
-  "mcpServers": {
-    "gmail-oauth": {
-      "command": "npx",
-      "args": [
-        "mcp-remote",
-        "http://localhost:7860/gradio_api/mcp/sse"
-      ]
-    }
-  }
-}
-```
-
-## 🔍 Available Tools
-
-### 1. search_emails
-Search your emails using natural language queries - **no credentials needed!**
-
-**Parameters:**
-- `query`: Natural language query (e.g., "show me emails from amazon last week")
-
-**Example Usage in Claude:**
-> "Can you search my emails for messages from Swiggy in the last week?"
-
-### 2. get_email_details
-Get full details of a specific email by message ID.
-
-**Parameters:**
-- `message_id`: Message ID from search results
-
-### 3. analyze_email_patterns
-Analyze email patterns from a specific sender over time.
-
-**Parameters:**
-- `sender_keyword`: Sender to analyze (e.g., "amazon", "google")
-- `days_back`: Number of days to analyze (default: "30")
-
-### 4. authenticate_user
-Trigger the OAuth authentication flow from Claude Desktop.
-
-**Parameters:** None
-
-### 5. get_authentication_status
-Check current authentication status.
-
-**Parameters:** None
-
-## 🔐 Security Features
-
-### Encrypted Storage
-- All credentials are encrypted using Fernet encryption
-- Encryption keys are stored securely with proper permissions
-- No plaintext credentials are ever stored
-
-### OAuth Benefits
-- No need to share Gmail passwords
-- Granular permission control
-- Easy revocation from Google Account settings
-- Automatic token refresh
-
-### Local Storage
-- All data stored locally on your machine
-- No cloud storage of credentials
-- You maintain full control
-
-## 🔧 Advanced Usage
-
-### Command Line Tools
-
-Check authentication status:
-```bash
-python setup_oauth.py --status
-```
-
-Re-authenticate:
-```bash
-python setup_oauth.py --auth
-```
-
-Clear stored credentials:
-```bash
-python setup_oauth.py --clear
-```
-
-Show help:
-```bash
-python setup_oauth.py --help
-```
-
-### Web Interface
-
-When the server is running, you can access the web interface at:
-```
-http://localhost:7860
-```
-
-Use this interface to:
-- Check authentication status
-- Trigger authentication flow
-- Test email search functionality
-
-## 🆚 Comparison: OAuth vs App Passwords
-
-| Feature | App Password (Old) | OAuth (New) |
-|---------|-------------------|-------------|
-| **Setup Complexity** | Simple | One-time setup required |
-| **Security** | Share app password | No password sharing |
-| **User Experience** | Enter credentials each time | Authenticate once |
-| **Revocation** | Change app password | Revoke from Google Account |
-| **Token Management** | Manual | Automatic refresh |
-| **Scope Control** | Full Gmail access | Granular permissions |
-
-## 🐛 Troubleshooting
-
-### Authentication Issues
-
-**"OAuth not configured" error:**
-```bash
-python setup_oauth.py
-```
-
-**"Not authenticated" error:**
-```bash
-python setup_oauth.py --auth
-```
-
-**Authentication timeout:**
-- Check if port 8080 is available
-- Try disabling firewall temporarily
-- Ensure browser can access localhost:8080
-
-### Common Issues
-
-**"No module named 'google.auth'" error:**
-```bash
-pip install -r requirements_oauth.txt
-```
-
-**"Permission denied" on credential files:**
-```bash
-# Check permissions
-ls -la ~/.mailquery_oauth/
-# Should show restricted permissions (600/700)
-```
-
-**Browser doesn't open:**
-- Copy the authorization URL manually
-- Paste it in your browser
-- Complete the flow manually
-
-### Getting Help
-
-1. Check authentication status: `python setup_oauth.py --status`
-2. Review server logs for detailed error messages
-3. Ensure Google Cloud project is properly configured
-4. Verify OAuth consent screen is set up correctly
-
-## 📁 File Structure
-
-```
-~/.mailquery_oauth/
-├── client_secret.json    # OAuth client configuration
-├── token.pickle         # Encrypted access/refresh tokens
-└── key.key             # Encryption key (secure permissions)
-```
-
-## 🔄 Migration from App Password Version
-
-If you're migrating from the app password version:
-
-1. Run the new OAuth setup: `python setup_oauth.py`
-2. Update your Claude Desktop configuration to use the new server
-3. The old environment variables (EMAIL_ID, APP_PASSWORD) are no longer needed
-
-## 📞 Support
-
-For issues or questions:
-1. Check the troubleshooting section above
-2. Review the setup script output for specific guidance
-3. Ensure all prerequisites are met
-4. Verify Google Cloud project configuration
-
-## 🎯 Example Queries for Claude
-
-Once set up, you can ask Claude:
-
-- "Search my emails for messages from Amazon in the last month"
-- "Show me emails from my bank from last week" 
-- "Analyze my LinkedIn email patterns over the last 60 days"
-- "Find emails from Swiggy today"
-- "Get details of the email with ID xyz123"
-
-Claude will automatically use the OAuth-authenticated tools without asking for credentials!
-
-## 🔒 Privacy & Data
-
-- **No data leaves your machine**: All processing happens locally
-- **Google only provides**: Access to your Gmail via official APIs
-- **We store**: Encrypted authentication tokens only
-- **We never store**: Email content, passwords, or personal data
-- **You control**: Access can be revoked anytime from Google Account settings 

agentic_implementation/email_mcp_server_oauth.py

@@ -1,786 +0,0 @@
-#!/usr/bin/env python3
-"""
-Gmail MCP Server with OAuth Authentication and Multi-Account Support
-"""
-
-import gradio as gr
-import json
-import base64
-from email.mime.text import MIMEText
-from googleapiclient.errors import HttpError
-import os
-from typing import Dict, List
-from datetime import datetime, timedelta
-from dotenv import load_dotenv
-from fastapi.responses import HTMLResponse
-from fastapi import FastAPI,Request
-from fastapi.routing import APIRoute
-# Import OAuth-enabled modules
-# from tools import extract_query_info, analyze_emails
-from gmail_api_scraper import GmailAPIScraper
-from oauth_manager import oauth_manager
-from logger import logger
-
-load_dotenv()
-
-if not oauth_manager.client_secrets_file.exists():
-    print("Setupy")
-    oauth_manager.setup_client_secrets(
-        os.environ["GOOGLE_CLIENT_ID"],
-        os.environ["GOOGLE_CLIENT_SECRET"]
-    )
-
-# Initialize Gmail API scraper
-gmail_scraper = GmailAPIScraper()
-
-def check_authentication() -> tuple[bool, str]:
-    """Check if user is authenticated and return status"""
-    current_account = oauth_manager.get_current_account()
-    if current_account and oauth_manager.is_authenticated():
-        return True, current_account
-    else:
-        return False, "Not authenticated"
-
-def simple_analyze_emails(emails) -> dict:
-    """
-    Simple email analysis without OpenAI - just basic statistics and patterns
-    """
-    if not emails:
-        return {"summary": "No emails to analyze.", "insights": []}
-    
-    # Basic statistics
-    total_count = len(emails)
-    
-    # Group by sender
-    senders = {}
-    subjects = []
-    dates = []
-    
-    for email in emails:
-        sender = email.get("from", "Unknown")
-        # Extract just the email domain for grouping
-        if "<" in sender and ">" in sender:
-            email_part = sender.split("<")[1].split(">")[0]
-        else:
-            email_part = sender
-        
-        domain = email_part.split("@")[-1] if "@" in email_part else sender
-        
-        senders[domain] = senders.get(domain, 0) + 1
-        subjects.append(email.get("subject", ""))
-        dates.append(email.get("date", ""))
-    
-    # Create insights
-    insights = []
-    insights.append(f"Found {total_count} emails total")
-    
-    if senders:
-        top_sender = max(senders.items(), key=lambda x: x[1])
-        insights.append(f"Most emails from: {top_sender[0]} ({top_sender[1]} emails)")
-    
-    if len(senders) > 1:
-        insights.append(f"Emails from {len(senders)} different domains")
-    
-    # Date range
-    if dates:
-        unique_dates = list(set(dates))
-        if len(unique_dates) > 1:
-            insights.append(f"Spanning {len(unique_dates)} different days")
-    
-    # Subject analysis
-    if subjects:
-        # Count common words in subjects (simple approach)
-        all_words = []
-        for subject in subjects:
-            words = subject.lower().split()
-            all_words.extend([w for w in words if len(w) > 3])  # Only words longer than 3 chars
-        
-        if all_words:
-            word_counts = {}
-            for word in all_words:
-                word_counts[word] = word_counts.get(word, 0) + 1
-            
-            if word_counts:
-                common_word = max(word_counts.items(), key=lambda x: x[1])
-                if common_word[1] > 1:
-                    insights.append(f"Common subject word: '{common_word[0]}' appears {common_word[1]} times")
-    
-    summary = f"Analysis of {total_count} emails from {len(senders)} sender(s)"
-    
-    return {
-        "summary": summary,
-        "insights": insights
-    }
-
-def authenticate_user() -> str:
-    """
-    Start OAuth authentication flow for Gmail access.
-    Opens a browser window for user to authenticate with Google.
-    
-    Returns:
-        str: JSON string containing authentication result
-    """
-    try:
-        logger.info("Starting OAuth authentication flow...")
-        
-        if oauth_manager.is_authenticated():
-            user_email = oauth_manager.get_current_account()
-            return json.dumps({
-                "success": True,
-                "message": "Already authenticated!",
-                "user_email": user_email,
-                "instructions": [
-                    "You are already authenticated and ready to use email tools",
-                    f"Currently authenticated as: {user_email}"
-                ]
-            }, indent=2)
-        # Check if OAuth is configured
-        if not oauth_manager.client_secrets_file.exists():
-            return json.dumps({
-                "error": "OAuth not configured",
-                "message": "Please run 'python setup_oauth.py' first to configure OAuth credentials.",
-                "success": False
-            }, indent=2)
-        
-        # Start authentication
-        success = oauth_manager.authenticate_interactive()
-        
-        if success:
-            user_email = oauth_manager.get_current_account()
-            result = {
-                "success": True,
-                "message": "Authentication successful! You can now use the email tools.",
-                "user_email": user_email,
-                "instructions": [
-                    "Authentication completed successfully",
-                    "You can now search emails, get email details, and analyze patterns",
-                    f"Currently authenticated as: {user_email}"
-                ]
-            }
-        else:
-            # Authentication not completed, provide manual instructions
-            auth_url = oauth_manager.get_pending_auth_url()
-            callback_url = oauth_manager.get_hf_redirect_uri()
-            
-            if auth_url:
-                result = {
-                    "success": False,
-                    "message": "Manual authentication required",
-                    "auth_url": auth_url,
-                    "callback_url": callback_url,
-                    "instructions": [
-                        "Authentication URL has been generated",
-                        "Please click the link below to authenticate:",
-                        "1. Open the authentication URL(auth_url) in a new browser tab",
-                        "2. Sign in with your Google account", 
-                        "3. Grant Gmail access permissions",
-                        "4. You'll be redirected back automatically",
-                        "5. Try clicking 'Submit' again after completing authentication"
-                    ],
-                    "note": "After completing authentication in the popup, click Submit again to verify"
-                }
-            else:
-                result = {
-                    "success": False,
-                    "error": "Failed to generate authentication URL",
-                    "message": "Could not start authentication process. Check your OAuth configuration."
-                }
-            
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error in authenticate_user: %s", e)
-        error_result = {
-            "success": False,
-            "error": str(e),
-            "message": "Authentication failed due to an error."
-        }
-        return json.dumps(error_result, indent=2)
-    
-    
-def handle_oauth_callback(auth_code: str) -> str:
-    """Handle OAuth callback for Hugging Face Spaces
-    
-    Args:
-        auth_code: Authorization code from OAuth callback
-        
-    Returns:
-        HTML response string
-    """
-    try:
-        if not auth_code:
-            return """
-            <html>
-            <head><title>OAuth Error</title></head>
-            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                <h1 style="color: #d32f2f;">Authentication Error</h1>
-                <p>No authorization code received.</p>
-                <button onclick="window.close()" style="padding: 10px 20px; margin: 20px; background: #1976d2; color: white; border: none; border-radius: 4px; cursor: pointer;">Close Window</button>
-            </body>
-            </html>
-            """
-        print(f"Received OAuth callback with code: {auth_code}")
-        success = oauth_manager.complete_hf_spaces_auth(auth_code)
-        
-        if success:
-            user_email = oauth_manager.get_current_account()
-            return f"""
-            <html>
-            <head><title>OAuth Success</title></head>
-            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                <h1 style="color: #2e7d32;">🎉 Authentication Successful!</h1>
-                <p>You are now authenticated as:</p>
-                <p style="font-weight: bold; font-size: 18px; color: #1976d2;">{user_email}</p>
-                <p>You can now close this window and return to the main application.</p>
-                <p style="color: #666; font-size: 14px;">This window will close automatically in 5 seconds...</p>
-                <button onclick="window.close()" style="padding: 10px 20px; margin: 20px; background: #2e7d32; color: white; border: none; border-radius: 4px; cursor: pointer;">Close Window</button>
-                <script>
-                    setTimeout(function() {{
-                        window.close();
-                    }}, 5000);
-                </script>
-            </body>
-            </html>
-            """
-        else:
-            return """
-            <html>
-            <head><title>OAuth Error</title></head>
-            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                <h1 style="color: #d32f2f;">Authentication Failed</h1>
-                <p>Unable to complete authentication. Please try again.</p>
-                <p>Make sure you granted all required permissions.</p>
-                <button onclick="window.close()" style="padding: 10px 20px; margin: 20px; background: #d32f2f; color: white; border: none; border-radius: 4px; cursor: pointer;">Close Window</button>
-            </body>
-            </html>
-            """
-            
-    except Exception as e:
-        logger.error(f"Error handling OAuth callback: {e}")
-        return f"""
-        <html>
-        <head><title>OAuth Error</title></head>
-        <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-            <h1 style="color: #d32f2f;">Authentication Error</h1>
-            <p>An error occurred during authentication:</p>
-            <pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; text-align: left; max-width: 500px; margin: 0 auto;">{str(e)}</pre>
-            <button onclick="window.close()" style="padding: 10px 20px; margin: 20px; background: #d32f2f; color: white; border: none; border-radius: 4px; cursor: pointer;">Close Window</button>
-        </body>
-        </html>
-        """
-
-
-def switch_account(target_email: str) -> str:
-    """
-    Switch to a different authenticated Gmail account.
-    
-    Args:
-        target_email (str): Email address to switch to
-        
-    Returns:
-        str: JSON string containing switch result
-    """
-    try:
-        logger.info("Switching to account: %s", target_email)
-        
-        # Check if target account is authenticated
-        if not oauth_manager.is_authenticated(target_email):
-            return json.dumps({
-                "error": "Account not authenticated",
-                "message": f"Account '{target_email}' is not authenticated. Please authenticate first.",
-                "target_email": target_email,
-                "authenticated_accounts": list(oauth_manager.list_accounts().keys())
-            }, indent=2)
-        
-        # Switch account
-        success = oauth_manager.switch_account(target_email)
-        
-        if success:
-            result = {
-                "success": True,
-                "message": f"Successfully switched to account: {target_email}",
-                "current_account": oauth_manager.get_current_account(),
-                "previous_account": None  # Could track this if needed
-            }
-        else:
-            result = {
-                "success": False,
-                "error": "Failed to switch account",
-                "message": f"Could not switch to account: {target_email}",
-                "current_account": oauth_manager.get_current_account()
-            }
-        
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error switching account: %s", e)
-        error_result = {
-            "success": False,
-            "error": str(e),
-            "message": f"Failed to switch to account: {target_email}"
-        }
-        return json.dumps(error_result, indent=2)
-
-def list_accounts() -> str:
-    """
-    List all authenticated Gmail accounts and their status.
-    
-    Returns:
-        str: JSON string containing all accounts and their authentication status
-    """
-    try:
-        logger.info("Listing all accounts")
-        
-        accounts = oauth_manager.list_accounts()
-        current_account = oauth_manager.get_current_account()
-        
-        result = {
-            "accounts": accounts,
-            "current_account": current_account,
-            "total_accounts": len(accounts),
-            "authenticated_accounts": [email for email, is_auth in accounts.items() if is_auth],
-            "message": f"Found {len(accounts)} stored accounts, currently using: {current_account or 'None'}"
-        }
-        
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error listing accounts: %s", e)
-        error_result = {
-            "error": str(e),
-            "message": "Failed to list accounts"
-        }
-        return json.dumps(error_result, indent=2)
-
-def remove_account(email_to_remove: str) -> str:
-    """
-    Remove an authenticated Gmail account and its stored credentials.
-    
-    Args:
-        email_to_remove (str): Email address to remove
-        
-    Returns:
-        str: JSON string containing removal result
-    """
-    try:
-        logger.info("Removing account: %s", email_to_remove)
-        
-        # Check if account exists
-        accounts = oauth_manager.list_accounts()
-        if email_to_remove not in accounts:
-            return json.dumps({
-                "error": "Account not found",
-                "message": f"Account '{email_to_remove}' not found in stored accounts.",
-                "available_accounts": list(accounts.keys())
-            }, indent=2)
-        
-        # Remove account
-        oauth_manager.remove_account(email_to_remove)
-        
-        result = {
-            "success": True,
-            "message": f"Successfully removed account: {email_to_remove}",
-            "removed_account": email_to_remove,
-            "current_account": oauth_manager.get_current_account(),
-            "remaining_accounts": list(oauth_manager.list_accounts().keys())
-        }
-        
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error removing account: %s", e)
-        error_result = {
-            "success": False,
-            "error": str(e),
-            "message": f"Failed to remove account: {email_to_remove}"
-        }
-        return json.dumps(error_result, indent=2)
-
-def search_emails(sender_keyword: str, start_date: str = "", end_date: str = "") -> str:
-    """
-    Search for emails from a specific sender within a date range using OAuth authentication.
-    
-    Args:
-        sender_keyword (str): The sender/company keyword to search for (e.g., "apple", "amazon")
-        start_date (str): Start date in DD-MMM-YYYY format (e.g., "01-Jan-2025"). If empty, defaults to 7 days ago.
-        end_date (str): End date in DD-MMM-YYYY format (e.g., "07-Jan-2025"). If empty, defaults to today.
-        
-    Returns:
-        str: JSON string containing email search results and analysis
-    """
-    try:
-        logger.info("OAuth Email search tool called with sender: %s, dates: %s to %s", sender_keyword, start_date, end_date)
-        
-        # Check authentication
-        is_auth, auth_info = check_authentication()
-        if not is_auth:
-            return json.dumps({
-                "error": "Not authenticated",
-                "message": "Please authenticate first using the authenticate_user tool or run 'python setup_oauth.py'",
-                "auth_status": auth_info
-            }, indent=2)
-        
-        # Set default date range if not provided
-        if not start_date or not end_date:
-            today = datetime.today()
-            if not end_date:
-                end_date = today.strftime("%d-%b-%Y")
-            if not start_date:
-                start_date = (today - timedelta(days=7)).strftime("%d-%b-%Y")
-        
-        logger.info(f"Searching for emails with keyword '{sender_keyword}' between {start_date} and {end_date}")
-        
-        # Use Gmail API scraper with OAuth
-        full_emails = gmail_scraper.search_emails(sender_keyword, start_date, end_date)
-        
-        if not full_emails:
-            result = {
-                "sender_keyword": sender_keyword,
-                "date_range": f"{start_date} to {end_date}",
-                "email_summary": [],
-                "analysis": {"summary": f"No emails found for '{sender_keyword}' in the specified date range.", "insights": []},
-                "email_count": 0,
-                "user_email": auth_info
-            }
-            return json.dumps(result, indent=2)
-        
-        # Create summary version without full content
-        email_summary = []
-        for email in full_emails:
-            summary_email = {
-                "date": email.get("date"),
-                "time": email.get("time"),
-                "subject": email.get("subject"),
-                "from": email.get("from", "Unknown Sender"),
-                "message_id": email.get("message_id"),
-                "gmail_id": email.get("gmail_id")
-            }
-            email_summary.append(summary_email)
-        
-        # Auto-analyze the emails for insights (no OpenAI)
-        analysis = simple_analyze_emails(full_emails)
-        
-        # Return summary info with analysis
-        result = {
-            "sender_keyword": sender_keyword,
-            "date_range": f"{start_date} to {end_date}",
-            "email_summary": email_summary,
-            "analysis": analysis,
-            "email_count": len(full_emails),
-            "user_email": auth_info
-        }
-        
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error in search_emails: %s", e)
-        error_result = {
-            "error": str(e),
-            "sender_keyword": sender_keyword,
-            "message": "Failed to search emails."
-        }
-        return json.dumps(error_result, indent=2)
-
-def get_email_details(message_id: str) -> str:
-    """
-    Get full details of a specific email by its message ID using OAuth authentication.
-    
-    Args:
-        message_id (str): The message ID of the email to retrieve
-        
-    Returns:
-        str: JSON string containing the full email details
-    """
-    try:
-        logger.info("Getting email details for message_id: %s", message_id)
-        
-        # Check authentication
-        is_auth, auth_info = check_authentication()
-        if not is_auth:
-            return json.dumps({
-                "error": "Not authenticated",
-                "message": "Please authenticate first using the authenticate_user tool or run 'python setup_oauth.py'",
-                "auth_status": auth_info
-            }, indent=2)
-        
-        # Get email using Gmail API
-        email = gmail_scraper.get_email_by_id(message_id)
-        
-        if email:
-            email["user_email"] = auth_info
-            return json.dumps(email, indent=2)
-        else:
-            error_result = {
-                "error": f"No email found with message_id '{message_id}'",
-                "message": "Email may not exist or you may not have access to it.",
-                "user_email": auth_info
-            }
-            return json.dumps(error_result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error in get_email_details: %s", e)
-        error_result = {
-            "error": str(e),
-            "message_id": message_id,
-            "message": "Failed to retrieve email details."
-        }
-        return json.dumps(error_result, indent=2)
-
-def analyze_email_patterns(sender_keyword: str, days_back: str = "30") -> str:
-    """
-    Analyze email patterns from a specific sender over a given time period using OAuth authentication.
-    
-    Args:
-        sender_keyword (str): The sender/company keyword to analyze (e.g., "amazon", "google")
-        days_back (str): Number of days to look back (default: "30")
-        
-    Returns:
-        str: JSON string containing email pattern analysis
-    """
-    try:
-        logger.info("Analyzing email patterns for sender: %s, days_back: %s", sender_keyword, days_back)
-        
-        # Check authentication
-        is_auth, auth_info = check_authentication()
-        if not is_auth:
-            return json.dumps({
-                "error": "Not authenticated",
-                "message": "Please authenticate first using the authenticate_user tool or run 'python setup_oauth.py'",
-                "auth_status": auth_info
-            }, indent=2)
-        
-        # Calculate date range
-        days_int = int(days_back)
-        end_date = datetime.today()
-        start_date = end_date - timedelta(days=days_int)
-        
-        start_date_str = start_date.strftime("%d-%b-%Y")
-        end_date_str = end_date.strftime("%d-%b-%Y")
-        
-        # Search for emails using Gmail API
-        full_emails = gmail_scraper.search_emails(sender_keyword, start_date_str, end_date_str)
-        
-        if not full_emails:
-            result = {
-                "sender_keyword": sender_keyword,
-                "date_range": f"{start_date_str} to {end_date_str}",
-                "analysis": {"summary": f"No emails found from '{sender_keyword}' in the last {days_back} days.", "insights": []},
-                "email_count": 0,
-                "user_email": auth_info
-            }
-            return json.dumps(result, indent=2)
-        
-        # Analyze the emails (no OpenAI)
-        analysis = simple_analyze_emails(full_emails)
-        
-        result = {
-            "sender_keyword": sender_keyword,
-            "date_range": f"{start_date_str} to {end_date_str}",
-            "analysis": analysis,
-            "email_count": len(full_emails),
-            "user_email": auth_info
-        }
-        
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error in analyze_email_patterns: %s", e)
-        error_result = {
-            "error": str(e),
-            "sender_keyword": sender_keyword,
-            "message": "Failed to analyze email patterns."
-        }
-        return json.dumps(error_result, indent=2)
-
-def get_authentication_status() -> str:
-    """
-    Get current authentication status and account information.
-    
-    Returns:
-        str: JSON string containing authentication status
-    """
-    try:
-        current_account = oauth_manager.get_current_account()
-        is_auth = oauth_manager.is_authenticated() if current_account else False
-        all_accounts = oauth_manager.list_accounts()
-        
-        result = {
-            "authenticated": is_auth,
-            "current_account": current_account,
-            "status": "authenticated" if is_auth else "not_authenticated",
-            "message": f"Current account: {current_account}" if is_auth else "No account selected or not authenticated",
-            "all_accounts": all_accounts,
-            "total_accounts": len(all_accounts),
-            "authenticated_accounts": [email for email, auth in all_accounts.items() if auth]
-        }
-        
-        if not is_auth and not oauth_manager.client_secrets_file.exists():
-            result["setup_required"] = True
-            result["message"] = "OAuth not configured. Please run 'python setup_oauth.py' first."
-        elif not is_auth and current_account:
-            result["message"] = f"Account {current_account} needs re-authentication"
-        elif not current_account and all_accounts:
-            result["message"] = "Accounts available but none selected. Use switch_account to select one."
-        
-        return json.dumps(result, indent=2)
-        
-    except Exception as e:
-        logger.error("Error checking authentication status: %s", e)
-        return json.dumps({
-            "error": str(e),
-            "message": "Failed to check authentication status"
-        }, indent=2)
-        
-def send_email(recipient: str, subject: str, body: str) -> str:
-    """
-    Send a plain-text email via the authenticated Gmail account.
-    Returns JSON with either:
-      {"success": true, "message_id": "..."}
-    or
-      {"success": false, "error": "..."}
-    """
-    # Use the correct method on your OAuth manager:
-    service = oauth_manager.get_gmail_service()
-    if service is None:
-        return json.dumps(
-            {"success": False, "error": "Not authenticated or failed to build service."},
-            indent=2,
-        )
-
-    # Build the MIME message
-    mime_msg = MIMEText(body, "plain", "utf-8")
-    mime_msg["to"] = recipient
-    mime_msg["subject"] = subject
-
-    # Base64-encode and send
-    raw_msg = base64.urlsafe_b64encode(mime_msg.as_bytes()).decode()
-    try:
-        sent = (
-            service.users()
-                   .messages()
-                   .send(userId="me", body={"raw": raw_msg})
-                   .execute()
-        )
-        return json.dumps(
-            {"success": True, "message_id": sent.get("id")}, indent=2
-        )
-    except HttpError as err:
-        logger.error(f"Error sending email: {err}")
-        # err.error_details may be None; fallback to string
-        error_detail = getattr(err, "error_details", None) or str(err)
-        return json.dumps(
-            {"success": False, "error": error_detail},
-            indent=2,
-        )
-
-
-# Create Gradio interfaces
-search_interface = gr.Interface(
-    fn=search_emails,
-    inputs=[
-        gr.Textbox(label="Sender Keyword", placeholder="apple, amazon, etc."),
-        gr.Textbox(label="Start Date (Optional)", placeholder="01-Jan-2025 (leave empty for last 7 days)"),
-        gr.Textbox(label="End Date (Optional)", placeholder="07-Jan-2025 (leave empty for today)")
-    ],
-    outputs=gr.Textbox(label="Search Results", lines=20),
-    title="Email Search (OAuth)",
-    description="Search your emails by sender keyword and date range with OAuth authentication"
-)
-
-details_interface = gr.Interface(
-    fn=get_email_details,
-    inputs=[
-        gr.Textbox(label="Message ID", placeholder="Email message ID from search results")
-    ],
-    outputs=gr.Textbox(label="Email Details", lines=20),
-    title="Email Details (OAuth)",
-    description="Get full details of a specific email by message ID with OAuth authentication"
-)
-
-analysis_interface = gr.Interface(
-    fn=analyze_email_patterns,
-    inputs=[
-        gr.Textbox(label="Sender Keyword", placeholder="amazon, google, linkedin, etc."),
-        gr.Textbox(label="Days Back", value="30", placeholder="Number of days to analyze")
-    ],
-    outputs=gr.Textbox(label="Analysis Results", lines=20),
-    title="Email Pattern Analysis (OAuth)",
-    description="Analyze email patterns from a specific sender over time with OAuth authentication"
-)
-
-auth_interface = gr.Interface(
-    fn=authenticate_user,
-    inputs=[],
-    outputs=gr.Textbox(label="Authentication Result", lines=10),
-    title="Authenticate with Gmail",
-    description="Click Submit to start OAuth authentication flow with Gmail"
-)
-
-status_interface = gr.Interface(
-    fn=get_authentication_status,
-    inputs=[],
-    outputs=gr.Textbox(label="Authentication Status", lines=15),
-    title="Authentication Status",
-    description="Check current authentication status and view all accounts"
-)
-
-switch_interface = gr.Interface(
-    fn=switch_account,
-    inputs=[
-        gr.Textbox(label="Target Email", placeholder="email@gmail.com")
-    ],
-    outputs=gr.Textbox(label="Switch Result", lines=10),
-    title="Switch Account",
-    description="Switch to a different authenticated Gmail account"
-)
-
-accounts_interface = gr.Interface(
-    fn=list_accounts,
-    inputs=[],
-    outputs=gr.Textbox(label="Accounts List", lines=15),
-    title="List All Accounts",
-    description="View all authenticated Gmail accounts and their status"
-)
-
-remove_interface = gr.Interface(
-    fn=remove_account,
-    inputs=[
-        gr.Textbox(label="Email to Remove", placeholder="email@gmail.com")
-    ],
-    outputs=gr.Textbox(label="Removal Result", lines=10),
-    title="Remove Account",
-    description="Remove an authenticated Gmail account and its credentials"
-)
-
-send_interface = gr.Interface(
-    fn=send_email,
-    inputs=[
-        gr.Textbox(label="Recipient Email", placeholder="recipient@example.com"),
-        gr.Textbox(label="Subject", placeholder="Email subject"),
-        gr.Textbox(label="Body", placeholder="Email body text", lines=5)
-    ],
-    outputs=gr.Textbox(label="Send Result", lines=10),
-    title="✉️ Send Email",
-    description="Send an email via Gmail using OAuth authenticated account"
-)
-
-# Combine interfaces into a tabbed interface
-demo = gr.TabbedInterface(
-    [auth_interface, status_interface, accounts_interface, switch_interface, remove_interface, search_interface, details_interface, analysis_interface, send_interface],
-    ["🔐 Authenticate", "📊 Status", "👥 All Accounts", "🔄 Switch Account", "🗑️ Remove Account", "📧 Email Search", "📄 Email Details", "📈 Pattern Analysis", "✉️ Send Email"],
-    title="📧 Gmail Assistant MCP Server (Multi-Account OAuth)"
-)
-
-app = FastAPI()
-# Add your OAuth callback route
-@app.get("/oauth2callback")
-async def google_oauth_cb(request: Request):
-    code = request.query_params.get("code")
-    print("code:", code)
-    return HTMLResponse(handle_oauth_callback(code))
-
-app = gr.mount_gradio_app(app, demo, path="/")
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

agentic_implementation/gmail_api_scraper.py

@@ -1,301 +0,0 @@
-#!/usr/bin/env python3
-"""
-Gmail API-based Email Scraper with OAuth Authentication
-"""
-
-import base64
-import re
-from datetime import datetime, timedelta
-from typing import List, Dict, Optional
-from email.mime.text import MIMEText
-import googleapiclient.errors
-from oauth_manager import oauth_manager
-from logger import logger
-
-class GmailAPIScraper:
-    """Gmail API-based email scraper using OAuth authentication"""
-    
-    def __init__(self):
-        """Initialize the Gmail API scraper"""
-        self.oauth_manager = oauth_manager
-    
-    def _parse_date_string(self, date_str: str) -> datetime:
-        """Parse date string in DD-MMM-YYYY format to datetime object"""
-        try:
-            return datetime.strptime(date_str, "%d-%b-%Y")
-        except ValueError:
-            raise ValueError(f"Invalid date format: {date_str}. Expected DD-MMM-YYYY")
-    
-    def _format_date_for_query(self, date_obj: datetime) -> str:
-        """Format datetime object for Gmail API query"""
-        return date_obj.strftime("%Y/%m/%d")
-    
-    def _decode_message_part(self, part: Dict) -> str:
-        """Decode message part content"""
-        data = part.get('body', {}).get('data', '')
-        if data:
-            # Decode base64url
-            data += '=' * (4 - len(data) % 4)  # Add padding if needed
-            decoded_bytes = base64.urlsafe_b64decode(data)
-            try:
-                return decoded_bytes.decode('utf-8')
-            except UnicodeDecodeError:
-                return decoded_bytes.decode('utf-8', errors='ignore')
-        return ''
-    
-    def _extract_email_content(self, message: Dict) -> str:
-        """Extract readable content from Gmail API message"""
-        content = ""
-        
-        if 'payload' not in message:
-            return content
-        
-        payload = message['payload']
-        
-        # Handle multipart messages
-        if 'parts' in payload:
-            for part in payload['parts']:
-                mime_type = part.get('mimeType', '')
-                
-                if mime_type == 'text/plain':
-                    content += self._decode_message_part(part)
-                elif mime_type == 'text/html':
-                    html_content = self._decode_message_part(part)
-                    # Simple HTML tag removal
-                    clean_text = re.sub(r'<[^>]+>', '', html_content)
-                    content += clean_text
-                elif mime_type.startswith('multipart/'):
-                    # Handle nested multipart
-                    if 'parts' in part:
-                        for nested_part in part['parts']:
-                            nested_mime = nested_part.get('mimeType', '')
-                            if nested_mime == 'text/plain':
-                                content += self._decode_message_part(nested_part)
-        else:
-            # Handle single part messages
-            mime_type = payload.get('mimeType', '')
-            if mime_type in ['text/plain', 'text/html']:
-                raw_content = self._decode_message_part(payload)
-                if mime_type == 'text/html':
-                    # Simple HTML tag removal
-                    content = re.sub(r'<[^>]+>', '', raw_content)
-                else:
-                    content = raw_content
-        
-        return content.strip()
-    
-    def _get_header_value(self, headers: List[Dict], name: str) -> str:
-        """Get header value by name"""
-        for header in headers:
-            if header.get('name', '').lower() == name.lower():
-                return header.get('value', '')
-        return ''
-    
-    def _parse_email_message(self, message: Dict) -> Dict:
-        """Parse Gmail API message into structured format"""
-        headers = message.get('payload', {}).get('headers', [])
-        
-        # Extract headers
-        subject = self._get_header_value(headers, 'Subject') or 'No Subject'
-        from_header = self._get_header_value(headers, 'From') or 'Unknown Sender'
-        date_header = self._get_header_value(headers, 'Date')
-        message_id = self._get_header_value(headers, 'Message-ID') or message.get('id', '')
-        
-        # Parse date
-        email_date = datetime.now().strftime("%d-%b-%Y")
-        email_time = "00:00:00"
-        
-        if date_header:
-            try:
-                # Parse RFC 2822 date format
-                from email.utils import parsedate_to_datetime
-                dt_obj = parsedate_to_datetime(date_header)
-                # Convert to IST (Indian Standard Time)
-                from zoneinfo import ZoneInfo
-                ist_dt = dt_obj.astimezone(ZoneInfo("Asia/Kolkata"))
-                email_date = ist_dt.strftime("%d-%b-%Y")
-                email_time = ist_dt.strftime("%H:%M:%S")
-            except Exception as e:
-                logger.warning(f"Failed to parse date {date_header}: {e}")
-        
-        # Extract content
-        content = self._extract_email_content(message)
-        
-        return {
-            "date": email_date,
-            "time": email_time,
-            "subject": subject,
-            "from": from_header,
-            "content": content[:2000],  # Limit content length
-            "message_id": message_id,
-            "gmail_id": message.get('id', '')
-        }
-    
-    def search_emails(self, keyword: str, start_date: str, end_date: str) -> List[Dict]:
-        """Search emails containing keyword within date range using Gmail API
-        
-        Args:
-            keyword: Keyword to search for in emails
-            start_date: Start date in DD-MMM-YYYY format
-            end_date: End date in DD-MMM-YYYY format
-            
-        Returns:
-            List of email dictionaries
-        """
-        logger.info(f"Searching emails containing '{keyword}' between {start_date} and {end_date}")
-        
-        # Get Gmail service
-        service = self.oauth_manager.get_gmail_service()
-        if not service:
-            raise Exception("Not authenticated. Please authenticate first using the setup tool.")
-        
-        try:
-            # Parse dates
-            start_dt = self._parse_date_string(start_date)
-            end_dt = self._parse_date_string(end_date)
-            
-            # Format dates for Gmail API query
-            after_date = self._format_date_for_query(start_dt)
-            before_date = self._format_date_for_query(end_dt + timedelta(days=1))  # Add 1 day for inclusive end
-            
-            # Build search query
-            # Gmail API search syntax: https://developers.google.com/gmail/api/guides/filtering
-            query_parts = [
-                f'after:{after_date}',
-                f'before:{before_date}',
-                f'({keyword})'  # Search in all fields
-            ]
-            query = ' '.join(query_parts)
-            
-            logger.info(f"Gmail API query: {query}")
-            
-            # Search for messages
-            results = service.users().messages().list(
-                userId='me',
-                q=query,
-                maxResults=500  # Limit to 500 results
-            ).execute()
-            
-            messages = results.get('messages', [])
-            logger.info(f"Found {len(messages)} messages")
-            
-            if not messages:
-                return []
-            
-            # Fetch full message details
-            scraped_emails = []
-            
-            for i, msg_ref in enumerate(messages):
-                try:
-                    logger.info(f"Processing email {i+1}/{len(messages)}")
-                    
-                    # Get full message
-                    message = service.users().messages().get(
-                        userId='me',
-                        id=msg_ref['id'],
-                        format='full'
-                    ).execute()
-                    
-                    # Parse message
-                    parsed_email = self._parse_email_message(message)
-                    
-                    # Verify date range (double-check since Gmail search might be inclusive)
-                    email_dt = self._parse_date_string(parsed_email['date'])
-                    if start_dt <= email_dt <= end_dt:
-                        # Verify keyword presence (case-insensitive)
-                        keyword_lower = keyword.lower()
-                        if any(keyword_lower in text.lower() for text in [
-                            parsed_email['subject'],
-                            parsed_email['from'],
-                            parsed_email['content']
-                        ]):
-                            scraped_emails.append(parsed_email)
-                    
-                except googleapiclient.errors.HttpError as e:
-                    logger.error(f"Error fetching message {msg_ref['id']}: {e}")
-                    continue
-                except Exception as e:
-                    logger.error(f"Error processing message {msg_ref['id']}: {e}")
-                    continue
-            
-            # Sort by date (newest first)
-            scraped_emails.sort(
-                key=lambda x: datetime.strptime(f"{x['date']} {x['time']}", "%d-%b-%Y %H:%M:%S"),
-                reverse=True
-            )
-            
-            logger.info(f"Successfully processed {len(scraped_emails)} emails containing '{keyword}'")
-            return scraped_emails
-            
-        except googleapiclient.errors.HttpError as e:
-            logger.error(f"Gmail API error: {e}")
-            raise Exception(f"Gmail API error: {e}")
-        except Exception as e:
-            logger.error(f"Email search failed: {e}")
-            raise
-    
-    def get_email_by_id(self, message_id: str) -> Optional[Dict]:
-        """Get email details by message ID or Gmail ID
-        
-        Args:
-            message_id: Either the Message-ID header or Gmail message ID
-            
-        Returns:
-            Email dictionary or None if not found
-        """
-        service = self.oauth_manager.get_gmail_service()
-        if not service:
-            raise Exception("Not authenticated. Please authenticate first using the setup tool.")
-        
-        try:
-            # Try to get message directly by Gmail ID first
-            try:
-                message = service.users().messages().get(
-                    userId='me',
-                    id=message_id,
-                    format='full'
-                ).execute()
-                return self._parse_email_message(message)
-            except googleapiclient.errors.HttpError:
-                # If direct ID lookup fails, search by Message-ID header
-                pass
-            
-            # Search by Message-ID header
-            query = f'rfc822msgid:{message_id}'
-            results = service.users().messages().list(
-                userId='me',
-                q=query,
-                maxResults=1
-            ).execute()
-            
-            messages = results.get('messages', [])
-            if not messages:
-                return None
-            
-            # Get the message
-            message = service.users().messages().get(
-                userId='me',
-                id=messages[0]['id'],
-                format='full'
-            ).execute()
-            
-            return self._parse_email_message(message)
-            
-        except Exception as e:
-            logger.error(f"Failed to get email {message_id}: {e}")
-            return None
-    
-    def is_authenticated(self) -> bool:
-        """Check if user is authenticated"""
-        return self.oauth_manager.is_authenticated()
-    
-    def get_user_email(self) -> Optional[str]:
-        """Get authenticated user's email address"""
-        return self.oauth_manager.get_user_email()
-    
-    def authenticate(self) -> bool:
-        """Trigger interactive authentication"""
-        return self.oauth_manager.authenticate_interactive()
-
-# Global scraper instance
-gmail_scraper = GmailAPIScraper() 

agentic_implementation/logger.py

@@ -1,29 +0,0 @@
-import logging
-import sys
-from datetime import datetime
-from loguru import logger as _logger
-from pathlib import Path
-import sys
-
-_print_level = "INFO"
-
-PROJECT_ROOT = Path(sys.path[0])  # Assuming the script is run from the project root
-
-def define_log_level(print_level="INFO", logfile_level="DEBUG", name: str = None):
-    """Adjust the log level to above level"""
-    global _print_level
-    _print_level = print_level
-
-    current_date = datetime.now()
-    formatted_date = current_date.strftime("%Y%m%d%H%M%S")
-    log_name = (
-        f"{name}_{formatted_date}" if name else formatted_date
-    )  # name a log with prefix name
-
-    _logger.remove()
-    _logger.add(sys.stderr, level=print_level)
-    _logger.add(PROJECT_ROOT / f"logs/{log_name}.log", level=logfile_level)
-    return _logger
-
-# Module-level default logger
-logger = define_log_level()

agentic_implementation/oauth_manager.py

@@ -1,631 +0,0 @@
-import os
-import json
-import pickle
-import base64
-from pathlib import Path
-from typing import Optional, Dict, Any
-from cryptography.fernet import Fernet
-import google.auth.transport.requests
-import google_auth_oauthlib.flow
-import googleapiclient.discovery
-from google.oauth2.credentials import Credentials
-from google.auth.transport.requests import Request
-import webbrowser
-import threading
-import time
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from urllib.parse import  urlparse,parse_qs
-from logger import logger
-from dotenv import load_dotenv
-load_dotenv()
-
-
-redirect_uri=os.getenv("GOOGLE_REDIRECT_URI")
-
-class OAuthCallbackHandler(BaseHTTPRequestHandler):
-    """HTTP request handler for OAuth callback"""
-    
-    def do_GET(self):
-        """Handle GET request (OAuth callback)"""
-        # Parse the callback URL to extract authorization code
-        parsed_path = urlparse.urlparse(self.path)
-        query_params = urlparse.parse_qs(parsed_path.query)
-        
-        if 'code' in query_params:
-            # Store the authorization code
-            self.server.auth_code = query_params['code'][0]
-            
-            # Send success response
-            self.send_response(200)
-            self.send_header('Content-type', 'text/html')
-            self.end_headers()
-            
-            success_html = """
-            <html>
-            <head><title>Authentication Successful</title></head>
-            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                <h1 style="color: #4CAF50;">✅ Authentication Successful!</h1>
-                <p>You have successfully authenticated with Gmail.</p>
-                <p>You can now close this window and return to Claude Desktop.</p>
-                <script>
-                    setTimeout(function() {
-                        window.close();
-                    }, 3000);
-                </script>
-            </body>
-            </html>
-            """
-            self.wfile.write(success_html.encode())
-        else:
-            # Send error response
-            self.send_response(400)
-            self.send_header('Content-type', 'text/html')
-            self.end_headers()
-            
-            error_html = """
-            <html>
-            <head><title>Authentication Error</title></head>
-            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
-                <h1 style="color: #f44336;">❌ Authentication Failed</h1>
-                <p>There was an error during authentication.</p>
-                <p>Please try again.</p>
-            </body>
-            </html>
-            """
-            self.wfile.write(error_html.encode())
-    
-    def log_message(self, format, *args):
-        """Suppress server log messages"""
-        pass
-
-class GmailOAuthManager:
-    """Manages Gmail OAuth 2.0 authentication and token storage for multiple accounts"""
-    
-    # Gmail API scopes
-    SCOPES = [
-        'https://www.googleapis.com/auth/gmail.readonly',
-        'https://www.googleapis.com/auth/gmail.modify'
-    ]
-    
-    def __init__(self, credentials_dir: str = None):
-        """Initialize OAuth manager
-        
-        Args:
-            credentials_dir: Directory to store credentials (defaults to ~/.mailquery_oauth)
-        """
-        if credentials_dir is None:
-            credentials_dir = os.path.expanduser("~/.mailquery_oauth")
-        
-        self.credentials_dir = Path(credentials_dir)
-        self.credentials_dir.mkdir(exist_ok=True)
-        
-        # File paths
-        self.client_secrets_file = self.credentials_dir / "client_secret.json"
-        self.accounts_file = self.credentials_dir / "accounts.json"
-        self.encryption_key_file = self.credentials_dir / "key.key"
-        self.current_account_file = self.credentials_dir / "current_account.txt"
-        
-        # Initialize encryption
-        self._init_encryption()
-        
-        # OAuth flow settings
-        self.redirect_uri = redirect_uri
-        
-        # Current account
-        self.current_account_email = self._load_current_account()
-        
-    def _init_encryption(self):
-        """Initialize encryption for secure credential storage"""
-        if self.encryption_key_file.exists():
-            with open(self.encryption_key_file, 'rb') as key_file:
-                self.encryption_key = key_file.read()
-        else:
-            self.encryption_key = Fernet.generate_key()
-            with open(self.encryption_key_file, 'wb') as key_file:
-                key_file.write(self.encryption_key)
-            # Make key file readable only by owner
-            os.chmod(self.encryption_key_file, 0o600)
-        
-        self.cipher_suite = Fernet(self.encryption_key)
-    
-    def _load_current_account(self) -> Optional[str]:
-        """Load the currently selected account"""
-        if self.current_account_file.exists():
-            try:
-                with open(self.current_account_file, 'r') as f:
-                    return f.read().strip()
-            except Exception as e:
-                logger.error(f"Failed to load current account: {e}")
-        return None
-    
-    def _save_current_account(self, email: str):
-        """Save the currently selected account"""
-        try:
-            with open(self.current_account_file, 'w') as f:
-                f.write(email)
-            self.current_account_email = email
-            logger.info(f"Set current account to: {email}")
-        except Exception as e:
-            logger.error(f"Failed to save current account: {e}")
-    
-    def setup_client_secrets(self, client_id: str, client_secret: str):
-        """Setup OAuth client secrets
-        
-        Args:
-            client_id: Google OAuth 2.0 client ID
-            client_secret: Google OAuth 2.0 client secret
-        """
-        client_config = {
-            "web": {
-                "client_id": client_id,
-                "client_secret": client_secret,
-                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-                "token_uri": "https://oauth2.googleapis.com/token",
-                "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-                "redirect_uris": [self.redirect_uri]
-            }
-        }
-        
-        with open(self.client_secrets_file, 'w') as f:
-            json.dump(client_config, f, indent=2)
-        
-        logger.info("Client secrets saved successfully")
-    
-    def _encrypt_data(self, data: Any) -> bytes:
-        """Encrypt data using Fernet encryption"""
-        serialized_data = pickle.dumps(data)
-        return self.cipher_suite.encrypt(serialized_data)
-    
-    def _decrypt_data(self, encrypted_data: bytes) -> Any:
-        """Decrypt data using Fernet encryption"""
-        decrypted_data = self.cipher_suite.decrypt(encrypted_data)
-        return pickle.loads(decrypted_data)
-    
-    def get_authorization_url(self) -> str:
-        """Get the authorization URL for OAuth flow
-        
-        Returns:
-            Authorization URL that user should visit
-        """
-        if not self.client_secrets_file.exists():
-            raise ValueError("Client secrets not found. Please run setup first.")
-        
-        flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
-            str(self.client_secrets_file), 
-            scopes=self.SCOPES
-        )
-        flow.redirect_uri = self.redirect_uri
-        print("👉 redirect_uri being sent to Google:", self.redirect_uri, flush=True)
-        auth_url, _ = flow.authorization_url(
-            access_type='offline',
-            include_granted_scopes='true',
-            prompt='consent'  # Force consent to get refresh token
-        )
-        
-        return auth_url
-    
-    def authenticate_interactive(self) -> bool:
-        """Interactive authentication flow for Hugging Face Spaces
-        
-        Returns:
-            True if authentication successful, False otherwise
-        """
-        try:
-            # Check if already authenticated
-            if self.is_authenticated():
-                logger.info("Already authenticated")
-                return True
-
-            
-            # Get authorization URL
-            auth_url = self.get_authorization_url()
-            
-            logger.info("Running on Hugging Face Spaces")
-            logger.info(f"Authentication URL generated: {auth_url}")
-            logger.info("User must visit the URL manually to complete authentication")
-            
-            # Store the auth URL for the Gradio interface to use
-            self._pending_auth_url = auth_url
-            self._auth_completed = False
-            
-            # For setup_oauth.py and testing contexts, we'll print the URL
-            # and wait briefly to see if authentication completes
-            print(f"\n🌐 Please visit this URL to authenticate:")
-            print(f"   {auth_url}")
-            print("\n⏳ Waiting for authentication completion...")
-            
-            # Wait for a reasonable time to see if auth completes
-            # This allows the callback to potentially complete the auth
-            timeout = 10  # 1 minute for manual completion
-            start_time = time.time()
-            
-            while (time.time() - start_time) < timeout:
-                # Check if authentication was completed via callback
-                if getattr(self, '_auth_completed', False):
-                    logger.info("Authentication completed successfully!")
-                    return True
-                
-                # Check if user is now authenticated (credentials were saved)
-                if self.is_authenticated():
-                    self._auth_completed = True
-                    logger.info("Authentication verified successful!")
-                    return True
-                    
-                time.sleep(2)  # Check every 2 seconds
-            
-            # Timeout reached - authentication not completed
-            logger.info("Authentication timeout. Please complete authentication via the provided URL.")
-            return False
-            
-        except Exception as e:
-            logger.error(f"Authentication failed: {e}")
-            return False
-
-    def complete_hf_spaces_auth(self, auth_code: str) -> bool:
-        """Complete authentication for HF Spaces with received auth code
-        
-        Args:
-            auth_code: Authorization code received from OAuth callback
-            
-        Returns:
-            True if authentication successful, False otherwise
-        """
-        try:
-            success = self._exchange_code_for_credentials(auth_code)
-            
-            if success:
-                # Mark authentication as completed
-                self._auth_completed = True
-                logger.info("HF Spaces authentication marked as completed")
-                
-            return success
-            
-        except Exception as e:
-            logger.error(f"Failed to complete HF Spaces authentication: {e}")
-            return False
-
-    def _exchange_code_for_credentials(self, auth_code: str) -> bool:
-        """Exchange authorization code for credentials
-        
-        Args:
-            auth_code: Authorization code from OAuth flow
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            # Exchange authorization code for credentials
-            flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
-                str(self.client_secrets_file), 
-                scopes=self.SCOPES
-            )
-            flow.redirect_uri = self.redirect_uri
-            
-            flow.fetch_token(code=auth_code)
-            credentials = flow.credentials
-            
-            # Get user email from credentials
-            user_email = self._get_email_from_credentials(credentials)
-            if not user_email:
-                logger.error("Failed to get user email from credentials")
-                return False
-            
-            # Save encrypted credentials for this account
-            self._save_credentials(user_email, credentials)
-            
-            # Set as current account
-            self._save_current_account(user_email)
-            
-            logger.info("Authentication successful!")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to exchange code for credentials: {e}")
-            return False
-
-    def get_pending_auth_url(self) -> str:
-        """Get the pending authentication URL for manual completion
-        
-        Returns:
-            Authentication URL string or None if not available
-        """
-        return getattr(self, '_pending_auth_url', None)
-
-    def get_hf_redirect_uri(self) -> str:
-        """Get the Hugging Face Spaces redirect URI
-        
-        Returns:
-            Redirect URI string
-        # """
-        # space_id = os.getenv('SPACE_ID')
-        # space_author = os.getenv('SPACE_AUTHOR', 'username')
-        return redirect_uri
-
-    # For running in a local machine, use this method instead
-        
-    # def authenticate_interactive(self) -> bool:
-    #     """Interactive authentication flow that opens browser
-        
-    #     Returns:
-    #         True if authentication successful, False otherwise
-    #     """
-    #     try:
-    #         # Start local HTTP server for OAuth callback
-    #         server = HTTPServer(('localhost', 8080), OAuthCallbackHandler)
-    #         server.auth_code = None
-            
-    #         # Get authorization URL
-    #         auth_url = self.get_authorization_url()
-            
-    #         logger.info("Opening browser for authentication...")
-    #         logger.info(f"If browser doesn't open, visit: {auth_url}")
-            
-    #         # Open browser
-    #         webbrowser.open(auth_url)
-            
-    #         # Start server in background thread
-    #         server_thread = threading.Thread(target=server.handle_request)
-    #         server_thread.daemon = True
-    #         server_thread.start()
-            
-    #         # Wait for callback (max 5 minutes)
-    #         timeout = 300  # 5 minutes
-    #         start_time = time.time()
-            
-    #         while server.auth_code is None and (time.time() - start_time) < timeout:
-    #             time.sleep(1)
-            
-    #         if server.auth_code is None:
-    #             logger.error("Authentication timed out")
-    #             return False
-            
-    #         # Exchange authorization code for credentials
-    #         flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
-    #             str(self.client_secrets_file), 
-    #             scopes=self.SCOPES
-    #         )
-    #         flow.redirect_uri = self.redirect_uri
-            
-    #         flow.fetch_token(code=server.auth_code)
-    #         credentials = flow.credentials
-            
-    #         # Get user email from credentials
-    #         user_email = self._get_email_from_credentials(credentials)
-    #         if not user_email:
-    #             logger.error("Failed to get user email from credentials")
-    #             return False
-            
-    #         # Save encrypted credentials for this account
-    #         self._save_credentials(user_email, credentials)
-            
-    #         # Set as current account
-    #         self._save_current_account(user_email)
-            
-    #         logger.info("Authentication successful!")
-    #         return True
-            
-    #     except Exception as e:
-    #         logger.error(f"Authentication failed: {e}")
-    #         return False
-    
-    def _get_email_from_credentials(self, credentials: Credentials) -> Optional[str]:
-        """Get email address from credentials"""
-        try:
-            service = googleapiclient.discovery.build(
-                'gmail', 'v1', credentials=credentials
-            )
-            profile = service.users().getProfile(userId='me').execute()
-            return profile.get('emailAddress')
-        except Exception as e:
-            logger.error(f"Failed to get email from credentials: {e}")
-            return None
-    
-    def _save_credentials(self, email: str, credentials: Credentials):
-        """Save encrypted credentials for a specific account"""
-        try:
-            # Load existing accounts
-            accounts = self._load_accounts()
-            
-            # Encrypt and store credentials
-            encrypted_credentials = self._encrypt_data(credentials)
-            accounts[email] = base64.b64encode(encrypted_credentials).decode('utf-8')
-            
-            # Save accounts file
-            with open(self.accounts_file, 'w') as f:
-                json.dump(accounts, f, indent=2)
-            
-            # Make accounts file readable only by owner
-            os.chmod(self.accounts_file, 0o600)
-            
-            logger.info(f"Credentials saved for account: {email}")
-        except Exception as e:
-            logger.error(f"Failed to save credentials for {email}: {e}")
-            raise
-    
-    def _load_accounts(self) -> Dict[str, str]:
-        """Load accounts data"""
-        if not self.accounts_file.exists():
-            return {}
-        
-        try:
-            with open(self.accounts_file, 'r') as f:
-                return json.load(f)
-        except Exception as e:
-            logger.error(f"Failed to load accounts: {e}")
-            return {}
-    
-    def _load_credentials(self, email: str) -> Optional[Credentials]:
-        """Load and decrypt credentials for a specific account"""
-        accounts = self._load_accounts()
-        
-        if email not in accounts:
-            return None
-        
-        try:
-            encrypted_credentials = base64.b64decode(accounts[email])
-            credentials = self._decrypt_data(encrypted_credentials)
-            return credentials
-        except Exception as e:
-            logger.error(f"Failed to load credentials for {email}: {e}")
-            return None
-    
-    def get_valid_credentials(self, email: str = None) -> Optional[Credentials]:
-        """Get valid credentials for an account, refreshing if necessary
-        
-        Args:
-            email: Email address of account (uses current account if None)
-            
-        Returns:
-            Valid Credentials object or None if authentication required
-        """
-        if email is None:
-            email = self.current_account_email
-        
-        if not email:
-            logger.warning("No current account set")
-            return None
-        
-        credentials = self._load_credentials(email)
-        
-        if not credentials:
-            logger.warning(f"No stored credentials found for {email}")
-            return None
-        
-        # Refresh if expired
-        if credentials.expired and credentials.refresh_token:
-            try:
-                logger.info(f"Refreshing expired credentials for {email}...")
-                credentials.refresh(Request())
-                self._save_credentials(email, credentials)
-                logger.info("Credentials refreshed successfully")
-            except Exception as e:
-                logger.error(f"Failed to refresh credentials for {email}: {e}")
-                return None
-        
-        if not credentials.valid:
-            logger.warning(f"Credentials are not valid for {email}")
-            return None
-        
-        return credentials
-    
-    def is_authenticated(self, email: str = None) -> bool:
-        """Check if user is authenticated
-        
-        Args:
-            email: Email address to check (uses current account if None)
-            
-        Returns:
-            True if valid credentials exist, False otherwise
-        """
-        return self.get_valid_credentials(email) is not None
-    
-    def switch_account(self, email: str) -> bool:
-        """Switch to a different authenticated account
-        
-        Args:
-            email: Email address to switch to
-            
-        Returns:
-            True if switch successful, False if account not found or not authenticated
-        """
-        if self.is_authenticated(email):
-            self._save_current_account(email)
-            logger.info(f"Switched to account: {email}")
-            return True
-        else:
-            logger.error(f"Account {email} is not authenticated")
-            return False
-    
-    def list_accounts(self) -> Dict[str, bool]:
-        """List all stored accounts and their authentication status
-        
-        Returns:
-            Dictionary mapping email addresses to authentication status
-        """
-        accounts = self._load_accounts()
-        result = {}
-        
-        for email in accounts.keys():
-            result[email] = self.is_authenticated(email)
-        
-        return result
-    
-    def remove_account(self, email: str):
-        """Remove an account and its credentials
-        
-        Args:
-            email: Email address to remove
-        """
-        accounts = self._load_accounts()
-        
-        if email in accounts:
-            del accounts[email]
-            
-            # Save updated accounts
-            with open(self.accounts_file, 'w') as f:
-                json.dump(accounts, f, indent=2)
-            
-            # If this was the current account, clear it
-            if self.current_account_email == email:
-                if self.current_account_file.exists():
-                    self.current_account_file.unlink()
-                self.current_account_email = None
-            
-            logger.info(f"Removed account: {email}")
-        else:
-            logger.warning(f"Account {email} not found")
-    
-    def clear_credentials(self):
-        """Clear all stored credentials"""
-        if self.accounts_file.exists():
-            self.accounts_file.unlink()
-        if self.current_account_file.exists():
-            self.current_account_file.unlink()
-        self.current_account_email = None
-        logger.info("All credentials cleared")
-    
-    def get_gmail_service(self, email: str = None):
-        """Get authenticated Gmail service object
-        
-        Args:
-            email: Email address (uses current account if None)
-            
-        Returns:
-            Gmail service object or None if not authenticated
-        """
-        credentials = self.get_valid_credentials(email)
-        if not credentials:
-            return None
-        
-        try:
-            service = googleapiclient.discovery.build(
-                'gmail', 'v1', credentials=credentials
-            )
-            return service
-        except Exception as e:
-            logger.error(f"Failed to build Gmail service: {e}")
-            return None
-    
-    def get_user_email(self, email: str = None) -> Optional[str]:
-        """Get the authenticated user's email address
-        
-        Args:
-            email: Email address (uses current account if None)
-            
-        Returns:
-            User's email address or None if not authenticated
-        """
-        if email is None:
-            return self.current_account_email
-        return email if self.is_authenticated(email) else None
-    
-    def get_current_account(self) -> Optional[str]:
-        """Get the currently selected account
-        
-        Returns:
-            Current account email or None if no account selected
-        """
-        return self.current_account_email
-
-# Global OAuth manager instance
-oauth_manager = GmailOAuthManager(credentials_dir="secure_data") 

agentic_implementation/setup_oauth.py

@@ -1,263 +0,0 @@
-#!/usr/bin/env python3
-"""
-OAuth Setup Utility for Gmail MCP Server
-
-This script helps users set up OAuth authentication for the Gmail MCP server.
-"""
-
-import sys
-import os
-import json
-from pathlib import Path
-from oauth_manager import oauth_manager
-from logger import logger
-from dotenv import load_dotenv
-load_dotenv()
-import os
-
-
-def print_banner():
-    """Print setup banner"""
-    print("=" * 60)
-    print("📧 Gmail MCP Server - OAuth Setup")
-    print("=" * 60)
-    print()
-
-def print_step(step_num: int, title: str):
-    """Print step header"""
-    print(f"\n🔹 Step {step_num}: {title}")
-    print("-" * 50)
-
-def check_dependencies():
-    """Check if required dependencies are installed"""
-    try:
-        import google.auth
-        import google_auth_oauthlib
-        import googleapiclient
-        import cryptography
-        print("✅ All required dependencies are installed")
-        return True
-    except ImportError as e:
-        print(f"❌ Missing dependency: {e}")
-        print("\nPlease install the required dependencies:")
-        print("pip install google-auth google-auth-oauthlib google-api-python-client cryptography")
-        return False
-
-def setup_google_cloud_project():
-    """Guide user through Google Cloud project setup"""
-    print_step(1, "Google Cloud Project Setup")
-    
-    print("You need to create a Google Cloud project and enable the Gmail API.")
-    print("\n📋 Follow these steps:")
-    print("1. Go to: https://console.cloud.google.com/")
-    print("2. Create a new project or select an existing one")
-    print("3. Enable the Gmail API:")
-    print("   - Go to 'APIs & Services' > 'Library'")
-    print("   - Search for 'Gmail API'")
-    print("   - Click 'Enable'")
-    
-    input("\n✅ Press Enter when you've completed these steps...")
-
-def setup_oauth_consent():
-    """Guide user through OAuth consent screen setup"""
-    print_step(2, "OAuth Consent Screen Setup")
-    
-    print("Now you need to configure the OAuth consent screen.")
-    print("\n📋 Follow these steps:")
-    print("1. Go to: https://console.cloud.google.com/apis/credentials/consent")
-    print("2. Choose 'External' user type (unless using Google Workspace)")
-    print("3. Fill in the app information:")
-    print("   - App name: 'Gmail MCP Server' (or your preferred name)")
-    print("   - User support email: Your email address")
-    print("   - Developer contact: Your email address")
-    print("4. Add these scopes:")
-    print("   - https://www.googleapis.com/auth/gmail.readonly")
-    print("   - https://www.googleapis.com/auth/gmail.modify")
-    print("5. Add your email as a test user")
-    print("6. Complete the setup")
-    
-    input("\n✅ Press Enter when you've completed these steps...")
-
-def setup_oauth_credentials():
-    """Guide user through OAuth credentials setup"""
-    print_step(3, "OAuth Client Credentials Setup")
-    
-    client_id     = os.getenv("GOOGLE_CLIENT_ID")
-    client_secret = os.getenv("GOOGLE_CLIENT_SECRET")
-
-    if not client_id or not client_secret:
-        print("❌ Missing GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET in your .env")
-        print("   Please add:")
-        print("     GOOGLE_CLIENT_ID=your-client-id")
-        print("     GOOGLE_CLIENT_SECRET=your-client-secret")
-        return False
-
-    try:
-        oauth_manager.setup_client_secrets(client_id, client_secret)
-        print("✅ OAuth credentials saved successfully")
-        return True
-    except Exception as e:
-        print(f"❌ Failed to save credentials: {e}")
-        return False
-
-def test_authentication():
-    """Test the OAuth authentication flow"""
-    print_step(4, "Authentication Test")
-    
-    print("Now let's test the authentication flow.")
-    print("This will open your web browser for authentication.")
-    
-    confirm = input("\n🌐 Ready to open browser for authentication? (y/n): ").strip().lower()
-    if confirm != 'y':
-        print("Authentication test skipped.")
-        return False
-    
-    try:
-        print("\n🔄 Starting authentication flow...")
-        success = oauth_manager.authenticate_interactive()
-        
-        if success:
-            print("✅ Authentication successful!")
-            
-            # Test getting user info
-            user_email = oauth_manager.get_user_email()
-            if user_email:
-                print(f"✅ Authenticated as: {user_email}")
-            
-            return True
-        else:
-            print("❌ Authentication failed")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Authentication error: {e}")
-        return False
-
-def show_completion_info():
-    """Show completion information and next steps"""
-    print("\n" + "=" * 60)
-    print("🎉 Setup Complete!")
-    print("=" * 60)
-    
-    print("\n✅ Your Gmail MCP server is now configured with OAuth authentication!")
-    print("\n📝 Next steps:")
-    print("1. Start the MCP server:")
-    print("   python email_mcp_server_oauth.py")
-    print("\n2. Configure Claude Desktop:")
-    print('   Add this to your MCP configuration:')
-    print('   {')
-    print('     "mcpServers": {')
-    print('       "gmail-oauth": {')
-    print('         "command": "npx",')
-    print('         "args": ["mcp-remote", "http://localhost:7860/gradio_api/mcp/sse"]')
-    print('       }')
-    print('     }')
-    print('   }')
-    
-    print("\n🔐 Security notes:")
-    print("- Your credentials are encrypted and stored locally")
-    print("- Tokens are automatically refreshed when needed")
-    print("- You can revoke access anytime from Google Account settings")
-    
-    credentials_dir = oauth_manager.credentials_dir
-    print(f"\n📁 Credentials stored in: {credentials_dir}")
-
-def show_help():
-    """Show help information"""
-    print("Gmail MCP Server OAuth Setup")
-    print("\nUsage:")
-    print("  python setup_oauth.py            # Full interactive setup")
-    print("  python setup_oauth.py --help     # Show this help")
-    print("  python setup_oauth.py --auth     # Re-authenticate only")
-    print("  python setup_oauth.py --status   # Check authentication status")
-    print("  python setup_oauth.py --clear    # Clear stored credentials")
-
-def check_status():
-    """Check authentication status"""
-    print("🔍 Checking authentication status...")
-    
-    if oauth_manager.is_authenticated():
-        user_email = oauth_manager.get_user_email()
-        print(f"✅ Authenticated as: {user_email}")
-        return True
-    else:
-        print("❌ Not authenticated")
-        return False
-
-def clear_credentials():
-    """Clear stored credentials"""
-    confirm = input("⚠️  This will clear all stored credentials. Continue? (y/n): ").strip().lower()
-    if confirm == 'y':
-        oauth_manager.clear_credentials()
-        print("✅ Credentials cleared")
-    else:
-        print("Operation cancelled")
-
-def main():
-    """Main setup function"""
-    if len(sys.argv) > 1:
-        arg = sys.argv[1].lower()
-        
-        if arg in ['--help', '-h', 'help']:
-            show_help()
-            return
-        elif arg == '--status':
-            check_status()
-            return
-        elif arg == '--auth':
-            print("🔄 Starting re-authentication...")
-            if test_authentication():
-                print("✅ Re-authentication successful")
-            else:
-                print("❌ Re-authentication failed")
-            return
-        elif arg == '--clear':
-            clear_credentials()
-            return
-        else:
-            print(f"Unknown argument: {arg}")
-            show_help()
-            return
-    
-    # Full interactive setup
-    print_banner()
-    
-    # Check if already authenticated
-    if oauth_manager.is_authenticated():
-        user_email = oauth_manager.get_user_email()
-        print(f"✅ Already authenticated as: {user_email}")
-        
-        choice = input("\n🔄 Do you want to re-authenticate? (y/n): ").strip().lower()
-        if choice == 'y':
-            if test_authentication():
-                show_completion_info()
-        else:
-            print("Setup complete - you're already authenticated!")
-        return
-    
-    # Check dependencies
-    if not check_dependencies():
-        return
-    
-    # Full setup flow
-    try:
-        setup_google_cloud_project()
-        setup_oauth_consent()
-        
-        if not setup_oauth_credentials():
-            print("❌ Setup failed at credentials step")
-            return
-        
-        if test_authentication():
-            show_completion_info()
-        else:
-            print("❌ Setup completed but authentication test failed")
-            print("You can try authentication later with: python setup_oauth.py --auth")
-            
-    except KeyboardInterrupt:
-        print("\n\n⚠️ Setup interrupted by user")
-    except Exception as e:
-        print(f"\n❌ Setup failed: {e}")
-
-if __name__ == "__main__":
-    main() 

app.py

@@ -0,0 +1,64 @@
+import gradio as gr
+from huggingface_hub import InferenceClient
+
+"""
+For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+"""
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    messages = [{"role": "system", "content": system_message}]
+
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = message.choices[0].delta.content
+
+        response += token
+        yield response
+
+
+"""
+For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+"""
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+    ],
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

mcp/client/host.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+CLI host for the FastAPI-powered Swiggy server.
+
+Flow
+1. Send natural-language query → /parse_query
+2. If is_swiggy_query == True and dates are present → /get_orders
+3. Pretty-print the result
+"""
+
+import requests, sys
+from dateutil import parser as dtparse
+
+API_BASE = "http://127.0.0.1:8000"
+
+# ----------------------------------------------------------------------
+# Helpers
+# ----------------------------------------------------------------------
+def nice_date(dt_str: str | None) -> str:
+    if not dt_str:
+        return "??"
+    return dtparse.parse(dt_str).strftime("%d %b %Y")
+
+def pretty_order(order: dict) -> str:
+    if "error" in order:
+        return f"  - Email #{order['email_number']}: ❌  {order['error']}"
+    head = (
+        f"Restaurant : {order['restaurant_name']}\n"
+        f"Date       : {nice_date(order['order_date'])} {order['order_time']}\n"
+        f"Total      : ₹{order['total_price']:.0f}\n"
+        "Items:"
+    )
+    items = "\n".join(
+        f"   • {it['quantity']} × {it['name']} – ₹{it['price']:.0f}"
+        for it in order["items"]
+    )
+    return head + "\n" + items
+
+# ----------------------------------------------------------------------
+# Main REPL
+# ----------------------------------------------------------------------
+def main() -> None:
+    # Quick health-check
+    try:
+        requests.get(f"{API_BASE}/docs").raise_for_status()
+    except Exception as e:
+        print("❌  Cannot reach FastAPI server:", e)
+        sys.exit(1)
+    print("✅  Connected. Type a Swiggy question (or Ctrl-C to quit).")
+
+    while True:
+        try:
+            query = input("\n🗨️  You: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            break
+        if not query:
+            continue
+
+        # ── Stage 1: parse_query ────────────────────────────────────
+        try:
+            r = requests.post(f"{API_BASE}/parse_query", json={"query": query})
+            r.raise_for_status()
+            meta = r.json()          # {is_swiggy_query, start_date, end_date, intent}
+        except Exception as e:
+            print("⚠️  Parse error:", e)
+            print("🔎  Server:", r.text if 'r' in locals() else "no response")
+            continue
+
+        # Handle non-Swiggy or missing dates
+        if not meta.get("is_swiggy_query"):
+            print("🤷  That doesn’t look like a Swiggy order query.")
+            continue
+        if not meta.get("start_date") or not meta.get("end_date"):
+            print("⚠️  Couldn’t find a full date range in your question.")
+            continue
+
+        print(f"   ↳ Date range: {meta['start_date']} → {meta['end_date']}")
+        print(f"   ↳ Intent    : {meta['intent']}")
+
+        # ── Stage 2: get_orders ────────────────────────────────────
+        try:
+            r2 = requests.post(
+                f"{API_BASE}/get_orders",
+                json={
+                    "start_date": meta["start_date"],
+                    "end_date":   meta["end_date"],
+                },
+            )
+            r2.raise_for_status()
+            orders = r2.json()
+        except Exception as e:
+            print("⚠️  Failed to fetch orders:", e)
+            print("🔎  Server:", r2.text if 'r2' in locals() else "no response")
+            continue
+
+        # ── Output ────────────────────────────────────────────────
+        if not orders:
+            print("😕  No orders found for that range.")
+            continue
+
+        print("\n📦  Orders:")
+        for o in orders:
+            print(pretty_order(o))
+            print("-" * 40)
+
+    print("\n👋  Bye!")
+
+# ----------------------------------------------------------------------
+if __name__ == "__main__":
+    main()

mcp/server/db_schema.py

@@ -0,0 +1,124 @@
+# File: db_schema.py
+import sqlite3
+
+DB_NAME = "swiggy_orders.db"
+
+
+def init_db(db_path: str = DB_NAME) -> None:
+    """
+    Initialize the SQLite database with the necessary tables.
+    """
+    conn = sqlite3.connect(db_path)
+    c = conn.cursor()
+    # Orders metadata
+    c.execute(
+        """
+        CREATE TABLE IF NOT EXISTS orders (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            email_number INTEGER,
+            order_date TEXT,
+            order_time TEXT,
+            restaurant_name TEXT,
+            delivery_address TEXT,
+            total_price REAL
+        )
+        """
+    )
+    # Individual items per order
+    c.execute(
+        """
+        CREATE TABLE IF NOT EXISTS order_items (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            item_name TEXT,
+            quantity INTEGER,
+            price REAL,
+            FOREIGN KEY(order_id) REFERENCES orders(id)
+        )
+        """
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_db_connection(db_path: str = DB_NAME) -> sqlite3.Connection:
+    """Return a new connection to the database."""
+    return sqlite3.connect(db_path)
+
+
+def get_orders_by_date_from_db(date_str: str) -> list[dict]:
+    """
+    Fetch all orders and their items for a given date from the database.
+    """
+    conn = get_db_connection()
+    c = conn.cursor()
+    c.execute(
+        "SELECT id, email_number, order_time, restaurant_name, delivery_address, total_price"
+        " FROM orders WHERE order_date = ?",
+        (date_str,)
+    )
+    orders = []
+    for order_id, email_number, order_time, restaurant_name, delivery_address, total_price in c.fetchall():
+        # fetch items for this order
+        c.execute(
+            "SELECT item_name, quantity, price FROM order_items WHERE order_id = ?",
+            (order_id,)
+        )
+        items = [
+            {"name": name, "quantity": qty, "price": price}
+            for name, qty, price in c.fetchall()
+        ]
+        orders.append({
+            "email_number": email_number,
+            "order_date": date_str,
+            "order_time": order_time,
+            "restaurant_name": restaurant_name,
+            "delivery_address": delivery_address,
+            "items": items,
+            "total_price": total_price
+        })
+    conn.close()
+    return orders
+
+
+def save_orders_to_db(date_str: str, orders: list[dict]) -> None:
+    """
+    Insert scraped orders and their items for a given date into the database.
+    """
+    conn = get_db_connection()
+    c = conn.cursor()
+    for order in orders:
+        c.execute(
+            """
+            INSERT INTO orders
+                (email_number, order_date, order_time, restaurant_name, delivery_address, total_price)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                order["email_number"],
+                date_str,
+                order["order_time"],
+                order["restaurant_name"],
+                order["delivery_address"],
+                order["total_price"]
+            )
+        )
+        order_id = c.lastrowid
+        for item in order.get("items", []):
+            c.execute(
+                """
+                INSERT INTO order_items
+                    (order_id, item_name, quantity, price)
+                VALUES (?, ?, ?, ?)
+                """,
+                (
+                    order_id,
+                    item["name"],
+                    item["quantity"],
+                    item["price"]
+                )
+            )
+    conn.commit()
+    conn.close()
+
+

mcp/server/eval.txt

@@ -0,0 +1,37 @@
+EVALUATIONS
+
+able to differentiate between swiggy based queries or not
+able to break prompts into 2 instruction. First instruction will be extracting dates. 
+second instructions will be analysing the data scrapped.  
+able to extract dates
+able to extract the analysis:
+
+-How much non-veg did I order last week / between date X and date Y?
+
+-Counts and/or total rupees spent on non-veg dishes.
+
+-What was my total expense between date X and date Y?
+
+-What is my average daily spend on Swiggy (overall or for a given period)?
+
+-Which restaurant got the most orders (or the most money) in that period?
+
+-What single order cost me the most during that window?
+
+-Show a day-by-day spend chart between date X and date Y.
+
+-List every item I’ve ordered only once—my “one-hit wonders.”
+
+-How many unique cuisines did I try in the last month?
+
+-Compare veg vs. non-veg spend for the current calendar year.
+
+-When was my longest streak of days without ordering anything?
+
+-Identify any “late-night” orders placed after 11 p.m. this week.
+
+-Tell me my top three most-ordered dishes in the past six months.
+
+-Which new restaurant did I try most recently, and what did I order?
+
+-Forecast next month’s spend based on my last three-month trend.

mcp/server/main.py

@@ -0,0 +1,24 @@
+# File: main.py
+from fastapi import FastAPI
+from contextlib import asynccontextmanager
+from routes import router
+from db_schema import init_db
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("🚀 Server is starting up...")
+    # Ensure SQLite tables exist before handling requests
+    init_db()
+    yield
+    print("🧹 Server is shutting down... Cleaned up!")
+
+app = FastAPI(
+    title="Swiggy Email API",
+    description="Extract Swiggy orders from Gmail",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+app.include_router(router)
+
+# Run with: uvicorn main:app --reload

mcp/server/routes.py

@@ -0,0 +1,167 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from swiggy_scraper import fetch_swiggy_orders
+from datetime import datetime
+from openai import OpenAI
+import os, json
+
+router = APIRouter()
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+class QueryInput(BaseModel):
+    query: str
+
+class DateRange(BaseModel):
+    start_date: str
+    end_date: str
+
+# @router.post("/parse_query")
+# def parse_query_llm(input: QueryInput):
+
+#     print("\ninput query:")
+#     print(input)
+
+#     today_str = datetime.today().strftime("%d-%b-%Y")
+#     system = (
+#         f"You are a date range extractor.\n"
+#         f"Today is {today_str}.\n"
+#         "Extract start_date and end_date in 'DD-MMM-YYYY' format.\n"
+#         "Respond with:\n"
+#         "Output ONLY a valid JSON object like:\n"
+#         '{ "start_date": "17-May-2025", "end_date": "18-May-2025" }\n'
+#         'no extra commentry needed.'
+#     )
+#     try:
+#         rsp = client.chat.completions.create(
+#             model="gpt-4o-mini",
+#             temperature=0,
+#             messages=[
+#                 {"role": "system", "content": system},
+#                 {"role": "user", "content": input.query},
+#             ]
+#         )
+#         result = json.loads(rsp.choices[0].message.content.strip())
+#         if "start_date" not in result or "end_date" not in result:
+#             raise ValueError("Invalid response format")
+#         print("results:", result)
+#         return result
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+
+
+
+
+
+
+
+def _llm(messages, model="gpt-4o-mini", temperature=0):
+    rsp = client.chat.completions.create(
+        model=model,
+        temperature=temperature,
+        messages=messages,
+    )
+    return rsp.choices[0].message.content.strip()
+
+# ----------  Stage 1: classify + extract dates --------------------------
+
+def _extract_scope(user_query: str):
+    today_str = datetime.today().strftime("%d-%b-%Y")
+
+    sys_prompt = f"""
+Today is {today_str}.
+You are a SCOPING assistant: decide if the user's text is about Swiggy food orders,
+extract ONE date range, and keep the leftover words.
+
+Return ONLY valid JSON like:
+{{
+  "is_swiggy_query": true,
+  "start_date": "15-May-2025",
+  "end_date":   "20-May-2025",
+  "remainder":  "non veg expense"
+}}
+
+Rules:
+• Accept natural phrases (“last week”, “since 1 May”).  
+• If no dates → start_date & end_date = null.  
+• If not Swiggy related → is_swiggy_query=false and remainder is full original text.  
+• Do NOT invent a remainder; it is literally whatever words follow the date phrase(s).  
+"""
+    raw = _llm(
+        [
+            {"role": "system", "content": sys_prompt},
+            {"role": "user",   "content": user_query}
+        ]
+    )
+    return json.loads(raw)
+
+# ----------  Stage 2: shrink “remainder” into an intent -----------------
+
+def _extract_intent(remainder: str):
+    sys_prompt = """
+You are an INTENT classifier for Swiggy-order analytics.
+Map the sentence into one concise snake_case intent.
+Allowed intents (extendable):
+
+• calculate_expense
+• list_orders
+• list_items
+• list_nonveg_items
+• list_veg_items
+• count_orders
+• unknown
+
+Return JSON: { "intent": "calculate_expense" }
+If unsure choose "unknown".
+"""
+    raw = _llm(
+        [
+            {"role": "system", "content": sys_prompt},
+            {"role": "user",   "content": remainder.strip()}
+        ]
+    )
+    return json.loads(raw)["intent"]
+
+# ----------  FastAPI route ----------------------------------------------
+
+@router.post("/parse_query")
+def parse_query_llm(input: QueryInput):
+    try:
+        scope = _extract_scope(input.query)
+        print("scope")
+        print(scope)
+        # If it is a Swiggy query, classify intent; else, intent = "unrelated"
+        if scope.get("is_swiggy_query", False):
+            intent = _extract_intent(scope.get("remainder", ""))
+        else:
+            intent = "unrelated"
+
+        result = {
+            "is_swiggy_query": scope["is_swiggy_query"],
+            "start_date":      scope["start_date"],
+            "end_date":        scope["end_date"],
+            "intent":          intent
+        }
+
+
+        print("result")
+        print(result)
+
+        return result
+
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+
+
+
+
+
+
+@router.post("/get_orders")
+def get_orders(range: DateRange):
+    try:
+        orders = fetch_swiggy_orders(range.start_date, range.end_date)
+        return orders
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

mcp/server/swiggy_cache.json

@@ -0,0 +1,1379 @@
+{
+  "2025-05-17": [
+    {
+      "email_number": 1,
+      "order_date": "17-May-2025",
+      "order_time": "11:00:08",
+      "restaurant_name": "IDC Kitchen",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Thatte Idli",
+          "quantity": 1,
+          "price": 59
+        },
+        {
+          "name": "Idly 2 Pc",
+          "quantity": 1,
+          "price": 59
+        },
+        {
+          "name": "Vada (1 Pc)",
+          "quantity": 3,
+          "price": 174
+        }
+      ],
+      "total_price": 330
+    },
+    {
+      "email_number": 2,
+      "order_date": "17-May-2025",
+      "order_time": "17:02:59",
+      "restaurant_name": "Suryawanshi",
+      "delivery_address": "Shobhit\n2C, Orchard Green Apartment\n2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Vada Pav (twin)",
+          "quantity": 1,
+          "price": 95
+        },
+        {
+          "name": "Kande Bhaji",
+          "quantity": 1,
+          "price": 160
+        }
+      ],
+      "total_price": 300
+    },
+    {
+      "email_number": 3,
+      "order_date": "17-May-2025",
+      "order_time": "20:25:39",
+      "restaurant_name": "Meghana Foods",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Extra Aloo 4 Pcs",
+          "quantity": 1,
+          "price": 45
+        },
+        {
+          "name": "Chicken Boneless Biryani",
+          "quantity": 1,
+          "price": 360
+        },
+        {
+          "name": "Lemon Chicken",
+          "quantity": 1,
+          "price": 360
+        },
+        {
+          "name": "Veg Manchurian Biryani",
+          "quantity": 1,
+          "price": 360
+        }
+      ],
+      "total_price": 1240
+    }
+  ],
+  "2025-05-19": [
+    {
+      "email_number": 1,
+      "order_date": "19-May-2025",
+      "order_time": "22:28:08",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Safal Frozen Green Peas (Matar)",
+          "quantity": 1,
+          "price": 110
+        },
+        {
+          "name": "NOTO Strawberry Raspberry Sugar Free Popsicle Ice Cream",
+          "quantity": 4,
+          "price": 500
+        },
+        {
+          "name": "Baby Lady's Finger  (Bendekaayi)",
+          "quantity": 2,
+          "price": 32
+        },
+        {
+          "name": "Whisper Ultra Skin Love Soft 30 Xl+ Sanitary Pads, Cottony Soft",
+          "quantity": 1,
+          "price": 323
+        },
+        {
+          "name": "Akshayakalpa Artisanal Organic Set Curd",
+          "quantity": 1,
+          "price": 145
+        },
+        {
+          "name": "Akshayakalpa Organic Malai Paneer",
+          "quantity": 1,
+          "price": 119
+        },
+        {
+          "name": "Aashirvaad Superior MP Atta",
+          "quantity": 2,
+          "price": 146
+        },
+        {
+          "name": "NOTO Kala Jamun Sugar Free Popsicle Ice Cream",
+          "quantity": 2,
+          "price": 250
+        },
+        {
+          "name": "Royal Gala Apple (Sebu)",
+          "quantity": 2,
+          "price": 356
+        }
+      ],
+      "total_price": 1564
+    }
+  ],
+  "2025-05-01": [
+    {
+      "email_number": 1,
+      "order_date": "01-May-2025",
+      "order_time": "11:36:15",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 2,
+          "price": 710
+        }
+      ],
+      "total_price": 647
+    },
+    {
+      "email_number": 2,
+      "order_date": "01-May-2025",
+      "order_time": "18:34:08",
+      "restaurant_name": "Chaayos Chai+Snacks=Relax",
+      "delivery_address": "Shobhit\n2C, Orchard Green Apartment\n2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Vada Pav",
+          "quantity": 2,
+          "price": 238
+        },
+        {
+          "name": "Desi Chai",
+          "quantity": 1,
+          "price": 219
+        },
+        {
+          "name": "Samosa(2 pc)",
+          "quantity": 1,
+          "price": 90
+        }
+      ],
+      "total_price": 528
+    },
+    {
+      "email_number": 3,
+      "order_date": "01-May-2025",
+      "order_time": "21:28:12",
+      "restaurant_name": "Lavonne Cafe",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Baguette",
+          "quantity": 1,
+          "price": 190.48
+        }
+      ],
+      "total_price": 278
+    }
+  ],
+  "2025-05-02": [
+    {
+      "email_number": 1,
+      "order_date": "02-May-2025",
+      "order_time": "11:13:38",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 315
+        },
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 355
+        }
+      ],
+      "total_price": 605
+    },
+    {
+      "email_number": 2,
+      "order_date": "02-May-2025",
+      "order_time": "14:43:19",
+      "restaurant_name": "Harvest Salad Co",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Hummus And Chipotle Chicken Wrap",
+          "quantity": 2,
+          "price": 498
+        },
+        {
+          "name": "Mediterranean Bowl (Veg)",
+          "quantity": 1,
+          "price": 299
+        }
+      ],
+      "total_price": 899
+    },
+    {
+      "email_number": 3,
+      "order_date": "02-May-2025",
+      "order_time": "21:10:20",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Classic Ice Burst",
+          "quantity": 1,
+          "price": 170
+        }
+      ],
+      "total_price": 222
+    },
+    {
+      "email_number": 4,
+      "order_date": "02-May-2025",
+      "order_time": "22:01:35",
+      "restaurant_name": "Dhaba Estd 1986 Delhi",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Non Vegetarian Platter ( 12 Pcs)",
+          "quantity": 1,
+          "price": 1249
+        },
+        {
+          "name": "Butter Naan",
+          "quantity": 2,
+          "price": 198
+        },
+        {
+          "name": "Dhabe Di Roti",
+          "quantity": 2,
+          "price": 238
+        },
+        {
+          "name": "Laal Mirchi Parantha",
+          "quantity": 1,
+          "price": 109
+        },
+        {
+          "name": "Handi Murgh",
+          "quantity": 1,
+          "price": 629
+        }
+      ],
+      "total_price": 2006
+    }
+  ],
+  "2025-05-03": [
+    {
+      "email_number": 1,
+      "order_date": "03-May-2025",
+      "order_time": "09:50:51",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Cold Brew Black",
+          "quantity": 1,
+          "price": 410
+        },
+        {
+          "name": "Caffe Americano.",
+          "quantity": 1,
+          "price": 315
+        }
+      ],
+      "total_price": 691
+    },
+    {
+      "email_number": 2,
+      "order_date": "03-May-2025",
+      "order_time": "15:06:18",
+      "restaurant_name": "Copper + Cloves",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Asian Peanut Salad",
+          "quantity": 1,
+          "price": 500
+        },
+        {
+          "name": "Tofu",
+          "quantity": 1,
+          "price": 100
+        }
+      ],
+      "total_price": 432
+    },
+    {
+      "email_number": 3,
+      "order_date": "03-May-2025",
+      "order_time": "21:32:47",
+      "restaurant_name": "Shiro",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Super Crunch (8 pcs)",
+          "quantity": 1,
+          "price": 695
+        },
+        {
+          "name": "Bulgogi Chicken Spring Rolls (6 pcs)",
+          "quantity": 1,
+          "price": 595
+        },
+        {
+          "name": "Cantonese Chicken Wonton (6 pcs)",
+          "quantity": 1,
+          "price": 410
+        },
+        {
+          "name": "Smoky Pork Gyoza (4 pcs)",
+          "quantity": 1,
+          "price": 495
+        },
+        {
+          "name": "Spicy Salmon Negi (8 pcs)",
+          "quantity": 1,
+          "price": 670
+        }
+      ],
+      "total_price": 2600
+    }
+  ],
+  "2025-05-04": [
+    {
+      "email_number": 1,
+      "order_date": "04-May-2025",
+      "order_time": "09:54:22",
+      "restaurant_name": "IDC Kitchen",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Masala Dosa",
+          "quantity": 1,
+          "price": 140
+        },
+        {
+          "name": "Idly 2 Pc",
+          "quantity": 1,
+          "price": 59
+        },
+        {
+          "name": "Thatte Idli",
+          "quantity": 1,
+          "price": 59
+        },
+        {
+          "name": "Vada (1 Pc)",
+          "quantity": 1,
+          "price": 58
+        }
+      ],
+      "total_price": 356
+    },
+    {
+      "email_number": 2,
+      "order_date": "04-May-2025",
+      "order_time": "10:21:33",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 315
+        },
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 355
+        }
+      ],
+      "total_price": 694
+    }
+  ],
+  "2025-05-05": [
+    {
+      "email_number": 1,
+      "order_date": "05-May-2025",
+      "order_time": "09:23:24",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 315
+        },
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 355
+        }
+      ],
+      "total_price": 694
+    },
+    {
+      "email_number": 2,
+      "order_date": "05-May-2025",
+      "order_time": "13:58:29",
+      "restaurant_name": "Maverick & Farmer Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Cold Brew Latte",
+          "quantity": 1,
+          "price": 300
+        },
+        {
+          "name": "Smoked Tandoori Chicken",
+          "quantity": 1,
+          "price": 450
+        }
+      ],
+      "total_price": 730
+    },
+    {
+      "email_number": 3,
+      "order_date": "05-May-2025",
+      "order_time": "14:42:09",
+      "restaurant_name": "Magnolia Bakery",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "CLASSIC TRES LECHES",
+          "quantity": 1,
+          "price": 410
+        }
+      ],
+      "total_price": 538
+    },
+    {
+      "email_number": 4,
+      "order_date": "05-May-2025",
+      "order_time": "21:09:39",
+      "restaurant_name": "Hyderabad Biryaani House",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Mutton Biryani Family Pack",
+          "quantity": 1,
+          "price": 749
+        }
+      ],
+      "total_price": 806
+    }
+  ],
+  "2025-05-06": [
+    {
+      "email_number": 1,
+      "order_date": "06-May-2025",
+      "order_time": "09:58:07",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Yellaki Banana (Baalehannu)",
+          "quantity": 1,
+          "price": 59
+        },
+        {
+          "name": "Robusta Banana (Pachha Baalehannu)",
+          "quantity": 1,
+          "price": 30
+        },
+        {
+          "name": "Eggoz Farm Fresh High Protein White Eggs Box",
+          "quantity": 1,
+          "price": 325
+        },
+        {
+          "name": "Amul Processed Cheese Slices",
+          "quantity": 1,
+          "price": 145
+        },
+        {
+          "name": "NOTO Orange Sugar Free Popsicle Ice Cream",
+          "quantity": 2,
+          "price": 157.5
+        },
+        {
+          "name": "Rocket Leaves (Arugula)",
+          "quantity": 1,
+          "price": 54
+        },
+        {
+          "name": "Royal Gala Apple (Sebu)",
+          "quantity": 2,
+          "price": 254.6
+        },
+        {
+          "name": "NOTO Kala Jamun Sugar Free Popsicle Ice Cream",
+          "quantity": 2,
+          "price": 132.5
+        },
+        {
+          "name": "Imported Avocado - Tanzania",
+          "quantity": 1,
+          "price": 75
+        },
+        {
+          "name": "Ratnagiri Alphonso Mango (Hapus)",
+          "quantity": 1,
+          "price": 415
+        },
+        {
+          "name": "Indian Blueberries",
+          "quantity": 1,
+          "price": 199
+        },
+        {
+          "name": "Flyer Dil Foods",
+          "quantity": 1,
+          "price": 0
+        },
+        {
+          "name": "Premium Guava (Thai)",
+          "quantity": 1,
+          "price": 71
+        },
+        {
+          "name": "Lettuce Mix Salad",
+          "quantity": 2,
+          "price": 120
+        }
+      ],
+      "total_price": 2049
+    },
+    {
+      "email_number": 2,
+      "order_date": "06-May-2025",
+      "order_time": "10:51:28",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 355
+        },
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 315
+        }
+      ],
+      "total_price": 694
+    },
+    {
+      "email_number": 3,
+      "order_date": "06-May-2025",
+      "order_time": "11:06:59",
+      "restaurant_name": "Yogisthaan",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Tapioca (sabu Dana) Khichadi",
+          "quantity": 1,
+          "price": 252
+        },
+        {
+          "name": "Sattu Paratha",
+          "quantity": 1,
+          "price": 288
+        }
+      ],
+      "total_price": 537
+    },
+    {
+      "email_number": 4,
+      "order_date": "06-May-2025",
+      "order_time": "15:05:22",
+      "restaurant_name": "Sweet Karam Coffee",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Sweet Karam Coffee Tapioca Chips (Kappa) - No Palm Oil",
+          "quantity": 1,
+          "price": 65
+        },
+        {
+          "name": "Sweet Karam Coffee Special Madras Mixture (No Palm Oil)",
+          "quantity": 1,
+          "price": 90
+        },
+        {
+          "name": "Sweet Karam Coffee Peanut Chikki Bites (No White Sugar, No Liquid Glucose)",
+          "quantity": 1,
+          "price": 87
+        },
+        {
+          "name": "Mother's Recipe Potato Masala Papad",
+          "quantity": 4,
+          "price": 126.64
+        },
+        {
+          "name": "Sweet Karam Coffee Kerala Nendran Banana Chips",
+          "quantity": 1,
+          "price": 87.12
+        },
+        {
+          "name": "Iyer's Rice Papad Buy 1 Get 1 (inside one pack)",
+          "quantity": 1,
+          "price": 64
+        },
+        {
+          "name": "Ginger kombucha (Low cal, Low sugar)",
+          "quantity": 4,
+          "price": 368.28
+        }
+      ],
+      "total_price": 899
+    },
+    {
+      "email_number": 5,
+      "order_date": "06-May-2025",
+      "order_time": "22:36:46",
+      "restaurant_name": "Misu",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India.",
+      "items": [
+        {
+          "name": "Spicy Chilli Basil Noodles Non-veg",
+          "quantity": 1,
+          "price": 465
+        },
+        {
+          "name": "Vietnamese Pho Chicken",
+          "quantity": 1,
+          "price": 305
+        },
+        {
+          "name": "Sour & Spicy Dumplings Chicken (6 Pcs)",
+          "quantity": 1,
+          "price": 405
+        }
+      ],
+      "total_price": 1117
+    }
+  ],
+  "2025-05-07": [
+    {
+      "email_number": 1,
+      "order_date": "07-May-2025",
+      "order_time": "13:26:32",
+      "restaurant_name": "Kale - A Salad Symphony",
+      "delivery_address": "Shobhit\n2nd Floor\nKariyammana Agrahara Road, Marathahalli, Bengaluru, Karnataka 560037, India. (Divyasree Technopolis)",
+      "items": [
+        {
+          "name": "Thai Chicken Bowl (nutrients & Vitamin B12)",
+          "quantity": 1,
+          "price": 425
+        },
+        {
+          "name": "Green Protein Smoothie",
+          "quantity": 1,
+          "price": 250
+        }
+      ],
+      "total_price": 693
+    },
+    {
+      "email_number": 2,
+      "order_date": "07-May-2025",
+      "order_time": "13:53:43",
+      "restaurant_name": "Chakum Chukum",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Chicken Tikka Roll",
+          "quantity": 1,
+          "price": 237.15
+        },
+        {
+          "name": "Kasundi Paneer Roll",
+          "quantity": 1,
+          "price": 275.24
+        }
+      ],
+      "total_price": 518
+    },
+    {
+      "email_number": 3,
+      "order_date": "07-May-2025",
+      "order_time": "20:50:27",
+      "restaurant_name": "Lavonne Cafe",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Sourdough Bread Plain",
+          "quantity": 1,
+          "price": 219.05
+        }
+      ],
+      "total_price": 41
+    },
+    {
+      "email_number": 4,
+      "order_date": "07-May-2025",
+      "order_time": "21:51:42",
+      "restaurant_name": "Basco And Fry",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Truffle Shroom Burger",
+          "quantity": 1,
+          "price": 365
+        },
+        {
+          "name": "Peri Peri Wings",
+          "quantity": 1,
+          "price": 425
+        },
+        {
+          "name": "Chicken Katsu Burger",
+          "quantity": 1,
+          "price": 365
+        }
+      ],
+      "total_price": 1100
+    }
+  ],
+  "2025-05-08": [
+    {
+      "email_number": 1,
+      "order_date": "08-May-2025",
+      "order_time": "13:04:12",
+      "restaurant_name": "NATRAJ Chole bhature",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Chole Bhature(full Plate)",
+          "quantity": 1,
+          "price": 225
+        },
+        {
+          "name": "Samosa(1pc)",
+          "quantity": 1,
+          "price": 45
+        }
+      ],
+      "total_price": 310
+    },
+    {
+      "email_number": 2,
+      "order_date": "08-May-2025",
+      "order_time": "14:27:04",
+      "restaurant_name": "Salad Days",
+      "delivery_address": "2nd Floor, Kariyammana Agrahara Road, Marathahalli, Bengaluru, Karnataka 560037, India. (Divyasree Technopolis)",
+      "items": [
+        {
+          "name": "Asian Chicken, Egg & Soba Noodle Salad",
+          "quantity": 1,
+          "price": 379
+        },
+        {
+          "name": "Green Pressed Juice",
+          "quantity": 1,
+          "price": 199
+        }
+      ],
+      "total_price": 655
+    },
+    {
+      "email_number": 3,
+      "order_date": "08-May-2025",
+      "order_time": "22:47:20",
+      "restaurant_name": "Mahesh Lunch Home",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Appam",
+          "quantity": 2,
+          "price": 60
+        },
+        {
+          "name": "Chicken Ghee Roast",
+          "quantity": 1,
+          "price": 460
+        },
+        {
+          "name": "Butter Roti",
+          "quantity": 2,
+          "price": 80
+        },
+        {
+          "name": "Chicken Manglorean",
+          "quantity": 1,
+          "price": 405
+        },
+        {
+          "name": "Neer Dosa (4 Pcs)",
+          "quantity": 1,
+          "price": 80
+        },
+        {
+          "name": "Dal Fry",
+          "quantity": 1,
+          "price": 210
+        }
+      ],
+      "total_price": 1267
+    },
+    {
+      "email_number": 4,
+      "order_date": "08-May-2025",
+      "order_time": "23:41:54",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "NOTO Strawberry Raspberry Sugar Free Popsicle Ice Cream",
+          "quantity": 4,
+          "price": 325
+        },
+        {
+          "name": "NOTO Orange Sugar Free Popsicle Ice Cream",
+          "quantity": 2,
+          "price": 162.5
+        }
+      ],
+      "total_price": 498
+    }
+  ],
+  "2025-05-09": [
+    {
+      "email_number": 1,
+      "order_date": "09-May-2025",
+      "order_time": "15:22:57",
+      "restaurant_name": "Kale - A Salad Symphony",
+      "delivery_address": "Shobhit\n2nd Floor\nKariyammana Agrahara Road, Marathahalli, Bengaluru, Karnataka 560037, India. (Divyasree Technopolis)",
+      "items": [
+        {
+          "name": "Thai Chicken Bowl (nutrients & Vitamin B12)",
+          "quantity": 1,
+          "price": 425
+        },
+        {
+          "name": "Green Protein Smoothie",
+          "quantity": 1,
+          "price": 250
+        }
+      ],
+      "total_price": 693
+    },
+    {
+      "email_number": 2,
+      "order_date": "09-May-2025",
+      "order_time": "16:25:50",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Kodai Parmesan Cheese",
+          "quantity": 1,
+          "price": 475
+        }
+      ],
+      "total_price": 487
+    }
+  ],
+  "2025-05-10": [
+    {
+      "email_number": 1,
+      "order_date": "10-May-2025",
+      "order_time": "13:34:39",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Gooseberry (Nellikaayi)",
+          "quantity": 1,
+          "price": 39
+        },
+        {
+          "name": "Fresh Turmeric",
+          "quantity": 2,
+          "price": 42
+        },
+        {
+          "name": "Licious Chicken Curry Cut (Large Pieces) - Skinless",
+          "quantity": 1,
+          "price": 165
+        },
+        {
+          "name": "White Radish (Moolangi)",
+          "quantity": 2,
+          "price": 30.6
+        },
+        {
+          "name": "English Cucumber (Sowthekaayi)",
+          "quantity": 2,
+          "price": 65.8
+        },
+        {
+          "name": "Robusta Banana (Pachha Baalehannu)",
+          "quantity": 1,
+          "price": 44
+        },
+        {
+          "name": "Curry Leaves (Karibevu)",
+          "quantity": 1,
+          "price": 11
+        },
+        {
+          "name": "Green Chilli (Hasiru Menasinakaayi)",
+          "quantity": 1,
+          "price": 12
+        },
+        {
+          "name": "Coriander - Without Roots (Kotthambari)",
+          "quantity": 1,
+          "price": 18
+        },
+        {
+          "name": "Ginger (Shunti)",
+          "quantity": 1,
+          "price": 16
+        },
+        {
+          "name": "Premium Guava (Thai)",
+          "quantity": 2,
+          "price": 131.4
+        },
+        {
+          "name": "Royal Gala Apple (Sebu)",
+          "quantity": 2,
+          "price": 275
+        }
+      ],
+      "total_price": 862
+    },
+    {
+      "email_number": 2,
+      "order_date": "10-May-2025",
+      "order_time": "17:23:45",
+      "restaurant_name": "Irani Std. Tea",
+      "delivery_address": "Swiggy,Tower D, 9th Floor, IBC Knowledge Park, Bannerghatta Road, Bangalore - 560029",
+      "items": [],
+      "total_price": 291
+    },
+    {
+      "email_number": 3,
+      "order_date": "10-May-2025",
+      "order_time": "18:05:00",
+      "restaurant_name": "Irani Std. Tea",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India",
+      "items": [
+        {
+          "name": "Irani Ginger Chai",
+          "quantity": 1,
+          "price": 219
+        },
+        {
+          "name": "Osmania Biscuits 100 Grams",
+          "quantity": 1,
+          "price": 100
+        },
+        {
+          "name": "Bun Maska",
+          "quantity": 2,
+          "price": 158
+        }
+      ],
+      "total_price": 399
+    }
+  ],
+  "2025-05-11": [
+    {
+      "email_number": 1,
+      "order_date": "11-May-2025",
+      "order_time": "12:36:17",
+      "restaurant_name": "Anand Sweets & Savouries",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India.",
+      "items": [
+        {
+          "name": "Shahi Tohfa Dry Fruits 750 Gms",
+          "quantity": 1,
+          "price": 1022.32
+        }
+      ],
+      "total_price": 1167
+    },
+    {
+      "email_number": 2,
+      "order_date": "11-May-2025",
+      "order_time": "21:17:18",
+      "restaurant_name": "Hotel Empire",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Paneer Butter Masala",
+          "quantity": 1,
+          "price": 252
+        },
+        {
+          "name": "Kerala Parotta",
+          "quantity": 1,
+          "price": 39
+        },
+        {
+          "name": "Coin Parotta",
+          "quantity": 2,
+          "price": 64
+        },
+        {
+          "name": "Dal Fry",
+          "quantity": 1,
+          "price": 137
+        },
+        {
+          "name": "Ghee Rice",
+          "quantity": 1,
+          "price": 110
+        },
+        {
+          "name": "Malabar Parotta",
+          "quantity": 2,
+          "price": 70
+        }
+      ],
+      "total_price": 749
+    }
+  ],
+  "2025-05-12": [
+    {
+      "email_number": 1,
+      "order_date": "12-May-2025",
+      "order_time": "22:12:42",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "NOTO Strawberry Raspberry Sugar Free Popsicle Ice Cream",
+          "quantity": 4,
+          "price": 275
+        },
+        {
+          "name": "NOTO Orange Sugar Free Popsicle Ice Cream",
+          "quantity": 2,
+          "price": 137.5
+        }
+      ],
+      "total_price": 423
+    }
+  ],
+  "2025-05-13": [],
+  "2025-05-14": [
+    {
+      "email_number": 1,
+      "order_date": "14-May-2025",
+      "order_time": "14:14:14",
+      "restaurant_name": "Swiggy Instamart",
+      "delivery_address": "2C, Orchard Green Apartment  2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Robusta Banana (Pachha Baalehannu)",
+          "quantity": 1,
+          "price": 42
+        },
+        {
+          "name": "Coriander - Without Roots (Kotthambari)",
+          "quantity": 1,
+          "price": 18
+        },
+        {
+          "name": "Tata Sampann Turmeric Powder Masala",
+          "quantity": 2,
+          "price": 85.04
+        },
+        {
+          "name": "Organic Certified Onion (Eerulli)",
+          "quantity": 1,
+          "price": 66
+        },
+        {
+          "name": "NOTO Strawberry Raspberry Sugar Free Popsicle Ice Cream",
+          "quantity": 4,
+          "price": 275
+        },
+        {
+          "name": "Premium Guava (Thai)",
+          "quantity": 2,
+          "price": 154
+        },
+        {
+          "name": "Garlic (Bellulli)",
+          "quantity": 1,
+          "price": 47
+        },
+        {
+          "name": "Royal Gala Apple (Sebu)",
+          "quantity": 1,
+          "price": 142
+        }
+      ],
+      "total_price": 841
+    }
+  ],
+  "2025-05-15": [],
+  "2025-05-16": [
+    {
+      "email_number": 1,
+      "order_date": "16-May-2025",
+      "order_time": "15:43:43",
+      "restaurant_name": "Glen's Bakehouse",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Mushroom Puff",
+          "quantity": 1,
+          "price": 62.86
+        },
+        {
+          "name": "Chicken Puff",
+          "quantity": 1,
+          "price": 84.23
+        }
+      ],
+      "total_price": 235
+    },
+    {
+      "email_number": 2,
+      "order_date": "16-May-2025",
+      "order_time": "15:48:57",
+      "restaurant_name": "The Himalayan Momo Company",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Woked Maggi",
+          "quantity": 1,
+          "price": 209
+        },
+        {
+          "name": "Himalayan Steamed Chicken Momos",
+          "quantity": 2,
+          "price": 318
+        }
+      ],
+      "total_price": 547
+    }
+  ],
+  "2025-05-18": [
+    {
+      "email_number": 1,
+      "order_date": "18-May-2025",
+      "order_time": "12:57:21",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 315
+        }
+      ],
+      "total_price": 363
+    },
+    {
+      "email_number": 2,
+      "order_date": "18-May-2025",
+      "order_time": "13:02:51",
+      "restaurant_name": "Maiz Mexican Kitchen",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Chips With Guacamole",
+          "quantity": 1,
+          "price": 249
+        },
+        {
+          "name": "Fresh Tomato Salsa (50ml)",
+          "quantity": 1,
+          "price": 69
+        },
+        {
+          "name": "Chipotle Chicken Burrito",
+          "quantity": 1,
+          "price": 299
+        }
+      ],
+      "total_price": 491
+    }
+  ],
+  "2025-05-20": [
+    {
+      "email_number": 1,
+      "order_date": "20-May-2025",
+      "order_time": "11:24:05",
+      "restaurant_name": "IDC Kitchen",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Vada (1 Pc)",
+          "quantity": 1,
+          "price": 58
+        },
+        {
+          "name": "Masala Dosa",
+          "quantity": 1,
+          "price": 140
+        }
+      ],
+      "total_price": 167
+    },
+    {
+      "email_number": 2,
+      "order_date": "20-May-2025",
+      "order_time": "16:15:50",
+      "restaurant_name": "Irani Std. Tea",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Bun Omelette",
+          "quantity": 1,
+          "price": 139
+        },
+        {
+          "name": "Osmania Biscuits 100 Grams",
+          "quantity": 1,
+          "price": 100
+        },
+        {
+          "name": "Plain Maggie",
+          "quantity": 1,
+          "price": 119
+        },
+        {
+          "name": "Bun Maska",
+          "quantity": 1,
+          "price": 79
+        },
+        {
+          "name": "Irani Ginger Chai",
+          "quantity": 1,
+          "price": 219
+        },
+        {
+          "name": "Aloo Samosa",
+          "quantity": 1,
+          "price": 49
+        }
+      ],
+      "total_price": 627
+    },
+    {
+      "email_number": 3,
+      "order_date": "20-May-2025",
+      "order_time": "20:13:33",
+      "restaurant_name": "Gayatri Sandwich(Mithibai College)",
+      "delivery_address": "Shobhit, ground floor, Vile Parle East, Vile Parle, Mumbai, Maharashtra, India. (T1)",
+      "items": [
+        {
+          "name": "Sada Sandwich",
+          "quantity": 1,
+          "price": 50
+        },
+        {
+          "name": "Vada Pav",
+          "quantity": 1,
+          "price": 25
+        }
+      ],
+      "total_price": 178
+    }
+  ],
+  "2025-05-21": [
+    {
+      "email_number": 1,
+      "order_date": "21-May-2025",
+      "order_time": "12:56:56",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "Shobhit\n2C, Orchard Green Apartment\n2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Cold Brew Black (Cold Brew)",
+          "quantity": 1,
+          "price": 390
+        }
+      ],
+      "total_price": 401
+    },
+    {
+      "email_number": 2,
+      "order_date": "21-May-2025",
+      "order_time": "12:58:49",
+      "restaurant_name": "Starbucks Coffee",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Caffe Americano",
+          "quantity": 1,
+          "price": 315
+        }
+      ],
+      "total_price": 363
+    },
+    {
+      "email_number": 3,
+      "order_date": "21-May-2025",
+      "order_time": "22:07:56",
+      "restaurant_name": "Magnolia Bakery",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Chocolate Cake with Chocolate Buttercream Cake Slice",
+          "quantity": 1,
+          "price": 260
+        },
+        {
+          "name": "CLASSIC TRES LECHES",
+          "quantity": 1,
+          "price": 410
+        }
+      ],
+      "total_price": 850
+    }
+  ],
+  "2025-05-22": [
+    {
+      "email_number": 1,
+      "order_date": "22-May-2025",
+      "order_time": "12:00:34",
+      "restaurant_name": "Yogisthaan",
+      "delivery_address": "2C, Orchard Green Apartment, 2nd Main Rd, Domlur, Bangalore, Karnataka 560071, India. (Orchard Green)",
+      "items": [
+        {
+          "name": "Poha (quick Of Breakfast)",
+          "quantity": 1,
+          "price": 288
+        },
+        {
+          "name": "Tapioca (sabu Dana) Khichadi",
+          "quantity": 1,
+          "price": 252
+        }
+      ],
+      "total_price": 547
+    }
+  ],
+  "2025-05-23": []
+}

mcp/server/swiggy_scraper.py

@@ -0,0 +1,179 @@
+"""
+Reusable helper to fetch Swiggy order e-mails and return a list[dict].
+
+Usage:
+    from swiggy_scraper import fetch_swiggy_orders
+    orders = fetch_swiggy_orders("17-May-2025", "20-May-2025")
+"""
+
+import os, imaplib, json
+from email import message_from_bytes
+from bs4 import BeautifulSoup
+from openai import OpenAI
+from dotenv import load_dotenv
+from datetime import datetime, timedelta
+from email.utils import parsedate_to_datetime
+from zoneinfo import ZoneInfo
+
+from db_schema import init_db, get_orders_by_date_from_db, save_orders_to_db
+
+
+load_dotenv()
+
+APP_PASSWORD = os.getenv("APP_PASSWORD")
+EMAIL_ID     = os.getenv("EMAIL_ID")
+OPENAI_KEY   = os.getenv("OPENAI_API_KEY")
+
+client = OpenAI(api_key=OPENAI_KEY)
+
+def _imap_connect():
+    m = imaplib.IMAP4_SSL("imap.gmail.com")
+    m.login(EMAIL_ID, APP_PASSWORD)
+    m.select('"[Gmail]/All Mail"')
+    return m
+
+def _email_to_clean_text(msg):
+    html = next(
+        (part.get_payload(decode=True).decode(errors="ignore")
+         for part in msg.walk()
+         if part.get_content_type() == "text/html"),
+        None,
+    )
+    if not html:
+        return ""
+    soup = BeautifulSoup(html, "html.parser")
+    for t in soup(["script", "style", "head", "meta", "link"]):
+        t.decompose()
+    return "\n".join(
+        line.strip() for line in soup.get_text("\n").splitlines() if line.strip()
+    )
+
+def _get_all_dates(start_date: str, end_date: str):
+    start = datetime.strptime(start_date, "%d-%b-%Y")
+    end = datetime.strptime(end_date, "%d-%b-%Y")
+    delta = (end - start).days + 1
+    return [(start + timedelta(days=i)).strftime("%Y-%m-%d") for i in range(delta)]
+
+
+
+
+def _extract_with_llm(email_number, subject, body, email_date, email_time):
+    current_email = {
+        "subject": subject,
+        "body": body
+    }
+
+    prompt = f"""
+You are given a Swiggy order confirmation email with a subject and body.
+
+Extract and return only the following:
+- "restaurant_name": name of the restaurant
+- "delivery_address": the delivery address
+- "items": a list of ordered items, each with "name", "quantity", and "price" (number)
+- "total_price": the total bill paid including taxes, charges, etc.
+
+Example output format:
+{{
+  "restaurant_name": "Dominos Pizza",
+  "delivery_address": "123 Main St, City",
+  "total_price": 567,
+  "items": [
+    {{ "name": "Veg Pizza", "quantity": 2, "price": 199 }},
+    {{ "name": "Coke", "quantity": 1, "price": 45 }}
+  ]
+}}
+
+Return only valid JSON. No extra text or comments.
+
+{json.dumps(current_email, indent=2)}
+"""
+
+
+    try:
+        rsp = client.chat.completions.create(
+            model="gpt-4o-mini",
+            temperature=0,
+            messages=[
+                {"role": "system", "content": "You are a precise JSON extractor."},
+                {"role": "user", "content": prompt},
+            ],
+        )
+
+        # Attempt to parse the returned content
+        parsed_data = json.loads(rsp.choices[0].message.content)
+
+        # Wrap into final structure
+        final_output = {
+            "email_number": email_number,
+            "order_date": email_date,
+            "order_time": email_time,
+            "restaurant_name": parsed_data.get("restaurant_name", ""),
+            "delivery_address": parsed_data.get("delivery_address", ""),
+            "items": parsed_data.get("items", []),
+            "total_price": parsed_data.get("total_price", 0)
+        }
+
+        
+        return final_output
+
+    except json.JSONDecodeError as json_err:
+        return {
+            "email_number": email_number,
+            "error": f"JSON decoding failed: {str(json_err)}",
+            "raw_response": rsp.choices[0].message.content if 'rsp' in locals() else None
+        }
+
+    except Exception as e:
+        return {
+            "email_number": email_number,
+            "error": f"Unexpected error: {str(e)}"
+        }
+
+
+
+def fetch_swiggy_orders(start_date: str, end_date: str) -> list[dict]:
+    mail = _imap_connect()
+    all_dates = _get_all_dates(start_date, end_date)
+    orders = []
+
+    for date_str in all_dates:
+        # 1) Try loading from DB
+        day_orders = get_orders_by_date_from_db(date_str)
+        if day_orders:
+            print(f"{date_str} loaded from DB")
+            orders.extend(day_orders)
+            continue
+
+        # 2) Otherwise scrape emails for that date
+        print(f"Fetching Swiggy emails for {date_str}")
+        dt_obj = datetime.strptime(date_str, "%Y-%m-%d")
+        next_day = (dt_obj + timedelta(days=1)).strftime("%d-%b-%Y")
+        this_day = dt_obj.strftime("%d-%b-%Y")
+
+        crit = f'(FROM "noreply@swiggy.in") SINCE "{this_day}" BEFORE "{next_day}"'
+        _, data = mail.search(None, crit)
+        ids = data[0].split()
+
+        scraped_orders = []
+        for idx, eid in enumerate(ids, 1):
+            _, msg_data = mail.fetch(eid, "(RFC822)")
+            msg = message_from_bytes(msg_data[0][1])
+            subject = msg.get("Subject", "")
+            body_text = _email_to_clean_text(msg)
+
+            try:
+                dt_obj = parsedate_to_datetime(msg["Date"]).astimezone(ZoneInfo("Asia/Kolkata"))
+                email_date = dt_obj.strftime("%d-%b-%Y")
+                email_time = dt_obj.strftime("%H:%M:%S")
+
+                order = _extract_with_llm(idx, subject, body_text, email_date, email_time)
+                scraped_orders.append(order)
+            except Exception as exc:
+                scraped_orders.append({"email_number": idx, "error": str(exc)})
+
+        # 3) Save newly scraped data to DB
+        save_orders_to_db(date_str, scraped_orders)
+        orders.extend(scraped_orders)
+
+    mail.logout()
+    return orders

requirements.txt

@@ -1,24 +1 @@
-# Core OAuth Gmail MCP Server Dependencies
-gradio[mcp]
-google-auth
-google-auth-oauthlib
-google-auth-httplib2
-google-api-python-client
-cryptography
-requests
-loguru
-python-dateutil
-
-uvicorn
-
-# MCP server support
-mcp
-
-# Email processing
-email-validator
-beautifulsoup4
-html2text
-
-# Development (optional)
-pytest
-black 
+huggingface_hub==0.25.2