gradio

.gitignore

@@ -9,5 +9,4 @@ __pycache__/
 *.log
 
 agentic_implementation/*.json
-agentic_implementation/*.db
-logs/
+agentic_implementation/*.db

README.md

@@ -1,19 +1,17 @@
 ---
-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
 ---
 
+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).
 
-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
+uvicorn main:app --reload

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/agent.py

@@ -0,0 +1,141 @@
+# agent.py
+
+import json
+from typing import Dict, Any
+
+from re_act import (
+    get_plan_from_llm,
+    think,
+    act,
+    store_name_email_mapping,
+    extract_sender_info,
+    client
+)
+from schemas import PlanStep
+from logger import logger  # from logger.py
+
+
+def run_agent():
+    """
+    Main REPL loop for the email agent.
+    """
+    logger.info("Starting Email Agent REPL...")
+    print("🤖 Email Agent ready. Type 'exit' to quit.\n")
+
+    while True:
+        try:
+            user_query = input("🗨 You: ").strip()
+            logger.info("Received user input: %s", user_query)
+
+            if user_query.lower() in ("exit", "quit"):
+                logger.info("Exit command detected, shutting down agent.")
+                print("👋 Goodbye!")
+                break
+
+            # 1) Generate plan
+            try:
+                plan = get_plan_from_llm(user_query)
+                logger.debug("Generated plan: %s", plan)
+            except Exception as e:
+                logger.error("Failed to generate plan: %s", e)
+                print(f"❌ Could not generate a plan: {e}")
+                continue
+
+            # print plan for user transparency
+            print("\n\nplan:")
+            print(plan)
+            print("\n\n")
+
+            results: Dict[str, Any] = {}
+
+            # 2) Execute each plan step
+            for step in plan.plan:
+                logger.info("Processing step: %s", step.action)
+
+                if step.action == "done":
+                    logger.info("Encountered 'done' action. Plan complete.")
+                    print("✅ Plan complete.")
+                    break
+
+                try:
+                    should_run, updated_step, user_prompt = think(step, results, user_query)
+                    logger.debug(
+                        "Think outcome for '%s': should_run=%s, updated_step=%s, user_prompt=%s",
+                        step.action, should_run, updated_step, user_prompt
+                    )
+                except Exception as e:
+                    logger.error("Error in think() for step '%s': %s", step.action, e)
+                    print(f"❌ Error in planning step '{step.action}': {e}")
+                    break
+
+                # Handle user prompt (e.g., missing email mapping)
+                if user_prompt:
+                    logger.info("User prompt required: %s", user_prompt)
+                    print(f"❓ {user_prompt}")
+                    user_input = input("📧 Email: ").strip()
+
+                    try:
+                        sender_info = extract_sender_info(user_query)
+                        sender_intent = sender_info.get("sender_intent", "")
+                        store_name_email_mapping(sender_intent, user_input)
+                        logger.info("Stored mapping: %s -> %s", sender_intent, user_input)
+                        print(f"✅ Stored mapping: {sender_intent} → {user_input}")
+
+                        # Retry current step
+                        should_run, updated_step, _ = think(step, results, user_query)
+                        logger.debug(
+                            "Post-mapping think outcome: should_run=%s, updated_step=%s",
+                            should_run, updated_step
+                        )
+                    except Exception as e:
+                        logger.error("Error storing mapping or retrying step '%s': %s", step.action, e)
+                        print(f"❌ Error storing mapping or retrying step: {e}")
+                        break
+
+                if not should_run:
+                    logger.info("Skipping step: %s", step.action)
+                    print(f"⏭️  Skipping `{step.action}`")
+                    continue
+
+                # Execute the action
+                try:
+                    output = act(updated_step)
+                    results[updated_step.action] = output
+                    logger.info("Action '%s' executed successfully.", updated_step.action)
+                    print(f"🔧 Ran `{updated_step.action}`")
+                except Exception as e:
+                    logger.error("Error executing action '%s': %s", updated_step.action, e)
+                    print(f"❌ Error running `{updated_step.action}`: {e}")
+                    break
+
+            # 3) Summarize results via LLM
+            try:
+                summary_rsp = client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    temperature=0.0,
+                    messages=[
+                        {"role": "system", "content": "Summarize these results for the user in a friendly way."},
+                        {"role": "assistant", "content": json.dumps(results)}
+                    ],
+                )
+                summary = summary_rsp.choices[0].message.content
+                logger.info("Summary generated successfully.")
+                print("\n📋 Summary:\n" + summary)
+            except Exception as e:
+                logger.error("Failed to generate summary: %s", e)
+                print("\n❌ Failed to generate summary.")
+
+            print("\nAnything else I can help you with?\n")
+
+        except KeyboardInterrupt:
+            logger.info("KeyboardInterrupt received, shutting down.")
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            logger.exception("Unexpected error in REPL loop: %s", e)
+            print(f"❌ Unexpected error: {e}")
+            continue
+
+
+if __name__ == "__main__":
+    run_agent()

agentic_implementation/email_db.json

@@ -0,0 +1,14 @@
+{
+  "agarwal.27@iitj.ac.in": {
+    "emails": [
+      {
+        "date": "07-Jun-2025",
+        "time": "16:42:51",
+        "subject": "testing",
+        "content": "hi bro",
+        "message_id": "<CAPziNCaSuVqpqNNfsRjhVbx22jN_vos3EGK_Odt-8WiD0HRKKQ@mail.gmail.com>"
+      }
+    ],
+    "last_scraped": "08-Jun-2025"
+  }
+}

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/email_scraper.py

@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+"""
+Enhanced Email Scraper with Intelligent Caching
+"""
+
+import os
+import imaplib
+import json
+from email import message_from_bytes
+from bs4 import BeautifulSoup
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+from zoneinfo import ZoneInfo
+from email.utils import parsedate_to_datetime
+from typing import List, Dict
+
+load_dotenv()
+
+# Email credentials
+APP_PASSWORD = os.getenv("APP_PASSWORD")
+EMAIL_ID = os.getenv("EMAIL_ID")
+print("EMAIL_ID: ", EMAIL_ID)
+EMAIL_DB_FILE = "email_db.json"
+
+def validate_email_setup():
+    """Validate email setup and credentials"""
+    print("=== Email Setup Validation ===")
+    
+    # Check .env file existence
+    # env_file_exists = os.path.exists('.env')
+    # print(f".env file exists: {'✅ Yes' if env_file_exists else '❌ No'}")
+    
+    # if not env_file_exists:
+    #     print("❌ No .env file found! Create one with:")
+    #     print("   EMAIL_ID=your_email@gmail.com")
+    #     print("   APP_PASSWORD=your_16_char_app_password")
+    #     print("   OPENAI_API_KEY=your_openai_key")
+    #     return False
+        
+    # Check environment variables
+    issues = []
+    
+    # if not EMAIL_ID:
+    #     issues.append("EMAIL_ID not set or empty")
+    # elif '@' not in EMAIL_ID:
+    #     issues.append("EMAIL_ID doesn't look like an email address")
+    # elif not EMAIL_ID.endswith('@gmail.com'):
+    #     issues.append("EMAIL_ID should be a Gmail address (@gmail.com)")
+        
+    # if not APP_PASSWORD:
+    #     issues.append("APP_PASSWORD not set or empty")
+    # elif len(APP_PASSWORD) != 16:
+    #     issues.append(f"APP_PASSWORD should be 16 characters, got {len(APP_PASSWORD)}")
+    # elif ' ' in APP_PASSWORD:
+    #     issues.append("APP_PASSWORD should not contain spaces (remove spaces from app password)")
+        
+    if not os.getenv("OPENAI_API_KEY"):
+        issues.append("OPENAI_API_KEY not set (needed for query processing)")
+        
+    if issues:
+        print("❌ Issues found:")
+        for issue in issues:
+            print(f"   - {issue}")
+        return False
+    else:
+        print("✅ All credentials look good!")
+        return True
+
+def _imap_connect():
+    """Connect to Gmail IMAP server"""
+    print("=== IMAP Connection Debug ===")
+    
+    # Check if environment variables are loaded
+    print(f"EMAIL_ID loaded: {'✅ Yes' if EMAIL_ID else '❌ No (None/Empty)'}")
+    print(f"APP_PASSWORD loaded: {'✅ Yes' if APP_PASSWORD else '❌ No (None/Empty)'}")
+    
+    if EMAIL_ID:
+        print(f"Email ID: {EMAIL_ID[:5]}...@{EMAIL_ID.split('@')[1] if '@' in EMAIL_ID else 'INVALID'}")
+    # if APP_PASSWORD:
+    #     print(f"App Password length: {len(APP_PASSWORD)} characters")
+    #     print(f"App Password format: {'✅ Looks correct (16 chars)' if len(APP_PASSWORD) == 16 else f'❌ Expected 16 chars, got {len(APP_PASSWORD)}'}")
+    
+    if not EMAIL_ID or not APP_PASSWORD:
+        error_msg = "Missing credentials in environment variables!"
+        print(f"❌ {error_msg}")
+        raise Exception(error_msg)
+    
+    try:
+        print("🔄 Attempting IMAP SSL connection to imap.gmail.com:993...")
+        mail = imaplib.IMAP4_SSL("imap.gmail.com")
+        print("✅ SSL connection established")
+        
+        print("🔄 Attempting login...")
+        result = mail.login(EMAIL_ID, APP_PASSWORD)
+        print(f"✅ Login successful: {result}")
+        
+        print("🔄 Selecting mailbox: [Gmail]/All Mail...")
+        result = mail.select('"[Gmail]/All Mail"')
+        print(f"✅ Mailbox selected: {result}")
+        
+        print("=== IMAP Connection Successful ===")
+        return mail
+        
+    except imaplib.IMAP4.error as e:
+        print(f"❌ IMAP Error: {e}")
+        print("💡 Possible causes:")
+        print("   - App Password is incorrect or expired")
+        print("   - 2FA not enabled on Gmail account")
+        print("   - IMAP access not enabled in Gmail settings")
+        print("   - Gmail account locked or requires security verification")
+        raise
+    except Exception as e:
+        print(f"❌ Connection Error: {e}")
+        print("💡 Possible causes:")
+        print("   - Network connectivity issues")
+        print("   - Gmail IMAP server temporarily unavailable")
+        print("   - Firewall blocking IMAP port 993")
+        raise
+
+def _email_to_clean_text(msg):
+    """Extract clean text from email message"""
+    # Try HTML first
+    html_content = None
+    text_content = None
+    
+    if msg.is_multipart():
+        for part in msg.walk():
+            content_type = part.get_content_type()
+            if content_type == "text/html":
+                try:
+                    html_content = part.get_payload(decode=True).decode(errors="ignore")
+                except:
+                    continue
+            elif content_type == "text/plain":
+                try:
+                    text_content = part.get_payload(decode=True).decode(errors="ignore")
+                except:
+                    continue
+    else:
+        # Non-multipart message
+        content_type = msg.get_content_type()
+        try:
+            content = msg.get_payload(decode=True).decode(errors="ignore")
+            if content_type == "text/html":
+                html_content = content
+            else:
+                text_content = content
+        except:
+            pass
+    
+    # Clean HTML content
+    if html_content:
+        soup = BeautifulSoup(html_content, "html.parser")
+        # Remove script and style elements
+        for script in soup(["script", "style"]):
+            script.decompose()
+        return soup.get_text(separator=' ', strip=True)
+    elif text_content:
+        return text_content.strip()
+    else:
+        return ""
+
+def _load_email_db() -> Dict:
+    """Load email database from file"""
+    if not os.path.exists(EMAIL_DB_FILE):
+        return {}
+    try:
+        with open(EMAIL_DB_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        print(f"Warning: Could not load {EMAIL_DB_FILE}, starting with empty database")
+        return {}
+
+def _save_email_db(db: Dict):
+    """Save email database to file"""
+    try:
+        with open(EMAIL_DB_FILE, "w") as f:
+            json.dump(db, f, indent=2)
+    except IOError as e:
+        print(f"Error saving database: {e}")
+        raise
+
+def _date_to_imap_format(date_str: str) -> str:
+    """Convert DD-MMM-YYYY to IMAP date format"""
+    try:
+        dt = datetime.strptime(date_str, "%d-%b-%Y")
+        return dt.strftime("%d-%b-%Y")
+    except ValueError:
+        raise ValueError(f"Invalid date format: {date_str}. Expected DD-MMM-YYYY")
+
+def _is_date_in_range(email_date: str, start_date: str, end_date: str) -> bool:
+    """Check if email date is within the specified range"""
+    try:
+        email_dt = datetime.strptime(email_date, "%d-%b-%Y")
+        start_dt = datetime.strptime(start_date, "%d-%b-%Y")
+        end_dt = datetime.strptime(end_date, "%d-%b-%Y")
+        return start_dt <= email_dt <= end_dt
+    except ValueError:
+        return False
+
+def scrape_emails_from_sender(sender_email: str, start_date: str, end_date: str) -> List[Dict]:
+    """
+    Scrape emails from specific sender within date range
+    Uses intelligent caching to avoid re-scraping
+    """
+    print(f"Scraping emails from {sender_email} between {start_date} and {end_date}")
+    
+    # Load existing database
+    db = _load_email_db()
+    sender_email = sender_email.lower().strip()
+    
+    # Check if we have cached emails for this sender
+    if sender_email in db:
+        cached_emails = db[sender_email].get("emails", [])
+        
+        # Filter cached emails by date range
+        filtered_emails = [
+            email for email in cached_emails
+            if _is_date_in_range(email["date"], start_date, end_date)
+        ]
+        
+        # Check if we need to scrape more recent emails
+        last_scraped = db[sender_email].get("last_scraped", "01-Jan-2020")
+        today = datetime.today().strftime("%d-%b-%Y")
+        
+        if last_scraped == today and filtered_emails:
+            print(f"Using cached emails (last scraped: {last_scraped})")
+            return filtered_emails
+    
+    # Need to scrape emails
+    try:
+        mail = _imap_connect()
+        
+        # Prepare IMAP search criteria
+        start_imap = _date_to_imap_format(start_date)
+        # Add one day to end_date for BEFORE criteria (IMAP BEFORE is exclusive)
+        end_dt = datetime.strptime(end_date, "%d-%b-%Y") + timedelta(days=1)
+        end_imap = end_dt.strftime("%d-%b-%Y")
+        
+        search_criteria = f'(FROM "{sender_email}") SINCE "{start_imap}" BEFORE "{end_imap}"'
+        print(f"IMAP search: {search_criteria}")
+        
+        # Search for emails
+        status, data = mail.search(None, search_criteria)
+        if status != 'OK':
+            raise Exception(f"IMAP search failed: {status}")
+        
+        email_ids = data[0].split()
+        print(f"Found {len(email_ids)} emails")
+        
+        scraped_emails = []
+        
+        # Process each email
+        for i, email_id in enumerate(email_ids):
+            try:
+                print(f"Processing email {i+1}/{len(email_ids)}")
+                
+                # Fetch email
+                status, msg_data = mail.fetch(email_id, "(RFC822)")
+                if status != 'OK':
+                    continue
+                
+                # Parse email
+                msg = message_from_bytes(msg_data[0][1])
+                
+                # Extract information
+                subject = msg.get("Subject", "No Subject")
+                content = _email_to_clean_text(msg)
+                
+                # Parse date
+                date_header = msg.get("Date", "")
+                if date_header:
+                    try:
+                        dt_obj = parsedate_to_datetime(date_header)
+                        # Convert to IST
+                        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:
+                        email_date = datetime.today().strftime("%d-%b-%Y")
+                        email_time = "00:00:00"
+                else:
+                    email_date = datetime.today().strftime("%d-%b-%Y")
+                    email_time = "00:00:00"
+                
+                # Get message ID for deduplication
+                message_id = msg.get("Message-ID", f"missing-{email_id.decode()}")
+                
+                scraped_emails.append({
+                    "date": email_date,
+                    "time": email_time,
+                    "subject": subject,
+                    "content": content[:2000],  # Limit content length
+                    "message_id": message_id
+                })
+                
+            except Exception as e:
+                print(f"Error processing email {email_id}: {e}")
+                continue
+        
+        mail.logout()
+        
+        # Update database
+        if sender_email not in db:
+            db[sender_email] = {"emails": [], "last_scraped": ""}
+        
+        # Merge with existing emails (avoid duplicates)
+        existing_emails = db[sender_email].get("emails", [])
+        existing_ids = {email.get("message_id") for email in existing_emails}
+        
+        new_emails = [
+            email for email in scraped_emails 
+            if email["message_id"] not in existing_ids
+        ]
+        
+        # Update database
+        db[sender_email]["emails"] = existing_emails + new_emails
+        db[sender_email]["last_scraped"] = datetime.today().strftime("%d-%b-%Y")
+        
+        # Save database
+        _save_email_db(db)
+        
+        # Return filtered results
+        all_emails = db[sender_email]["emails"]
+        filtered_emails = [
+            email for email in all_emails
+            if _is_date_in_range(email["date"], start_date, end_date)
+        ]
+        
+        print(f"Scraped {len(new_emails)} new emails, returning {len(filtered_emails)} in date range")
+        return filtered_emails
+        
+    except Exception as e:
+        print(f"Email scraping failed: {e}")
+        raise
+
+def scrape_emails_by_text_search(keyword: str, start_date: str, end_date: str) -> List[Dict]:
+    """
+    Scrape emails containing a specific keyword (like company name) within date range.
+    Uses IMAP text search to find emails from senders containing the keyword.
+    """
+    print(f"Searching emails containing '{keyword}' between {start_date} and {end_date}") 
+    
+    # Validate setup first
+    if not validate_email_setup():
+        raise Exception("Email setup validation failed. Please check your .env file and credentials.")
+    
+    try:
+        mail = _imap_connect()
+        
+        # Prepare IMAP search criteria with text search
+        start_imap = _date_to_imap_format(start_date)
+        # Add one day to end_date for BEFORE criteria (IMAP BEFORE is exclusive)
+        end_dt = datetime.strptime(end_date, "%d-%b-%Y") + timedelta(days=1)
+        end_imap = end_dt.strftime("%d-%b-%Y")
+        
+        # Search for emails containing the keyword in FROM field or SUBJECT or BODY
+        # We'll search multiple criteria and combine results
+        search_criteria_list = [
+            f'FROM "{keyword}" SINCE "{start_imap}" BEFORE "{end_imap}"',
+            f'SUBJECT "{keyword}" SINCE "{start_imap}" BEFORE "{end_imap}"',
+            f'BODY "{keyword}" SINCE "{start_imap}" BEFORE "{end_imap}"'
+        ]
+        
+        all_email_ids = set()
+        
+        # Search with multiple criteria to catch emails containing the keyword
+        for search_criteria in search_criteria_list:
+            try:
+                print(f"IMAP search: {search_criteria}")
+                status, data = mail.search(None, search_criteria)
+                if status == 'OK' and data[0]:
+                    email_ids = data[0].split()
+                    all_email_ids.update(email_ids)
+                    print(f"Found {len(email_ids)} emails with this criteria")
+            except Exception as e:
+                print(f"Search criteria failed: {search_criteria}, error: {e}")
+                continue
+        
+        print(f"Total unique emails found: {len(all_email_ids)}")
+        scraped_emails = []
+        
+        # Process each email
+        for i, email_id in enumerate(all_email_ids):
+            try:
+                print(f"Processing email {i+1}/{len(all_email_ids)}")
+                
+                # Fetch email
+                status, msg_data = mail.fetch(email_id, "(RFC822)")
+                if status != 'OK':
+                    continue
+                
+                # Parse email
+                msg = message_from_bytes(msg_data[0][1])
+                
+                # Extract information
+                subject = msg.get("Subject", "No Subject")
+                from_header = msg.get("From", "Unknown Sender")
+                content = _email_to_clean_text(msg)
+                
+                # Check if the keyword is actually present (case-insensitive)
+                keyword_lower = keyword.lower()
+                if not any(keyword_lower in text.lower() for text in [subject, from_header, content]):
+                    continue
+                
+                # Parse date
+                date_header = msg.get("Date", "")
+                if date_header:
+                    try:
+                        dt_obj = parsedate_to_datetime(date_header)
+                        # Convert to IST
+                        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:
+                        email_date = datetime.today().strftime("%d-%b-%Y")
+                        email_time = "00:00:00"
+                else:
+                    email_date = datetime.today().strftime("%d-%b-%Y")
+                    email_time = "00:00:00"
+                
+                # Double-check date range
+                if not _is_date_in_range(email_date, start_date, end_date):
+                    continue
+                
+                # Get message ID for deduplication
+                message_id = msg.get("Message-ID", f"missing-{email_id.decode()}")
+                
+                scraped_emails.append({
+                    "date": email_date,
+                    "time": email_time,
+                    "subject": subject,
+                    "from": from_header,
+                    "content": content[:2000],  # Limit content length
+                    "message_id": message_id
+                })
+                
+            except Exception as e:
+                print(f"Error processing email {email_id}: {e}")
+                continue
+        
+        mail.logout()
+        
+        # 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)
+        
+        print(f"Successfully processed {len(scraped_emails)} emails containing '{keyword}'")
+        return scraped_emails
+        
+    except Exception as e:
+        print(f"Email text search failed: {e}")
+        raise
+
+# Test the scraper
+if __name__ == "__main__":
+    # Test scraping
+    try:
+        emails = scrape_emails_from_sender(
+            "noreply@example.com", 
+            "01-Jun-2025", 
+            "07-Jun-2025"
+        )
+        
+        print(f"\nFound {len(emails)} emails:")
+        for email in emails[:3]:  # Show first 3
+            print(f"- {email['date']} {email['time']}: {email['subject']}")
+            
+    except Exception as e:
+        print(f"Test failed: {e}")

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/name_mapping.json

@@ -0,0 +1,4 @@
+{
+  "dev agarwal": "agarwal.27@iitj.ac.in",
+  "axis bank": "alerts@axisbank.com"
+}

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/re_act.py

@@ -0,0 +1,229 @@
+# orchestrator.py
+
+import os
+import json
+import re
+from typing import Any, Dict, Tuple, Optional
+from datetime import datetime
+
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from schemas import Plan, PlanStep, FetchEmailsParams
+from tools import TOOL_MAPPING
+
+# Load .env and initialize OpenAI client
+load_dotenv()
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise RuntimeError("Missing OPENAI_API_KEY in environment")
+client = OpenAI(api_key=api_key)
+
+# File paths for name mapping
+NAME_MAPPING_FILE = "name_mapping.json"
+
+# === Hard-coded list of available actions ===
+SYSTEM_PLAN_PROMPT = """
+You are an email assistant agent. You have access to the following actions:
+
+  • fetch_emails - fetch emails using text search with sender keywords and date extraction (e.g., "swiggy emails last week")  
+  • show_email - display specific email content
+  • analyze_emails - analyze email patterns or content
+  • draft_reply - create a reply to an email
+  • send_reply - send a drafted reply
+  • done - complete the task
+
+When the user gives you a query, output _only_ valid JSON of this form:
+
+{
+  "plan": [
+    "fetch_emails",
+    ...,
+    "done"
+  ]
+}
+
+Rules:
+- Use "fetch_emails" for text-based email search (automatically extracts sender keywords and dates)
+- The final entry _must_ be "done"
+- If no tool is needed, return `{"plan":["done"]}`
+
+Example: For "show me emails from swiggy today" → ["fetch_emails", "done"]
+"""
+
+SYSTEM_VALIDATOR_TEMPLATE = """
+You are a plan validator.  
+Context (results so far):  
+{context}
+
+Next action:  
+{action}
+
+Reply _only_ with JSON:
+{{
+  "should_execute": <true|false>,
+  "parameters": <null or a JSON object with this action's parameters>
+}}
+"""
+
+
+def _load_name_mapping() -> Dict[str, str]:
+    """Load name to email mapping from JSON file"""
+    if not os.path.exists(NAME_MAPPING_FILE):
+        return {}
+    try:
+        with open(NAME_MAPPING_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def _save_name_mapping(mapping: Dict[str, str]):
+    """Save name to email mapping to JSON file"""
+    with open(NAME_MAPPING_FILE, "w") as f:
+        json.dump(mapping, f, indent=2)
+
+
+def store_name_email_mapping(name: str, email: str):
+    """Store new name to email mapping"""
+    name_mapping = _load_name_mapping()
+    name_mapping[name.lower().strip()] = email.lower().strip()
+    _save_name_mapping(name_mapping)
+
+
+def extract_sender_info(query: str) -> Dict:
+    """
+    Extract sender information from user query using LLM
+    """
+    system_prompt = """
+You are an email query parser that extracts sender information.
+
+Given a user query, extract the sender intent - the person/entity they want emails from.
+This could be:
+- A person's name (e.g., "dev", "john smith", "dev agarwal")
+- A company/service (e.g., "amazon", "google", "linkedin")
+- An email address (e.g., "john@company.com")
+
+Examples:
+- "emails from dev agarwal last week" → "dev agarwal"
+- "show amazon emails from last month" → "amazon"  
+- "emails from john@company.com yesterday" → "john@company.com"
+- "get messages from sarah" → "sarah"
+
+Return ONLY valid JSON:
+{
+  "sender_intent": "extracted name, company, or email"
+}
+"""
+    
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        temperature=0.0,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": query}
+        ],
+    )
+    
+    result = json.loads(response.choices[0].message.content)
+    return result
+
+
+def resolve_sender_email(sender_intent: str) -> Tuple[Optional[str], bool]:
+    """
+    Resolve sender intent to actual email address
+    Returns: (email_address, needs_user_input)
+    """
+    # Check if it's already an email address
+    if "@" in sender_intent:
+        return sender_intent.lower(), False
+    
+    # Load name mapping
+    name_mapping = _load_name_mapping()
+    
+    # Normalize the intent (lowercase for comparison)
+    normalized_intent = sender_intent.lower().strip()
+    
+    # Check direct match
+    if normalized_intent in name_mapping:
+        return name_mapping[normalized_intent], False
+    
+    # Check partial matches (fuzzy matching)
+    for name, email in name_mapping.items():
+        if normalized_intent in name.lower() or name.lower() in normalized_intent:
+            return email, False
+    
+    # No match found
+    return None, True
+
+
+def get_plan_from_llm(user_query: str) -> Plan:
+    """
+    Ask the LLM which actions to run, in order. No parameters here.
+    """
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        temperature=0.0,
+        messages=[
+            {"role": "system", "content": SYSTEM_PLAN_PROMPT},
+            {"role": "user",   "content": user_query},
+        ],
+    )
+
+    plan_json = json.loads(response.choices[0].message.content)
+    steps = [PlanStep(action=a) for a in plan_json["plan"]]
+    return Plan(plan=steps)
+
+
+def think(
+    step: PlanStep,
+    context: Dict[str, Any],
+    user_query: str
+) -> Tuple[bool, Optional[PlanStep], Optional[str]]:
+    """
+    Fill in parameters or skip based on the action:
+     - fetch_emails: pass the raw query for text-based search and date extraction
+     - others: ask the LLM validator for params
+    
+    Returns: (should_execute, updated_step, user_prompt_if_needed)
+    """
+    # 1) fetch_emails → pass the full query for text-based search and date extraction
+    if step.action == "fetch_emails":
+        params = FetchEmailsParams(
+            query=user_query  # Pass the full query for keyword and date extraction
+        )
+        return True, PlanStep(action="fetch_emails", parameters=params), None
+
+    # 2) everything else → validate & supply params via LLM
+    prompt = SYSTEM_VALIDATOR_TEMPLATE.format(
+        context=json.dumps(context, indent=2),
+        action=step.action,
+    )
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        temperature=0.0,
+        messages=[
+            {"role": "system",  "content": "Validate or supply parameters for this action."},
+            {"role": "user",    "content": prompt},
+        ],
+    )
+    verdict = json.loads(response.choices[0].message.content)
+    if not verdict.get("should_execute", False):
+        return False, None, None
+
+    return True, PlanStep(
+        action=step.action,
+        parameters=verdict.get("parameters")
+    ), None
+
+
+def act(step: PlanStep) -> Any:
+    """
+    Dispatch to the actual implementation in tools.py.
+    """
+    fn = TOOL_MAPPING.get(step.action)
+    if fn is None:
+        raise ValueError(f"Unknown action '{step.action}'")
+
+    kwargs = step.parameters.model_dump() if step.parameters else {}
+    return fn(**kwargs)

agentic_implementation/schemas.py

@@ -0,0 +1,47 @@
+# schemas.py
+
+from pydantic import BaseModel, EmailStr
+from typing import List, Literal, Optional, Union
+
+
+
+class FetchEmailsParams(BaseModel):
+    query: str  # Natural language query with sender and date info (e.g., "show me mails for last week from swiggy")
+
+
+class ShowEmailParams(BaseModel):
+    message_id: str
+
+class AnalyzeEmailsParams(BaseModel):
+    emails: List[dict]
+
+class DraftReplyParams(BaseModel):
+    email: dict
+    tone: Optional[Literal["formal", "informal"]] = "formal"
+
+class SendReplyParams(BaseModel):
+    message_id: str
+    reply_body: str
+
+
+ToolParams = Union[
+    FetchEmailsParams,
+    ShowEmailParams,
+    AnalyzeEmailsParams,
+    DraftReplyParams,
+    SendReplyParams
+]
+
+class PlanStep(BaseModel):
+    action: Literal[
+        "fetch_emails",
+        "show_email",
+        "analyze_emails",
+        "draft_reply",
+        "send_reply",
+        "done",
+    ]
+    parameters: Optional[ToolParams] = None
+    
+class Plan(BaseModel):
+    plan: List[PlanStep]

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() 

agentic_implementation/tools.py

@@ -0,0 +1,244 @@
+from schemas import (
+    FetchEmailsParams,
+    ShowEmailParams,
+    AnalyzeEmailsParams,
+    DraftReplyParams,
+    SendReplyParams,
+)
+from typing import Any, Dict
+from email_scraper import scrape_emails_from_sender, scrape_emails_by_text_search, _load_email_db, _save_email_db, _is_date_in_range
+from datetime import datetime, timedelta
+from typing import List
+from openai import OpenAI
+import json
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Initialize OpenAI client
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+client = OpenAI(api_key=OPENAI_API_KEY)
+
+
+def extract_query_info(query: str) -> Dict[str, str]:
+    """
+    Use an LLM to extract sender information and date range from a user query.
+    Returns {"sender_keyword": "company/sender name", "start_date":"DD-MMM-YYYY","end_date":"DD-MMM-YYYY"}.
+    """
+    today_str = datetime.today().strftime("%d-%b-%Y")
+    five_days_ago = (datetime.today() - timedelta(days=5)).strftime("%d-%b-%Y")
+    
+    system_prompt = f"""
+You are a query parser for email search. Today is {today_str}.
+
+Given a user query, extract the sender/company keyword and date range. Return _only_ valid JSON with:
+{{
+  "sender_keyword": "keyword or company name to search for",
+  "start_date": "DD-MMM-YYYY", 
+  "end_date": "DD-MMM-YYYY"
+}}
+
+Rules:
+1. Extract sender keywords from phrases like "from swiggy", "swiggy emails", "mails from amazon", etc.
+2. If no time is mentioned, use last 5 days: {five_days_ago} to {today_str}
+3. Interpret relative dates as:
+   - "today" → {today_str} to {today_str}
+   - "yesterday" → 1 day ago to 1 day ago  
+   - "last week" → 7 days ago to {today_str}
+   - "last month" → 30 days ago to {today_str}
+   - "last N days" → N days ago to {today_str}
+
+Examples:
+- "show me mails for last week from swiggy" 
+  → {{"sender_keyword": "swiggy", "start_date": "01-Jun-2025", "end_date": "{today_str}"}}
+- "emails from amazon yesterday"
+  → {{"sender_keyword": "amazon", "start_date": "06-Jun-2025", "end_date": "06-Jun-2025"}}  
+- "show flipkart emails"
+  → {{"sender_keyword": "flipkart", "start_date": "{five_days_ago}", "end_date": "{today_str}"}}
+
+Return _only_ the JSON object—no extra text.
+"""
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": query}
+    ]
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        temperature=0.0,
+        messages=messages
+    )
+    content = resp.choices[0].message.content.strip()
+
+    # Try direct parse; if the model added fluff, strip to the JSON block.
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError:
+        start = content.find("{")
+        end = content.rfind("}") + 1
+        return json.loads(content[start:end])
+
+
+def fetch_emails(query: str) -> Dict:
+    """
+    Fetch emails based on a natural language query that contains sender information and date range.
+    Now uses text-based search and returns only summary information, not full content.
+    
+    Args:
+        query: The natural language query (e.g., "show me mails for last week from swiggy")
+    
+    Returns:
+        Dict with query_info, email_summary, analysis, and email_count
+    """
+    # Extract sender keyword and date range from query
+    query_info = extract_query_info(query)
+    sender_keyword = query_info.get("sender_keyword", "")
+    start_date = query_info.get("start_date")
+    end_date = query_info.get("end_date")
+    
+    print(f"Searching for emails with keyword '{sender_keyword}' between {start_date} and {end_date}")
+    
+    # Use the new text-based search function
+    full_emails = scrape_emails_by_text_search(sender_keyword, start_date, end_date)
+    
+    if not full_emails:
+        return {
+            "query_info": query_info,
+            "email_summary": [],
+            "analysis": {"summary": f"No emails found for '{sender_keyword}' in the specified date range.", "insights": []},
+            "email_count": 0
+        }
+    
+    # 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")
+            # Note: Removed 'content' to keep response clean
+        }
+        email_summary.append(summary_email)
+    
+    # Auto-analyze the emails for insights
+    analysis = analyze_emails(full_emails)  # Use full emails for analysis but don't return them
+    
+    # Return summary info with analysis
+    return {
+        "query_info": query_info,
+        "email_summary": email_summary,
+        "analysis": analysis,
+        "email_count": len(full_emails)
+    }
+
+
+def show_email(message_id: str) -> Dict:
+    """
+    Retrieve the full email record (date, time, subject, content, etc.)
+    from the local cache by message_id.
+    """
+    db = _load_email_db()  # returns { sender_email: { "emails": [...], "last_scraped": ... }, ... }
+
+    # Search each sender's email list
+    for sender_data in db.values():
+        for email in sender_data.get("emails", []):
+            if email.get("message_id") == message_id:
+                return email
+
+    # If we didn't find it, raise or return an error structure
+    raise ValueError(f"No email found with message_id '{message_id}'")
+
+
+def draft_reply(email: Dict, tone: str) -> str:
+    # call LLM to generate reply
+    # return a dummy reply for now
+    print(f"Drafting reply for email {email['id']} with tone: {tone}")
+    return f"Drafted reply for email {email['id']} with tone {tone}."
+    ...
+
+
+def send_reply(message_id: str, reply_body: str) -> Dict:
+    # SMTP / Gmail API send
+    print(f"Sending reply to message {message_id} with body: {reply_body}")
+    ...
+
+
+def analyze_emails(emails: List[Dict]) -> Dict:
+    """
+    Summarize and extract insights from a list of emails.
+    Returns a dict with this schema:
+      {
+        "summary": str,        # a concise overview of all emails
+        "insights": [str, ...] # list of key observations or stats
+      }
+    """
+    if not emails:
+        return {"summary": "No emails to analyze.", "insights": []}
+    
+    # 1) Create a simplified email summary for analysis (without full content)
+    simplified_emails = []
+    for email in emails:
+        simplified_email = {
+            "date": email.get("date"),
+            "time": email.get("time"), 
+            "subject": email.get("subject"),
+            "from": email.get("from", "Unknown Sender"),
+            "content_preview": email.get("content", "")[:200] + "..." if email.get("content") else ""
+        }
+        simplified_emails.append(simplified_email)
+    
+    emails_payload = json.dumps(simplified_emails, ensure_ascii=False)
+
+    # 2) Build the LLM prompt
+    system_prompt = """
+You are an expert email analyst. You will be given a JSON array of email objects,
+each with keys: date, time, subject, from, content_preview.
+
+Your job is to produce _only_ valid JSON with two fields:
+1. summary: a 1–2 sentence high-level overview of these emails.
+2. insights: a list of 3–5 bullet-style observations or statistics 
+   (e.g. "5 emails from Swiggy", "mostly promotional content", "received over 3 days").
+
+Focus on metadata like senders, subjects, dates, and patterns rather than detailed content analysis.
+
+Output exactly:
+
+{
+  "summary": "...",
+  "insights": ["...", "...", ...]
+}
+"""
+    messages = [
+        {"role": "system",  "content": system_prompt},
+        {"role": "user",    "content": f"Here are the emails:\n{emails_payload}"}
+    ]
+
+    # 3) Call the LLM
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        temperature=0.0,
+        messages=messages
+    )
+
+    # 4) Parse and return
+    content = response.choices[0].message.content.strip()
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError:
+        # In case the model outputs extra text, extract the JSON block
+        start = content.find('{')
+        end = content.rfind('}') + 1
+        return json.loads(content[start:end])
+
+
+TOOL_MAPPING = {
+    "fetch_emails": fetch_emails,
+    "show_email": show_email,
+    "analyze_emails": analyze_emails,
+    "draft_reply": draft_reply,
+    "send_reply": send_reply,
+}

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()

client/main.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+
+import requests
+import sys
+from typing import Dict, Any
+
+API_BASE = "http://127.0.0.1:8000/api/v1"
+
+class EmailQueryCLI:
+    def __init__(self):
+        self.session = requests.Session()
+        
+    def check_connection(self) -> bool:
+        """Check if API server is running"""
+        try:
+            response = self.session.get(f"{API_BASE}/health")
+            response.raise_for_status()
+            return True
+        except:
+            return False
+    
+    def pretty_print_email(self, email: Dict) -> str:
+        """Format email for display"""
+        return f"""
+📧 {email['subject']}
+   📅 {email['date']} {email['time']}
+   💬 {email['content'][:200]}...
+   🆔 {email['message_id'][:20]}...
+{"─" * 60}"""
+
+    def handle_query(self, query: str):
+        """Handle a natural language query"""
+        print(f"\n🔍 Processing: '{query}'")
+        
+        try:
+            # Try to get emails directly
+            response = self.session.post(
+                f"{API_BASE}/get_emails",
+                json={"query": query}
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                self.display_email_results(data)
+                return True
+                
+            elif response.status_code == 400:
+                error_detail = response.json()["detail"]
+                
+                # Check if we need email mapping
+                if isinstance(error_detail, dict) and error_detail.get("type") == "need_email_input":
+                    mapping_success = self.handle_missing_mapping(error_detail)
+                    if mapping_success and hasattr(self, '_retry_query'):
+                        # Retry the query after successful mapping
+                        print(f"🔄 Retrying query...")
+                        delattr(self, '_retry_query')
+                        return self.handle_query(query)  # Recursive retry
+                    return mapping_success
+                else:
+                    print(f"❌ Error: {error_detail}")
+                    return False
+            else:
+                print(f"❌ API Error: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Connection Error: {e}")
+            return False
+    
+    def handle_missing_mapping(self, error_detail: Dict) -> bool:
+        """Handle case where email mapping is needed"""
+        sender_intent = error_detail["sender_intent"]
+        print(f"\n❓ {error_detail['message']}")
+        
+        try:
+            email = input(f"📧 Enter email for '{sender_intent}': ").strip()
+            if not email or "@" not in email:
+                print("❌ Invalid email address")
+                return False
+            
+            # Add the mapping
+            mapping_response = self.session.post(
+                f"{API_BASE}/add_email_mapping",
+                json={"name": sender_intent, "email": email}
+            )
+            
+            if mapping_response.status_code == 200:
+                print(f"✅ Mapping saved: '{sender_intent}' → '{email}'")
+                self._retry_query = True  # Flag to retry the original query
+                return True
+            else:
+                print(f"❌ Failed to save mapping: {mapping_response.text}")
+                return False
+                
+        except KeyboardInterrupt:
+            print("\n❌ Cancelled")
+            return False
+    
+    def display_email_results(self, data: Dict):
+        """Display email search results"""
+        print(f"\n✅ Found {data['total_emails']} emails")
+        print(f"📤 From: {data['resolved_email']}")
+        print(f"📅 Period: {data['start_date']} to {data['end_date']}")
+        
+        if data['emails']:
+            print(f"\n📧 Emails:")
+            for email in data['emails'][:10]:  # Show first 10
+                print(self.pretty_print_email(email))
+                
+            if len(data['emails']) > 10:
+                print(f"\n... and {len(data['emails']) - 10} more emails")
+        else:
+            print("\n📭 No emails found in this date range")
+    
+    def show_mappings(self):
+        """Display all stored name-to-email mappings"""
+        try:
+            response = self.session.get(f"{API_BASE}/view_mappings")
+            if response.status_code == 200:
+                data = response.json()
+                mappings = data["mappings"]
+                
+                print(f"\n📇 Stored Mappings ({len(mappings)}):")
+                if mappings:
+                    for name, email in mappings.items():
+                        print(f"  👤 {name} → 📧 {email}")
+                else:
+                    print("  (No mappings stored)")
+            else:
+                print(f"❌ Failed to load mappings: {response.text}")
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    
+    def run(self):
+        """Main CLI loop"""
+        if not self.check_connection():
+            print("❌ Cannot connect to API server at http://127.0.0.1:8000")
+            print("   Make sure to run: uvicorn main:app --reload")
+            sys.exit(1)
+        
+        print("✅ Connected to Email Query System")
+        print("💡 Try queries like:")
+        print("   • 'emails from john last week'")
+        print("   • 'show amazon emails from last month'")
+        print("   • 'get dev@iitj.ac.in emails yesterday'")
+        print("\n📋 Commands:")
+        print("   • 'mappings' - View stored name-to-email mappings")
+        print("   • 'quit' or Ctrl+C - Exit")
+        print("=" * 60)
+        
+        while True:
+            try:
+                query = input("\n🗨️  You: ").strip()
+                
+                if not query:
+                    continue
+                    
+                if query.lower() in ['quit', 'exit', 'q']:
+                    break
+                elif query.lower() in ['mappings', 'map', 'm']:
+                    self.show_mappings()
+                elif query.lower() in ['help', 'h']:
+                    print("\n💡 Examples:")
+                    print("   • emails from amazon last 5 days")
+                    print("   • show john smith emails this week") 
+                    print("   • get notifications from google yesterday")
+                else:
+                    self.handle_query(query)
+                        
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                print(f"❌ Unexpected error: {e}")
+        
+        print("\n👋 Goodbye!")
+
+def main():
+    """Entry point for CLI"""
+    cli = EmailQueryCLI()
+    cli.run()
+
+if __name__ == "__main__":
+    main()

requirements.txt

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

server/email_db.json

@@ -0,0 +1,135 @@
+{
+  "director@iitj.ac.in": {
+    "emails": [
+      {
+        "date": "01-Jan-2025",
+        "time": "11:00:26",
+        "subject": "2025: A Year to Unite, Innovate, and Lead with Integrity: Let's make\r\n IIT Jodhpur a beacon of excellence and sustainability!",
+        "content": "Dear Members of the IIT Jodhpur Fraternity, Students, Staff Members, and Faculty Colleagues, As we stand on the brink of a new year, I take this opportunity to reflect on\u00a0the remarkable journey of IIT Jodhpur so far and the collective efforts that\u00a0have brought us to where we are today over the last\u00a016\u00a0years or so. Each one of you - our faculty,\u00a0students, staff, alumni, and partners, has played a vital role in shaping\u00a0this institute and its evolution as a hub of learning, innovation, and excellence. It is\u00a0your commitment, resilience, and unwavering dedication that inspires all of us to aim higher and envision a future of much greater achievements,\u00a0breaking the\u00a0moulds of conventional thinking and defining excellence at a new\u00a0level. The year 2025 holds immense promise. It is a year when our shared vision of growth, innovation, and sustainability will take centre stage. Our institution stands at the confluence of tradition and modernity, of\u00a0ambition and responsibility. Let this be the year where we align our\u00a0efforts to not only push the boundaries of research and education but\u00a0also embrace a balanced approach toward sustainability in every aspect. Together, we can make IIT Jodhpur a beacon of innovation,\u00a0collaboration, and societal impact.\u00a0Our strength lies in our unity. As a diverse and dynamic community, we\u00a0can bring together varied perspectives, talents, and\u00a0disciplines to create something extraordinary. It is through this synergy that we will achieve the breakthroughs needed to address global\u00a0challenges and contribute meaningfully to the world. Let us continue to\u00a0foster an environment of mutual respect, inclusivity, and shared\u00a0purpose, ensuring that every member of our community feels\u00a0empowered to contribute their best. The journey ahead requires us to focus on strengthening collaborations\u00a0that amplify our impact. By working closely with industry, academia, and\u00a0governmental organizations, we can create pathways to meaningful\u00a0innovation and transformative research. O",
+        "message_id": "<CADCv5Wjqd09OCsR0fT2YXv5zzyJT=+xsuvsu4rhLTKbDBznYNw@mail.gmail.com>"
+      },
+      {
+        "date": "14-Jan-2025",
+        "time": "09:52:47",
+        "subject": "Makar Sankranti, Lohri, Bihu, Pongal: Festivals of Progress and New Aspirations",
+        "content": "Dear Members of the IIT Jodhpur Fraternity, \u0906\u092a\u0915\u094b \u0932\u094b\u0939\u093f\u095c\u0940, \u092c\u093f\u0939\u0942, \u092a\u094b\u0902\u0917\u0932 \u0914\u0930 \u092e\u0915\u0930 \u0938\u0902\u0915\u094d\u0930\u093e\u0902\u0924\u093f \u0915\u0940 \u0939\u093e\u0930\u094d\u0926\u093f\u0915 \u0936\u0941\u092d\u0915\u093e\u092e\u0928\u093e\u090f\u0901! \u092d\u093e\u0938\u094d\u0915\u0930\u0938\u094d\u092f \u092f\u0925\u093e \u0924\u0947\u091c\u094b \u092e\u0915\u0930\u0938\u094d\u0925\u0938\u094d\u092f \u0935\u0930\u094d\u0927\u0924\u0947\u0964 \u0924\u0925\u0948\u0935 \u092d\u0935\u0924\u093e\u0902 \u0924\u0947\u091c\u094b \u0935\u0930\u094d\u0927\u0924\u093e\u092e\u093f\u0924\u093f \u0915\u093e\u092e\u092f\u0947\u0964\u0964 \u092d\u0917\u0935\u093e\u0928 \u0938\u0942\u0930\u094d\u092f \u0915\u0947 \u092e\u0915\u0930 \u0930\u093e\u0936\u093f \u092e\u0947\u0902 \u092a\u094d\u0930\u0935\u0947\u0936 \u0924\u0925\u093e \u0909\u0924\u094d\u0924\u0930\u093e\u092f\u0923 \u0939\u094b\u0928\u0947 \u092a\u0930 \u0938\u0902\u092a\u0942\u0930\u094d\u0923 \u092d\u093e\u0930\u0924\u0935\u0930\u094d\u0937 \u092e\u0947\u0902 \u090a\u0930\u094d\u091c\u093e \u0935 \u0909\u0937\u094d\u092e\u093e \u092e\u0947\u0902 \u0935\u0943\u0926\u094d\u0927\u093f \u0915\u0947 \u092a\u094d\u0930\u0924\u0940\u0915-\u092a\u0930\u094d\u0935 \u00a0\"\u092e\u0915\u0930 \u0938\u0902\u0915\u094d\u0930\u093e\u0902\u0924\u093f\" \u092a\u0930 \u0906\u092a\u0915\u093e \u090f\u0935\u0902 \u0906\u092a\u0915\u0947 \u092a\u0930\u093f\u0935\u093e\u0930 \u092e\u0947\u0902 \u0938\u092d\u0940 \u0915\u093e \u091c\u0940\u0935\u0928 \u0905\u0924\u094d\u092f\u0902\u0924 \u092a\u094d\u0930\u0915\u093e\u0936\u092e\u093e\u0928 \u0939\u094b! \u0906\u092a \u0938\u092d\u0940 \u0938\u094d\u0935\u0938\u094d\u0925 \u0930\u0939\u0947\u0902, \u092a\u094d\u0930\u0938\u0928\u094d\u0928 \u0930\u0939\u0947\u0902 \u0914\u0930 \u0938\u0942\u0930\u094d\u092f \u0915\u0940 \u092d\u093e\u0901\u0924\u093f \u0905\u092a\u0928\u0947 \u092a\u094d\u0930\u0915\u093e\u0936 \u0938\u0947 \u0935\u093f\u0936\u094d\u0935 \u0915\u094b \u0906\u0932\u094b\u0915\u093f\u0924 \u0915\u0930\u0947\u0902! \u0906\u0907\u090f, \u0905\u092a\u0928\u0940 \u0906\u0932\u094b\u0915\u0927\u0930\u094d\u092e\u0940 \u0938\u0902\u0938\u094d\u0915\u0943\u0924\u093f \u0915\u0940 \u0935\u093f\u0930\u093e\u0938\u0924 \u0915\u0947 \u0935\u093e\u0939\u0915 \u092c\u0928\u0947\u0902\u0964 \u0909\u0938\u0915\u0947 \u092e\u0939\u0924\u094d\u0924\u094d\u0935 \u090f\u0935\u0902 \u0935\u0948\u091c\u094d\u091e\u093e\u0928\u093f\u0915\u0924\u093e \u0915\u094b \u092a\u0939\u0932\u0947 \u0938\u094d\u0935\u092f\u0902 \u0938\u092e\u091d\u0947\u0902, \u092b\u093f\u0930 \u0905\u092a\u0928\u0940 \u0938\u0902\u0924\u0924\u093f\u092f\u094b\u0902 \u0915\u094b \u092d\u0940 \u0938\u092e\u091d\u093e\u090f\u0901\u0964 \u0939\u092e\u093e\u0930\u0947 \u0924\u094d\u092f\u094b\u0939\u093e\u0930, \u0939\u092e\u093e\u0930\u0940 \u092d\u093e\u0937\u093e, \u0939\u092e\u093e\u0930\u0940 \u092a\u0930\u0902\u092a\u0930\u093e, \u0939\u092e\u093e\u0930\u0940 \u0938\u0902\u0938\u094d\u0915\u0943\u0924\u093f - \u0939\u0940\u0928\u0924\u093e \u0928\u0939\u0940\u0902, \u0917\u0930\u094d\u0935 \u0915\u0940 \u0935\u093f\u0937\u092f\u0935\u0938\u094d\u0924\u0941 \u0939\u0948\u0902\u0964 As we celebrate the auspicious occasion of Makar Sankranti, when the sun begins its northward journey (Uttarayan), let us draw inspiration from this symbol of progress, renewal, and growth. This festival reminds us to embrace change, rise above challenges, and strive for new aspirations. Much like the sun\u2019s steady path, our commitment to advancing knowledge, innovation, and societal impact continues to illuminate the way forward. At IIT Jodhpur, we are driven to explore transformative solutions, foster excellence, and shape a sustainable and inclusive future for ourselves, and the nation. Let us make use of this occasion to reflect on our achievements and renew our dedication to the goals that lie ahead. Together, as a community, we can reach greater heights and leave an enduring legacy for generations to come. May this festive season bring joy, prosperity, and inspiration to you and your families. Let us soar higher, united in our purpose and vision. -- Affectionately Yours..... With warm regards..... Prof. Avinash Kumar Agarwal, FTWAS, FAAAS, FCI, FSAE, FASME, FRSC, FNAE, FNASc, FISEES Director, IIT Jodhpur & Sir J C Bose National Fellow Tel: +91 291 2801011 (Off) Wikipedia: tinyurl.com/bdhe89ew | Scopus: https://tinyurl.com/mwccdcc4 | Google Scholar: https://tinyurl.com/mtbyv7w4 | FUE",
+        "message_id": "<CADCv5WgfRV2jFQf2=gfVHw1xfyE87tdqHSVtGQq3S4dhNmwEdA@mail.gmail.com>"
+      },
+      {
+        "date": "25-Jan-2025",
+        "time": "19:48:33",
+        "subject": "Happy Republic Day-2025",
+        "content": "My Dear Students, Faculty and Staff members, \ud83c\uddee\ud83c\uddf3 Greetings on the occasion of the 76th Republic Day! \ud83c\uddee\ud83c\uddf3 As we approach the 26th of January, we unite to celebrate not only the adoption of our Constitution but also the enduring principles of democracy, justice, and equality that define us as individuals and as an institution. This momentous day inspires us to reaffirm our collective commitment to shaping the future of our nation. At IIT Jodhpur, we hold a pivotal role in this journey of progress and innovation. As proud members of this esteemed institution, we bear the responsibility of fostering a culture rooted in innovation, academic excellence, and ethical leadership. Republic Day serves as a powerful reminder of our individual and collective contributions to IIT Jodhpur and the nation\u2014 not only through our collective professional accomplishments but also through the values we instil in our students and the spirit of collaboration and excellence we cultivate among ourselves. On this Republic Day, let us focus on: \u2705 Strengthening research and teaching excellence in our Institute, \u2705 Enhancing our infrastructure, and \u2705 Building a more inclusive and supportive environment for all members of our community. It is through these efforts that we will continue to push the frontiers of knowledge, innovation and excellence, contributing meaningfully to our nation and beyond. I encourage everyone to actively participate in the Republic Day celebrations tomorrow morning and reflect on how we can collectively elevate IIT Jodhpur\u2019s legacy. Together, let us uphold the values of integrity, diversity, and excellence\u2014the core pillars of our nation and our Institute. Wishing you and yours a thoughtful, inspiring, and joyous Republic Day 2025. Jai Hind. Jai Bharat. With warm regards and affection, Prof. Avinash Kumar Agarwal, FTWAS, FAAAS, FCI, FSAE, FASME, FRSC, FNAE, FNASc, FISEES Director, IIT Jodhpur & Sir J C Bose National Fellow Tel: +91 291 2801011 (Off) Wikipedia: tinyurl.com/bd",
+        "message_id": "<CADCv5WiULZvioxbVYrmR7mdmZHtB4jQ2P2cG_+S-Sdas1hNyew@mail.gmail.com>"
+      },
+      {
+        "date": "13-Feb-2025",
+        "time": "11:37:07",
+        "subject": "=?UTF-8?Q?Re=3A_=5Bfaculty=5D_Invitation_to_Hamira_Manganiyar_Group=27?=\r\n\t=?UTF-8?Q?s_Rajasthani_Folk_Music_Performance_Today_=E2=80=93_VIRASAT_2025?=",
+        "content": "Dear All, The Institute is organising Virasat 2025, and renowned artists will descend on our campus over the next five days. We must take this opportunity to learn about our cultural heritage and musical\u00a0performances during this period. I will strongly encourage all constituents of our campus community, including students, faculty and staff members and their families, and project staff members, to attend all these programs in the evening over the next five days and enjoy the cultural performances. Best wishes Avinash Kumar Agarwal On Thu, Feb 13, 2025 at 11:26\u202fAM Sherin Sabu < sherinsabu@iitj.ac.in > wrote: Dear all, We are delighted to invite you to an enchanting evening of Rajasthani folk music as part of VIRASAT 2025 , organized by IIT Jodhpur in collaboration with SPIC MACAY. \ud83c\udfb6 Performance Details: \ud83d\udccd Venue: Jodhpur Club, IIT Jodhpur \ud83c\udfa4 Artist: Hamira Manganiyar Group (Rajasthani Folk Music) \ud83d\udcc5 Date: Today: 13th February 2025 \u23f0 Time: 7:30 PM Immerse yourself in the vibrant and soulful rhythms of Rajasthan as the Hamira Manganiyar Group brings to life the rich musical traditions of the desert. This performance is a rare opportunity to experience the deep-rooted heritage of folk music passed down through generations. We warmly invite you to join us for this unforgettable musical evening.\u00a0\r\n\r\nPlease bring your family along to share in this cultural celebration! \ud83d\udccc Find attached the official event poster for more details. Looking forward to your presence! Warm Regards, Team Virasat 2025 IIT Jodhpur -- Dr Sherin Sabu Assistant Professor (Sociology), School of Liberal Arts (SoLA) Affiliate Faculty, Center for Emerging Technologies for Sustainable Development (CETSD) IIT Jodhpur",
+        "message_id": "<CADCv5WiZNk6BBrYPXhaaN0K_9N-L27ufUfg5JyWTrrJdbnwM=w@mail.gmail.com>"
+      },
+      {
+        "date": "26-Feb-2025",
+        "time": "19:54:24",
+        "subject": "Greetings on Mahashivratri!",
+        "content": "Dear all, Wishing you all a blessed and joyous Mahashivratri! I extend my warmest greetings to all of you and your family members. Mahashivratri is a time of deep spiritual reflection, inner growth, and devotion. This sacred festival symbolizes the triumph of wisdom, devotion, and inner strength, inspiring us to pursue knowledge and morality in all our endeavors. As we celebrate this day with devotion and reflection, let us also reaffirm our commitment to excellence, innovation, and the collective growth of IIT Jodhpur. Together, through dedication and hard work, we should continue to make meaningful contributions to knowledge, technology, and society. With warm regards, Prof. Avinash Kumar Agarwal ..",
+        "message_id": "<CADCv5WhSG91tOjiv_+XUUrxvqeOQv4xMocQNsgAC_EuUTQ87jw@mail.gmail.com>"
+      },
+      {
+        "date": "28-Feb-2025",
+        "time": "12:05:48",
+        "subject": "Re: [faculty] Invitation to celebrate \"National Science Day\" on 28th\r\n February 2025 at IIT Jodhpur",
+        "content": "Dear All, Hearty Congratulations to all of you on the occasion of National Science Day 2025. I urge all of you to attend this celebration of National Science Day. Sh Sharad Sarraf, BoG Chairman of IIT Mumbai and Jammu, is the Speaker and the chief guest. He is a strong well-wisher of IIT Jodhpur and we will enrich ourselves by listening to his words, full of wisdom. Best regards Avinash Kumar Agarwal On Wed, Feb 26, 2025 at 6:02\u202fPM Committee for Celebration of Commemorative Days < cccd@iitj.ac.in > wrote: Dear All, \u092e\u0939\u093e\u0936\u093f\u0935\u0930\u093e\u0924\u094d\u0930\u093f\u00a0 \u0915\u0940 \u0939\u093e\u0930\u094d\u0926\u093f\u0915 \u0936\u0941\u092d\u0915\u093e\u092e\u0928\u093e\u090f\u0902 / Happy MahaShivratri....! \u0938\u094d\u092e\u093e\u0930\u0915 \u0926\u093f\u0935\u0938 \u0938\u092e\u093e\u0930\u094b\u0939 \u0938\u092e\u093f\u0924\u093f (\u0938\u0940\u0938\u0940\u0938\u0940\u0921\u0940) \u0915\u0940 \u0913\u0930 \u0938\u0947, \u092d\u093e\u0930\u0924\u0940\u092f \u092a\u094d\u0930\u094c\u0926\u094d\u092f\u094b\u0917\u093f\u0915\u0940 \u0938\u0902\u0938\u094d\u0925\u093e\u0928 \u091c\u094b\u0927\u092a\u0941\u0930 \u092e\u0947\u0902 28 \u092b\u0930\u0935\u0930\u0940, 2025 (\u0936\u0941\u0915\u094d\u0930\u0935\u093e\u0930) \u0915\u094b \u0930\u093e\u0937\u094d\u091f\u094d\u0930\u0940\u092f \u0935\u093f\u091c\u094d\u091e\u093e\u0928 \u0926\u093f\u0935\u0938\u00a0 2025 \u0915\u0947 \u0905\u0935\u0938\u0930 \u092a\u0930 \u0939\u092e \u0906\u092a\u0915\u094b \u00a0\u0939\u093e\u0930\u094d\u0926\u093f\u0915 \u0928\u093f\u092e\u0902\u0924\u094d\u0930\u0923 \u0926\u0947\u0924\u0947\u00a0 \u0939\u0948\u0902 \u0964 \u0939\u092e\u00a0\u00a0\u0907\u0938 \u092e\u0939\u0924\u094d\u0935\u092a\u0942\u0930\u094d\u0923 \u0915\u093e\u0930\u094d\u092f\u0915\u094d\u0930\u092e \u092e\u0947\u0902 \u0906\u092a\u0915\u0947 \u0936\u093e\u092e\u093f\u0932 \u0939\u094b\u0928\u0947 \u0915\u0947 \u0938\u092e\u094d\u092e\u093e\u0928 \u0915\u0940 \u0909\u0924\u094d\u0938\u0941\u0915\u0924\u093e \u0938\u0947 \u092a\u094d\u0930\u0924\u0940\u0915\u094d\u0937\u093e \u0915\u0930\u0947\u0902\u0917\u0947\u0964 On behalf of the Committee for Celebration of Commemorative Days (CCCD) at IIT Jodhpur, we cordially invite you to join us in commemorating the National Science Day 2025 on February 28, 2025 (Friday) . We eagerly anticipate the honour of having you at this momentous event. Program: National Science Day 2025 Date: 28th February 2025 (Friday) Venue: Jodhpur Club Time: 5:45 PM onwards Program details: Time Event 05:45 \u2013 06:05 PM Scientific Demonstration & Tea -Refreshments 06:05 \u2013 06:10 PM Lamp Lighting & felicitation 06:10 \u2013 06:20 PM Welcome address by the Director 06:20 \u2013 06:45 PM Talk and interaction by the Chief Guest 06:45 \u2013 06:50 PM Felicitation of Guests 06:50 \u2013 07:00 PM Library App Release 07:00 \u2013 07:05 PM Quiz Session 07:05 \u2013 07:15 PM Felicitation to ACAC students 07:15 \u2013 07:20 PM Vote of Thanks 07:20 PM National Anthem Your presence and active participation will contribute significantly to the success of this celebration. With warm regards, Himmat Singh Assistant Registrar ___________________________________________________ \u0938\u094d\u092e\u093e\u0930\u0915 \u0926\u093f\u0935\u0938 \u0938\u092e\u093e\u0930\u094b\u0939 \u0938\u092e\u093f\u0924\u093f / Committee for Celebration of Commemorative Days (CCCD) \u0906\u0908\u0906\u0908",
+        "message_id": "<CADCv5WjLQTBkWxUB7XuOmQEKmNJftW5Orw8rnnjX-cAQ4bPFuw@mail.gmail.com>"
+      },
+      {
+        "date": "01-Apr-2025",
+        "time": "10:53:52",
+        "subject": "Fwd: FY Closure and Updates",
+        "content": "Dear Students, Today, April 1, marks an important day because we are taking two important steps in the direction of our evolution as a mature institute of higher learning. 1. Today, our Health Center starts working in autonomous mode, managed and operated by OUR OWN team. 2. Today, our transport services also start operating in autonomous mode, managed and operated by OUR OWN team. These two are definitely two big steps in the evolution of our institute. I would also like to put on record my deep appreciation of the teams of the Health Center, led by Prof. Anil Tiwari and Dr Neha Sharma, and the transport team, led by Prof. Shree Prakash Tiwari and Sandeep Chandel. Please join me in congratulating them for a good start. While these are big transitions, it is\u00a0possible that there might be some perturbations in services in the initial period. Please give your feedback to the process owners, and actions will be taken to minimise the inconveniences and meet all genuine expectations. Best regards -- With warm regards..... Prof. Avinash Kumar Agarwal, FTWAS, FAAAS, FCI, FSAE, FASME, FRSC, FNAE, FNASc, FISEES Director, IIT Jodhpur & Sir J C Bose National Fellow Tel: +91 291 2801011 (Off) Wikipedia: tinyurl.com/bdhe89ew | Scopus: https://tinyurl.com/mwccdcc4 | Google Scholar: https://tinyurl.com/mtbyv7w4 | FUEL: https://tinyurl.com/bdzn4r28 | Orcid: https://tinyurl.com/537m3tad ------------------------------ ------------------------------ ---------------- \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of The World Academy of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Combustion Institute, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Association for the Advancement of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Society of Mechanical Engineers \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Society of Automotive Engineers International, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of World Society for Sustainable Energy Technologies, UK \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Royal Society of Chemistry, UK \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of National Academy of Sciences India \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Indian National Academy of Engineering \u2022\u00a0 \u00a0 \u00a0 \u00a0F",
+        "message_id": "<CADCv5WhGgVj0LCjvkTKda_mNxQ6WqQdGmP1afV=sj2v=WSBwow@mail.gmail.com>"
+      },
+      {
+        "date": "23-Apr-2025",
+        "time": "20:27:50",
+        "subject": "Directorate Shifted to Chankya Complex",
+        "content": "Dear All, This is to inform you that all the offices of the Deans, Registrar, DD and D have moved back to Chanamkya\u00a0Complex. -- With warm regards..... Prof. Avinash Kumar Agarwal, FTWAS, FAAAS, FCI, FSAE, FASME, FRSC, FNAE, FNASc, FISEES Director, IIT Jodhpur & Sir J C Bose National Fellow Tel: +91 291 2801011 (Off) Wikipedia: tinyurl.com/bdhe89ew | Scopus: https://tinyurl.com/mwccdcc4 | Google Scholar: https://tinyurl.com/mtbyv7w4 | FUEL: https://tinyurl.com/bdzn4r28 | Orcid: https://tinyurl.com/537m3tad ------------------------------ ------------------------------ ---------------- \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of The World Academy of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Combustion Institute, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Association for the Advancement of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Society of Mechanical Engineers \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Society of Automotive Engineers International, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of World Society for Sustainable Energy Technologies, UK \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Royal Society of Chemistry, UK \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of National Academy of Sciences India \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Indian National Academy of Engineering \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of International Society of Energy, Environment, and Sustainability ------------------------------ ------------------------------ ------------- \u2022\u00a0 \u00a0 \u00a0 \u00a0Shanti Swarup Bhatnagar Award-2016 \u2022\u00a0 \u00a0 \u00a0 \u00a0Editor of FUEL \u2022\u00a0 \u00a0 \u00a0 \u00a0Associate Editor of ASME Open Journal of Engineering \u2022\u00a0 \u00a0 \u00a0 \u00a0Associate Editor of SAE International Journal of Engines ------------------------------ ------------------------------ --------------",
+        "message_id": "<CADCv5WhB=aoNjykLwPj9wY-ZNTCxnBp5EFsPriDs+mpH9Fi-WA@mail.gmail.com>"
+      },
+      {
+        "date": "01-May-2025",
+        "time": "12:20:20",
+        "subject": "Thank You",
+        "content": "Dear\r\nColleagues I want to thank all the stakeholders for their kind cooperation,\r\nenabling me to complete one year as Director of IIT Jodhpur. I joined the\r\nInstitute on 1 st May 2024. I realised this Institute has great potential and can break into the top echelons of\r\nranking among engineering institutions in the country and the world. However,\r\nto achieve this, all of us must work as a unified team. From my\r\nside, I assure you that I will make all possible efforts to ensure that fair\r\nand transparent governance processes are in place and we, as a team, make all\r\nthe efforts in the right direction. In the last\r\nyear, extra-mural research grants to IIT jodhpur have doubled, and project endorsements\r\nand publications have significantly increased; however, there are miles to go. I hope we\r\nall continue to work relentlessly to pursue excellence in our activities, be\r\nloyal to the Institute, and do all our duties with dedication, sincerity and\r\nhonesty. This Institute cannot have any room for corruption, nepotism and\r\nregionalism. As IIT Jodhpur stakeholders, we must commit to having excellent\r\nconduct and setting an example for others to follow. Wishing you\r\nall the very best Affectionately\r\nyours Avinash Kumar Agarwal, FTWAS, FAAAS, FCI, FSAE, FASME, FRSC, FNAE, FNASc, FISEES Director, IIT Jodhpur & Sir J C Bose National Fellow Tel: +91 291 2801011 (Off) Wikipedia: tinyurl.com/bdhe89ew | Scopus: https://tinyurl.com/mwccdcc4 | Google Scholar: https://tinyurl.com/mtbyv7w4 | FUEL: https://tinyurl.com/bdzn4r28 | Orcid: https://tinyurl.com/537m3tad ------------------------------ ------------------------------ ---------------- \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of The World Academy of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Combustion Institute, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Association for the Advancement of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Society of Mechanical Engineers \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Society of Automotive Engineers International, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of World Society for Sustainable Energy Technol",
+        "message_id": "<CADCv5Wjxn7Pj2XXBf4n2S0PyJQapU1aOOvfHfjjtr4xfSWbeKw@mail.gmail.com>"
+      },
+      {
+        "date": "07-May-2025",
+        "time": "20:56:02",
+        "subject": "Instruction for Next few days: Urgent attention",
+        "content": "Dear Faculty Members, Staff Members, Students and Other Constituents of our campus community You are aware that we are passing through a tough time, as far as national security is concerned. Today, we have done a drill for the evacuation of the campus community in the event of an air strike by our nemesis. We will have less than 5 minutes for blackout and evacuation into the tunnels. The next few days and nights are very critical, and we may be one of the soft targets. Hence, adequate care and precaution are important to all of us. Please note: 1. There will be no more drills. In case you hear a siren (Oscillating), it means an impending attack, and we will have less than 5 minutes to get into the tunnel hideouts.\u00a0The flat siren will mean that the danger has passed, and now it is safe to venture out. Enemy fighters\u00a0and missiles will reach us in 5-10 minutes after crossing the border, and that's all we would have to ensure our safety. 2. Today evening, we will do black out\u00a0drill between 10-10.15 PM. There will be no siren; hence, all of you are to follow the procedure voluntarily on your own. The power will be cut (If it is resumed by JVVNL). Every possible light source must be turned off. The lights can be put on again after 15 minutes, at 10.15 PM tonight. 3. In the event of an impending attack, the lights will be cut off centrally after the siren goes off, in the next 2-3 minutes.\u00a0That's all the time, you will have to come down the roads and move into the tunnels. It is\u00a0advised to carry your own water bottle in such an event. 4. There should be no live streaming, photographs posted on social media for these or sharing of this email on any platform. This will put all of us in danger. On each tunnel entry point, we will post security guards to\u00a0guide\u00a0you safely. Please ensure that you do not panic and move in a\u00a0disciplined manner into the tunnels,\u00a0when and if required. If you have already posted the photos and videos of tunnels on your social media accounts, please d",
+        "message_id": "<CADCv5WiK10w-aj0Vn2vq+bT1qViromAsfpwd+DPWGeYx2zspXA@mail.gmail.com>"
+      },
+      {
+        "date": "07-May-2025",
+        "time": "22:28:02",
+        "subject": "Re: Instruction for Next few days: Urgent attention",
+        "content": "Dear All, Thanks. Black out drill was an outstanding success and we figured out some lapses, which have been fixed. Be alert and all of us know the steps, in case required, to keep us safe. Be calm and hope that our forces will keep our nemesis at bay and we are not required to be in the hideout. In any case, now we all know the next steps and hopefully we will sleep peacefully. Best regards Avinash Kumar Agarwal On Wed, 7 May, 2025, 20:56 Director, IIT Jodhpur, < director@iitj.ac.in > wrote: Dear Faculty Members, Staff Members, Students and Other Constituents of our campus community You are aware that we are passing through a tough time, as far as national security is concerned. Today, we have done a drill for the evacuation of the campus community in the event of an air strike by our nemesis. We will have less than 5 minutes for blackout and evacuation into the tunnels. The next few days and nights are very critical, and we may be one of the soft targets. Hence, adequate care and precaution are important to all of us. Please note: 1. There will be no more drills. In case you hear a siren (Oscillating), it means an impending attack, and we will have less than 5 minutes to get into the tunnel hideouts.\u00a0The flat siren will mean that the danger has passed, and now it is safe to venture out. Enemy fighters\u00a0and missiles will reach us in 5-10 minutes after crossing the border, and that's all we would have to ensure our safety. 2. Today evening, we will do black out\u00a0drill between 10-10.15 PM. There will be no siren; hence, all of you are to follow the procedure voluntarily on your own. The power will be cut (If it is resumed by JVVNL). Every possible light source must be turned off. The lights can be put on again after 15 minutes, at 10.15 PM tonight. 3. In the event of an impending attack, the lights will be cut off centrally after the siren goes off, in the next 2-3 minutes.\u00a0That's all the time, you will have to come down the roads and move into the tunnels. It is\u00a0advis",
+        "message_id": "<CADCv5Wh8x5L+Z=5bNYG_f=tbX=Lo0HH=1cT3yTw9Huv4Kr+iWQ@mail.gmail.com>"
+      },
+      {
+        "date": "08-May-2025",
+        "time": "11:06:17",
+        "subject": "Re: [faculty] Re: Instruction for Next few days: Urgent attention",
+        "content": "Dear All, There was a complete blackout in the entire city last night from 12-4 AM as all feeders were shut down by the district administration, and there was no power supply anywhere in the city. This might have led to some inconveniences\u00a0for all of us in these difficult times. These directions of complete blackout\u00a0are likely to be given again by the district administration over the next few days, depending on threat perception and intel inputs. I am trying to get our electricity supplies uninterrupted by discussing with the district admin so that the campus community stays indoors during these long and declared blackout periods. It is likely that we will keep all our street lights and public lights off starting the evenings over the next few days. The campus community is advised to ensure that they have all lights off during the declared blackout periods,\u00a0without any defaults. Any defaults may lead to our staying without electricity,\u00a0at par with the rest of the city. In addition, in the event of a siren going off, everyone needs to rush to the hideouts, as per our previous drill. Siren will indicate an upcoming aerial raid. I would also like to reiterate that there is no specific additional threat to the IITJ community. The threat to us is similar to that of any other part of the country, and there is no specific need for any panic or concern. We are all in this situation, as a united Bharat, and we must all face it bravely. There is no need for any anxiety or nervousness by seeing our emails about the safety protocols. These are just to ensure that in the event of any adverse action by our nemesis, our campus community stays safe, and all these measures taken by IITJ and drills were part of precautionary measures taken on the directions of the district administration. You may please contact Prof. Bhabani Satapathi, Prof. S R Vadera or Col Virendra Singh Rathore in case of any genuine concerns. Best wishes Avinash Kumar Agarwal On Wed, May 7, 2025 at 11:32\u202fPM Avin",
+        "message_id": "<CADCv5WixMeCadxAfjoOoNrBR2WotkVyw-678FsLfEODX5KRisA@mail.gmail.com>"
+      },
+      {
+        "date": "08-May-2025",
+        "time": "21:42:20",
+        "subject": "Re: Important Notice: Citywide Blackout and Campus Power Supply Instructions",
+        "content": "Evacuation to tunnels immediately On Thu, 8 May, 2025, 21:32 Deputy Director IIT Jodhpur, < dydir@iitj.ac.in > wrote: Dear All, As per instructions from the District Administration, there will be a blackout and no power supply tonight across the entire city of Jodhpur. However, following discussions between our Director and the city administration, a special provision has been made to allow limited power supply within our campus\u2014only to Type C, Type B, and Hostel areas\u2014provided that the campus community strictly adheres to the following: \u2022\tRemain indoors throughout the blackout period. \u2022\tKeep all lights switched off; only fans may be used. \u2022\tNo lights should be visible from outside under any circumstance. Please note, no power supply will be provided to any other areas of the campus apart from the three mentioned above. Your cooperation is essential in ensuring compliance with this directive and maintaining safety for all. Warm regards, Prof. Bhabani Kumar Satapathy",
+        "message_id": "<CADCv5WiFEi5Qbim6PqHk7E-fu=qv4XP5ZDbg3uQgBAHou3Tzmw@mail.gmail.com>"
+      },
+      {
+        "date": "10-May-2025",
+        "time": "18:33:45",
+        "subject": "Updates",
+        "content": "Dear All, We should be aware that the threat is now over, and we can resume our \"Business as usual\". Those who are planning to go should not, and those who have already left the campus can make their plans to return, as per their convenience. Congratulations to all for showing an absolute resolve to tackle this national threat and showing that we are Bharat of the 21st century, a \"Naya Bharat\". This also calls for all IITJ constituents to work actively towards the national defence and offence capabilities. Jai Hind and Jai Bharat. Best regards Avinash Kumar AGarwal",
+        "message_id": "<CADCv5Wg8YogC8kG2DH7w=GmpZiKb80_nXMhBFRJjNTUZBVGQVQ@mail.gmail.com>"
+      },
+      {
+        "date": "24-May-2025",
+        "time": "21:46:02",
+        "subject": "Great News",
+        "content": "Dear All, I am delighted to share with you some fantastic news. Our Jaipur campus has come one step closer to realisation with the Government of Rajasthan agreeing \"in principle\" to allocate us land and buildings. Now we have secured a letter of intent from the GoR, which now needs to be taken up with the Ministry of Education and the Ministry of Finance, Government of India. Once these approvals are secured, we will realise our dream of having a Jaipur campus, apart from our main campus in Jodhpur. We are also beginning to work on our small footprint\u00a0campus in Jaisalmer to\u00a0complete our dream of IITJ3. This is a big feat for us as an institute to get the GoR to agree to our proposal. Hopefully, more good things will follow. -- With warm regards..... Prof. Avinash Kumar Agarwal, FTWAS, FAAAS, FCI, FSAE, FASME, FRSC, FNAE, FNASc, FISEES Director, IIT Jodhpur & Sir J C Bose National Fellow Tel: +91 291 2801011 (Off) Wikipedia: tinyurl.com/bdhe89ew | Scopus: https://tinyurl.com/mwccdcc4 | Google Scholar: https://tinyurl.com/mtbyv7w4 | FUEL: https://tinyurl.com/bdzn4r28 | Orcid: https://tinyurl.com/537m3tad ------------------------------ ------------------------------ ---------------- \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of The World Academy of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Combustion Institute, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Association for the Advancement of Science \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of American Society of Mechanical Engineers \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Society of Automotive Engineers International, USA \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of World Society for Sustainable Energy Technologies, UK \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Royal Society of Chemistry, UK \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of National Academy of Sciences India \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of Indian National Academy of Engineering \u2022\u00a0 \u00a0 \u00a0 \u00a0Fellow of International Society of Energy, Environment, and Sustainability ------------------------------ ------------------------------ ------------- \u2022\u00a0 \u00a0 \u00a0 \u00a0Shanti Swarup Bhatnagar Award-2016 \u2022\u00a0 \u00a0 \u00a0 \u00a0Editor of FUEL \u2022\u00a0 \u00a0 \u00a0 \u00a0Associate Editor of ASME Open Journal of Enginee",
+        "message_id": "<CADCv5Wik-=UY6XFVqbtHBPNYXGe3gWkYE82qV286AySDp1qL_w@mail.gmail.com>"
+      },
+      {
+        "date": "07-Jun-2025",
+        "time": "12:44:03",
+        "subject": "Greetings on the occasion of Eid al-Adha!",
+        "content": "Dear All, On the joyous occasion of Eid al-Adha, I extend my warmest greetings to all members of IITJ. This festival, rooted in the values of personal sacrifices, compassion, empathy and unity, inspires us to strengthen our bonds and work together for the greater good. At IIT Jodhpur, we are committed to nurturing an environment of compassion, empathy, honesty, collaboration, innovation, and integrity. As we celebrate this auspicious day, let us reaffirm our dedication to positive growth, unite in our pursuit of excellence, and resolve to uphold transparency. May this festival bring peace, prosperity, and harmony to our vibrant campus community and its constituents. Best wishes, Affectionately Yours Avinash Kumar Agarwal Director",
+        "message_id": "<CADCv5Wj4J-FCNitA2r_m9uT5pFZNz-OQFXTwQM1em+ki69=9jQ@mail.gmail.com>"
+      }
+    ],
+    "last_scraped": "07-Jun-2025"
+  },
+  "agarwal.27@gmail.com": {
+    "emails": [],
+    "last_scraped": "07-Jun-2025"
+  },
+  "agarwal.27@iitj.ac.in": {
+    "emails": [
+      {
+        "date": "07-Jun-2025",
+        "time": "16:42:51",
+        "subject": "testing",
+        "content": "hi bro",
+        "message_id": "<CAPziNCaSuVqpqNNfsRjhVbx22jN_vos3EGK_Odt-8WiD0HRKKQ@mail.gmail.com>"
+      }
+    ],
+    "last_scraped": "07-Jun-2025"
+  }
+}

server/email_scraper.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Enhanced Email Scraper with Intelligent Caching
+"""
+
+import os
+import imaplib
+import json
+from email import message_from_bytes
+from bs4 import BeautifulSoup
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+from zoneinfo import ZoneInfo
+from email.utils import parsedate_to_datetime
+from typing import List, Dict
+
+load_dotenv()
+
+# Email credentials
+APP_PASSWORD = os.getenv("APP_PASSWORD")
+EMAIL_ID = os.getenv("EMAIL_ID")
+EMAIL_DB_FILE = "email_db.json"
+
+def _imap_connect():
+    """Connect to Gmail IMAP server"""
+    try:
+        mail = imaplib.IMAP4_SSL("imap.gmail.com")
+        mail.login(EMAIL_ID, APP_PASSWORD)
+        mail.select('"[Gmail]/All Mail"')
+        return mail
+    except Exception as e:
+        print(f"IMAP connection failed: {e}")
+        raise
+
+def _email_to_clean_text(msg):
+    """Extract clean text from email message"""
+    # Try HTML first
+    html_content = None
+    text_content = None
+    
+    if msg.is_multipart():
+        for part in msg.walk():
+            content_type = part.get_content_type()
+            if content_type == "text/html":
+                try:
+                    html_content = part.get_payload(decode=True).decode(errors="ignore")
+                except:
+                    continue
+            elif content_type == "text/plain":
+                try:
+                    text_content = part.get_payload(decode=True).decode(errors="ignore")
+                except:
+                    continue
+    else:
+        # Non-multipart message
+        content_type = msg.get_content_type()
+        try:
+            content = msg.get_payload(decode=True).decode(errors="ignore")
+            if content_type == "text/html":
+                html_content = content
+            else:
+                text_content = content
+        except:
+            pass
+    
+    # Clean HTML content
+    if html_content:
+        soup = BeautifulSoup(html_content, "html.parser")
+        # Remove script and style elements
+        for script in soup(["script", "style"]):
+            script.decompose()
+        return soup.get_text(separator=' ', strip=True)
+    elif text_content:
+        return text_content.strip()
+    else:
+        return ""
+
+def _load_email_db() -> Dict:
+    """Load email database from file"""
+    if not os.path.exists(EMAIL_DB_FILE):
+        return {}
+    try:
+        with open(EMAIL_DB_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        print(f"Warning: Could not load {EMAIL_DB_FILE}, starting with empty database")
+        return {}
+
+def _save_email_db(db: Dict):
+    """Save email database to file"""
+    try:
+        with open(EMAIL_DB_FILE, "w") as f:
+            json.dump(db, f, indent=2)
+    except IOError as e:
+        print(f"Error saving database: {e}")
+        raise
+
+def _date_to_imap_format(date_str: str) -> str:
+    """Convert DD-MMM-YYYY to IMAP date format"""
+    try:
+        dt = datetime.strptime(date_str, "%d-%b-%Y")
+        return dt.strftime("%d-%b-%Y")
+    except ValueError:
+        raise ValueError(f"Invalid date format: {date_str}. Expected DD-MMM-YYYY")
+
+def _is_date_in_range(email_date: str, start_date: str, end_date: str) -> bool:
+    """Check if email date is within the specified range"""
+    try:
+        email_dt = datetime.strptime(email_date, "%d-%b-%Y")
+        start_dt = datetime.strptime(start_date, "%d-%b-%Y")
+        end_dt = datetime.strptime(end_date, "%d-%b-%Y")
+        return start_dt <= email_dt <= end_dt
+    except ValueError:
+        return False
+
+def scrape_emails_from_sender(sender_email: str, start_date: str, end_date: str) -> List[Dict]:
+    """
+    Scrape emails from specific sender within date range
+    Uses intelligent caching to avoid re-scraping
+    """
+    print(f"Scraping emails from {sender_email} between {start_date} and {end_date}")
+    
+    # Load existing database
+    db = _load_email_db()
+    sender_email = sender_email.lower().strip()
+    
+    # Check if we have cached emails for this sender
+    if sender_email in db:
+        cached_emails = db[sender_email].get("emails", [])
+        
+        # Filter cached emails by date range
+        filtered_emails = [
+            email for email in cached_emails
+            if _is_date_in_range(email["date"], start_date, end_date)
+        ]
+        
+        # Check if we need to scrape more recent emails
+        last_scraped = db[sender_email].get("last_scraped", "01-Jan-2020")
+        today = datetime.today().strftime("%d-%b-%Y")
+        
+        if last_scraped == today and filtered_emails:
+            print(f"Using cached emails (last scraped: {last_scraped})")
+            return filtered_emails
+    
+    # Need to scrape emails
+    try:
+        mail = _imap_connect()
+        
+        # Prepare IMAP search criteria
+        start_imap = _date_to_imap_format(start_date)
+        # Add one day to end_date for BEFORE criteria (IMAP BEFORE is exclusive)
+        end_dt = datetime.strptime(end_date, "%d-%b-%Y") + timedelta(days=1)
+        end_imap = end_dt.strftime("%d-%b-%Y")
+        
+        search_criteria = f'(FROM "{sender_email}") SINCE "{start_imap}" BEFORE "{end_imap}"'
+        print(f"IMAP search: {search_criteria}")
+        
+        # Search for emails
+        status, data = mail.search(None, search_criteria)
+        if status != 'OK':
+            raise Exception(f"IMAP search failed: {status}")
+        
+        email_ids = data[0].split()
+        print(f"Found {len(email_ids)} emails")
+        
+        scraped_emails = []
+        
+        # Process each email
+        for i, email_id in enumerate(email_ids):
+            try:
+                print(f"Processing email {i+1}/{len(email_ids)}")
+                
+                # Fetch email
+                status, msg_data = mail.fetch(email_id, "(RFC822)")
+                if status != 'OK':
+                    continue
+                
+                # Parse email
+                msg = message_from_bytes(msg_data[0][1])
+                
+                # Extract information
+                subject = msg.get("Subject", "No Subject")
+                content = _email_to_clean_text(msg)
+                
+                # Parse date
+                date_header = msg.get("Date", "")
+                if date_header:
+                    try:
+                        dt_obj = parsedate_to_datetime(date_header)
+                        # Convert to IST
+                        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:
+                        email_date = datetime.today().strftime("%d-%b-%Y")
+                        email_time = "00:00:00"
+                else:
+                    email_date = datetime.today().strftime("%d-%b-%Y")
+                    email_time = "00:00:00"
+                
+                # Get message ID for deduplication
+                message_id = msg.get("Message-ID", f"missing-{email_id.decode()}")
+                
+                scraped_emails.append({
+                    "date": email_date,
+                    "time": email_time,
+                    "subject": subject,
+                    "content": content[:2000],  # Limit content length
+                    "message_id": message_id
+                })
+                
+            except Exception as e:
+                print(f"Error processing email {email_id}: {e}")
+                continue
+        
+        mail.logout()
+        
+        # Update database
+        if sender_email not in db:
+            db[sender_email] = {"emails": [], "last_scraped": ""}
+        
+        # Merge with existing emails (avoid duplicates)
+        existing_emails = db[sender_email].get("emails", [])
+        existing_ids = {email.get("message_id") for email in existing_emails}
+        
+        new_emails = [
+            email for email in scraped_emails 
+            if email["message_id"] not in existing_ids
+        ]
+        
+        # Update database
+        db[sender_email]["emails"] = existing_emails + new_emails
+        db[sender_email]["last_scraped"] = datetime.today().strftime("%d-%b-%Y")
+        
+        # Save database
+        _save_email_db(db)
+        
+        # Return filtered results
+        all_emails = db[sender_email]["emails"]
+        filtered_emails = [
+            email for email in all_emails
+            if _is_date_in_range(email["date"], start_date, end_date)
+        ]
+        
+        print(f"Scraped {len(new_emails)} new emails, returning {len(filtered_emails)} in date range")
+        return filtered_emails
+        
+    except Exception as e:
+        print(f"Email scraping failed: {e}")
+        raise
+
+# Test the scraper
+if __name__ == "__main__":
+    # Test scraping
+    try:
+        emails = scrape_emails_from_sender(
+            "noreply@example.com", 
+            "01-Jun-2025", 
+            "07-Jun-2025"
+        )
+        
+        print(f"\nFound {len(emails)} emails:")
+        for email in emails[:3]:  # Show first 3
+            print(f"- {email['date']} {email['time']}: {email['subject']}")
+            
+    except Exception as e:
+        print(f"Test failed: {e}")

server/main.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from routes import router
+
+app = FastAPI(
+    title="Email Query System",
+    description="Natural language email querying with intent classification",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routes
+app.include_router(router, prefix="/api/v1")
+
+@app.get("/")
+def root():
+    return {
+        "message": "Email Query System API",
+        "docs": "/docs",
+        "health": "/api/v1/health"
+    }

server/name_mapping.json

@@ -0,0 +1,3 @@
+{
+  "dev": "agarwal.27@iitj.ac.in"
+}

server/query_parser.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+Query Parser with Intent Classification and Name-to-Email Resolution
+"""
+
+import json
+import os
+from datetime import datetime, timedelta
+from openai import OpenAI
+from typing import Dict, Optional, Tuple
+from dotenv import load_dotenv  # <-- Add this
+
+# Load environment variables from .env file
+load_dotenv()  # <-- Add this
+
+# Initialize OpenAI client
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+# File paths
+NAME_MAPPING_FILE = "name_mapping.json"
+EMAIL_DB_FILE = "email_db.json"
+
+def _llm(messages, model="gpt-4o-mini", temperature=0):
+    """Helper function to call OpenAI API"""
+    rsp = client.chat.completions.create(
+        model=model,
+        temperature=temperature,
+        messages=messages,
+    )
+    return rsp.choices[0].message.content.strip()
+
+def _load_name_mapping() -> Dict[str, str]:
+    """Load name to email mapping from JSON file"""
+    if not os.path.exists(NAME_MAPPING_FILE):
+        return {}
+    try:
+        with open(NAME_MAPPING_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+def _save_name_mapping(mapping: Dict[str, str]):
+    """Save name to email mapping to JSON file"""
+    with open(NAME_MAPPING_FILE, "w") as f:
+        json.dump(mapping, f, indent=2)
+
+def _load_email_db() -> Dict:
+    """Load email database"""
+    if not os.path.exists(EMAIL_DB_FILE):
+        return {}
+    try:
+        with open(EMAIL_DB_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+def _save_email_db(db: Dict):
+    """Save email database"""
+    with open(EMAIL_DB_FILE, "w") as f:
+        json.dump(db, f, indent=2)
+
+def extract_query_info(query: str) -> Dict:
+    """
+    Extract intent and date range from user query using LLM
+    """
+    today_str = datetime.today().strftime("%d-%b-%Y")
+    
+    system_prompt = f"""
+You are an email query parser. Today is {today_str}.
+
+Given a user query, extract:
+1. sender_intent: The person/entity they want emails from (could be name or email)
+2. start_date and end_date: Date range in DD-MMM-YYYY format
+
+For relative dates:
+- "last week" = 7 days ago to today
+- "yesterday" = yesterday only  
+- "last month" = 30 days ago to today
+- "last 3 days" = 3 days ago to today
+
+Examples:
+- "emails from dev agarwal last week" → sender_intent: "dev agarwal"
+- "show amazon emails from last month" → sender_intent: "amazon"  
+- "emails from john@company.com yesterday" → sender_intent: "john@company.com"
+
+Return ONLY valid JSON:
+{{
+  "sender_intent": "extracted name or email",
+  "start_date": "DD-MMM-YYYY",
+  "end_date": "DD-MMM-YYYY"
+}}
+"""
+    
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": query}
+    ]
+    
+    result = _llm(messages)
+    return json.loads(result)
+
+def resolve_sender_email(sender_intent: str) -> Tuple[Optional[str], bool]:
+    """
+    Resolve sender intent to actual email address
+    Returns: (email_address, needs_user_input)
+    """
+    # Check if it's already an email address
+    if "@" in sender_intent:
+        return sender_intent.lower(), False
+    
+    # Load name mapping
+    name_mapping = _load_name_mapping()
+    
+    # Normalize the intent (lowercase for comparison)
+    normalized_intent = sender_intent.lower().strip()
+    
+    # Check direct match
+    if normalized_intent in name_mapping:
+        return name_mapping[normalized_intent], False
+    
+    # Check partial matches (fuzzy matching)
+    for name, email in name_mapping.items():
+        if normalized_intent in name.lower() or name.lower() in normalized_intent:
+            return email, False
+    
+    # No match found
+    return None, True
+
+def store_name_email_mapping(name: str, email: str):
+    """Store new name to email mapping"""
+    name_mapping = _load_name_mapping()
+    name_mapping[name.lower().strip()] = email.lower().strip()
+    _save_name_mapping(name_mapping)
+
+def parse_email_query(query: str) -> Dict:
+    """
+    Main function to parse email query
+    Returns structured response with next steps
+    """
+    try:
+        # Step 1: Extract intent and dates
+        query_info = extract_query_info(query)
+        sender_intent = query_info["sender_intent"]
+        start_date = query_info["start_date"]
+        end_date = query_info["end_date"]
+        
+        # Step 2: Resolve sender email
+        email_address, needs_input = resolve_sender_email(sender_intent)
+        
+        if needs_input:
+            # Need to ask user for email address
+            return {
+                "status": "need_email_input",
+                "sender_intent": sender_intent,
+                "start_date": start_date,
+                "end_date": end_date,
+                "message": f"I don't have an email address for '{sender_intent}'. Please provide the email address."
+            }
+        else:
+            # Ready to proceed with email scraping
+            return {
+                "status": "ready_to_scrape",
+                "sender_intent": sender_intent,
+                "resolved_email": email_address,
+                "start_date": start_date,
+                "end_date": end_date,
+                "message": f"Found email: {email_address} for '{sender_intent}'"
+            }
+            
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e),
+            "message": "Failed to parse query"
+        }
+
+# Test the parser
+if __name__ == "__main__":
+    # Test cases
+    test_queries = [
+        "Show me emails from dev agarwal last week",
+        "emails from amazon in the last month", 
+        "get john@company.com emails yesterday",
+        "emails from new person last 3 days"
+    ]
+    
+    for query in test_queries:
+        print(f"\nQuery: {query}")
+        result = parse_email_query(query)
+        print(f"Result: {json.dumps(result, indent=2)}")

server/routes.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+FastAPI Routes for Email Query System
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, EmailStr
+from typing import List, Dict, Optional
+import json
+
+# Import our modules
+from query_parser import parse_email_query, store_name_email_mapping
+from email_scraper import scrape_emails_from_sender
+
+router = APIRouter()
+
+# Pydantic models
+class NaturalQuery(BaseModel):
+    query: str
+
+class EmailMappingInput(BaseModel):
+    name: str
+    email: EmailStr
+
+class EmailResponse(BaseModel):
+    date: str
+    time: str
+    subject: str
+    content: str
+    message_id: str
+
+class QueryParseResponse(BaseModel):
+    status: str
+    sender_intent: Optional[str] = None
+    resolved_email: Optional[str] = None
+    start_date: Optional[str] = None
+    end_date: Optional[str] = None
+    message: str
+    error: Optional[str] = None
+
+class EmailsResponse(BaseModel):
+    status: str
+    sender_intent: str
+    resolved_email: str
+    start_date: str
+    end_date: str
+    total_emails: int
+    emails: List[EmailResponse]
+    message: str
+
+@router.post("/parse_query", response_model=QueryParseResponse)
+def parse_email_query_endpoint(input_data: NaturalQuery):
+    """
+    Parse natural language query to extract intent and dates
+    """
+    try:
+        result = parse_email_query(input_data.query)
+        return QueryParseResponse(**result)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Query parsing failed: {str(e)}")
+
+@router.post("/add_email_mapping")
+def add_email_mapping(mapping: EmailMappingInput):
+    """
+    Add new name to email mapping
+    """
+    try:
+        store_name_email_mapping(mapping.name, mapping.email)
+        return {
+            "status": "success",
+            "message": f"Mapping added: '{mapping.name}' → '{mapping.email}'"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to add mapping: {str(e)}")
+
+@router.post("/get_emails", response_model=EmailsResponse)
+def get_emails_from_query(input_data: NaturalQuery):
+    """
+    Complete flow: Parse query → Resolve email → Scrape emails
+    """
+    try:
+        # Step 1: Parse the query
+        parsed_result = parse_email_query(input_data.query)
+        
+        if parsed_result["status"] == "need_email_input":
+            raise HTTPException(
+                status_code=400, 
+                detail={
+                    "type": "need_email_input",
+                    "sender_intent": parsed_result["sender_intent"],
+                    "message": parsed_result["message"]
+                }
+            )
+        elif parsed_result["status"] == "error":
+            raise HTTPException(status_code=400, detail=parsed_result["message"])
+        
+        # Step 2: Scrape emails
+        emails = scrape_emails_from_sender(
+            parsed_result["resolved_email"],
+            parsed_result["start_date"],
+            parsed_result["end_date"]
+        )
+        
+        # Step 3: Format response
+        email_responses = [
+            EmailResponse(
+                date=email["date"],
+                time=email["time"],
+                subject=email["subject"],
+                content=email["content"],
+                message_id=email["message_id"]
+            )
+            for email in emails
+        ]
+        
+        return EmailsResponse(
+            status="success",
+            sender_intent=parsed_result["sender_intent"],
+            resolved_email=parsed_result["resolved_email"],
+            start_date=parsed_result["start_date"],
+            end_date=parsed_result["end_date"],
+            total_emails=len(emails),
+            emails=email_responses,
+            message=f"Found {len(emails)} emails from {parsed_result['resolved_email']}"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Email retrieval failed: {str(e)}")
+
+@router.get("/view_mappings")
+def view_name_mappings():
+    """
+    View all stored name to email mappings
+    """
+    try:
+        from query_parser import _load_name_mapping
+        mappings = _load_name_mapping()
+        return {
+            "status": "success",
+            "total_mappings": len(mappings),
+            "mappings": mappings
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to load mappings: {str(e)}")
+
+@router.get("/health")
+def health_check():
+    """
+    Health check endpoint
+    """
+    return {
+        "status": "healthy",
+        "message": "Email query system is running"
+    }
+
+# For testing - manual endpoint to add mapping and then query
+@router.post("/complete_flow")
+def complete_email_flow(input_data: dict):
+    """
+    Test endpoint for complete flow with optional mapping
+    Expected input:
+    {
+        "query": "emails from john last week",
+        "mapping": {"name": "john", "email": "john@example.com"}  # optional
+    }
+    """
+    try:
+        query = input_data.get("query")
+        mapping = input_data.get("mapping")
+        
+        if not query:
+            raise HTTPException(status_code=400, detail="Query is required")
+        
+        # Add mapping if provided
+        if mapping:
+            store_name_email_mapping(mapping["name"], mapping["email"])
+        
+        # Parse and get emails
+        parsed_result = parse_email_query(query)
+        
+        if parsed_result["status"] == "need_email_input":
+            return {
+                "status": "need_mapping",
+                "message": parsed_result["message"],
+                "sender_intent": parsed_result["sender_intent"]
+            }
+        
+        # Get emails
+        emails = scrape_emails_from_sender(
+            parsed_result["resolved_email"],
+            parsed_result["start_date"],
+            parsed_result["end_date"]
+        )
+        
+        return {
+            "status": "success",
+            "query": query,
+            "parsed": parsed_result,
+            "total_emails": len(emails),
+            "emails": emails[:5]  # Return first 5 emails
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))