removed open ai involvement

agentic_implementation/email_mcp_server_oauth.py

@@ -1,3 +1,8 @@
+#!/usr/bin/env python3
+"""
+Gmail MCP Server with OAuth Authentication and Multi-Account Support
+"""
+
 import gradio as gr
 import json
 import os
@@ -7,18 +12,93 @@ from dotenv import load_dotenv
 
 # Import OAuth-enabled modules
 from tools import extract_query_info, analyze_emails
-from gmail_api_scraper import gmail_scraper
+from gmail_api_scraper import GmailAPIScraper
 from oauth_manager import oauth_manager
 from logger import logger
 
 load_dotenv()
 
+# Initialize Gmail API scraper
+gmail_scraper = GmailAPIScraper()
+
 def check_authentication() -> tuple[bool, str]:
-    """Check if user is authenticated and return status info"""
-    if oauth_manager.is_authenticated():
-        user_email = oauth_manager.get_user_email()
-        return True, user_email or "authenticated"
-    return False, "not authenticated"
+    """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:
     """
@@ -203,18 +283,20 @@ def remove_account(email_to_remove: str) -> str:
         }
         return json.dumps(error_result, indent=2)
 
-def search_emails(query: str) -> str:
+def search_emails(sender_keyword: str, start_date: str = "", end_date: str = "") -> str:
     """
-    Search for emails based on a natural language query using OAuth authentication.
+    Search for emails from a specific sender within a date range using OAuth authentication.
     
     Args:
-        query (str): Natural language query (e.g., "show me mails from swiggy last week")
+        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 query: %s", query)
+        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()
@@ -225,11 +307,13 @@ def search_emails(query: str) -> str:
                 "auth_status": auth_info
             }, indent=2)
         
-        # 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")
+        # 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}")
         
@@ -238,7 +322,8 @@ def search_emails(query: str) -> str:
         
         if not full_emails:
             result = {
-                "query_info": query_info,
+                "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,
@@ -259,12 +344,13 @@ def search_emails(query: str) -> str:
             }
             email_summary.append(summary_email)
         
-        # Auto-analyze the emails for insights
-        analysis = analyze_emails(full_emails)
+        # Auto-analyze the emails for insights (no OpenAI)
+        analysis = simple_analyze_emails(full_emails)
         
         # Return summary info with analysis
         result = {
-            "query_info": query_info,
+            "sender_keyword": sender_keyword,
+            "date_range": f"{start_date} to {end_date}",
             "email_summary": email_summary,
             "analysis": analysis,
             "email_count": len(full_emails),
@@ -277,8 +363,8 @@ def search_emails(query: str) -> str:
         logger.error("Error in search_emails: %s", e)
         error_result = {
             "error": str(e),
-            "query": query,
-            "message": "Failed to search emails. Please check your authentication and try again."
+            "sender_keyword": sender_keyword,
+            "message": "Failed to search emails."
         }
         return json.dumps(error_result, indent=2)
 
@@ -371,8 +457,8 @@ def analyze_email_patterns(sender_keyword: str, days_back: str = "30") -> str:
             }
             return json.dumps(result, indent=2)
         
-        # Analyze the emails
-        analysis = analyze_emails(full_emails)
+        # Analyze the emails (no OpenAI)
+        analysis = simple_analyze_emails(full_emails)
         
         result = {
             "sender_keyword": sender_keyword,
@@ -436,11 +522,13 @@ def get_authentication_status() -> str:
 search_interface = gr.Interface(
     fn=search_emails,
     inputs=[
-        gr.Textbox(label="Query", placeholder="Show me emails from amazon last week")
+        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 using natural language queries with OAuth authentication"
+    description="Search your emails by sender keyword and date range with OAuth authentication"
 )
 
 details_interface = gr.Interface(

agentic_implementation/requirements_oauth.txt

@@ -1,21 +1,22 @@
-# Core dependencies from original requirements
-gradio>=4.0.0
-python-dotenv
-beautifulsoup4
+# Core OAuth Gmail MCP Server Dependencies
+gradio
+google-auth
+google-auth-oauthlib
+google-auth-httplib2
+google-api-python-client
+cryptography
 requests
+loguru
+python-dateutil
 
-# OAuth and Google API dependencies
-google-auth>=2.15.0
-google-auth-oauthlib>=1.0.0
-google-auth-httplib2>=0.2.0
-google-api-python-client>=2.70.0
+# MCP server support
+mcp
 
-# Encryption for secure credential storage
-cryptography>=3.4.8
+# Email processing
+email-validator
+beautifulsoup4
+html2text
 
-# Existing dependencies (if not already included)
-openai
-pandas
-numpy
-matplotlib
-seaborn 
+# Development (optional)
+pytest
+black