1# Install required packages
2pip install openai python-dotenv

1import openai
2import os
3from dotenv import load_dotenv
4
5# Load API key from environment
6load_dotenv()
7openai.api_key = os.getenv("OPENAI_API_KEY")
8
9def test_openai_connection():
10    """Verify OpenAI API is working."""
11    try:
12        response = openai.ChatCompletion.create(
13            model="gpt-4",
14            messages=[{"role": "user", "content": "Say 'API connected'"}],
15            max_tokens=10
16        )
17        print(f"✅ {response.choices[0].message.content}")
18    except Exception as e:
19        print(f"❌ Error: {e}")
20
21test_openai_connection()

1def analyze_email(subject, body, sender):
2    """
3    Analyze email to determine priority, sentiment, and required action.
4    
5    Args:
6        subject: Email subject line
7        body: Email content
8        sender: Sender email address
9    
10    Returns:
11        dict with urgency, sentiment, category, and suggested action
12    """
13    
14    prompt = f"""Analyze this email and provide structured assessment:
15
16From: {sender}
17Subject: {subject}
18Body: {body}
19
20Provide analysis in this exact format:
21URGENCY: [high/medium/low]
22SENTIMENT: [positive/neutral/negative/urgent]
23CATEGORY: [meeting request/question/update/complaint/sales/other]
24ACTION REQUIRED: [reply needed/forward to team/schedule meeting/acknowledge/no action]
25KEY POINTS: [bullet list of main points]
26SUGGESTED RESPONSE TONE: [formal/friendly/apologetic/enthusiastic]
27"""
28
29    try:
30        response = openai.ChatCompletion.create(
31            model="gpt-4",
32            messages=[
33                {"role": "system", "content": "You are an expert email analyst who helps prioritize and categorize emails."},
34                {"role": "user", "content": prompt}
35            ],
36            temperature=0.3,
37            max_tokens=500
38        )
39        
40        analysis_text = response.choices[0].message.content
41        
42        # Parse response into structured data
43        analysis = {}
44        for line in analysis_text.split('\n'):
45            if ':' in line:
46                key, value = line.split(':', 1)
47                analysis[key.strip().lower().replace(' ', '_')] = value.strip()
48        
49        return analysis
50    
51    except Exception as e:
52        print(f"❌ Analysis error: {e}")
53        return None
54
55
56# Example usage
57email_analysis = analyze_email(
58    subject="Urgent: Production server down",
59    body="Hi, our production server has been down for 15 minutes. Customers are reporting errors. Need immediate help.",
60    sender="ops@company.com"
61)
62
63print(f"Urgency: {email_analysis.get('urgency')}")
64print(f"Action: {email_analysis.get('action_required')}")

1def generate_email_response(original_subject, original_body, 
2                          sender, context="", tone="professional"):
3    """
4    Generate an email response draft using AI.
5    
6    Args:
7        original_subject: Subject of email being replied to
8        original_body: Content of original email
9        sender: Who sent the original email
10        context: Additional context about the situation
11        tone: Desired response tone
12    
13    Returns:
14        str: Draft email response
15    """
16    
17    prompt = f"""You are writing an email response on behalf of a busy professional.
18
19ORIGINAL EMAIL:
20From: {sender}
21Subject: {original_subject}
22Body: {original_body}
23
24ADDITIONAL CONTEXT: {context}
25
26Generate a {tone} response that:
271. Acknowledges the email appropriately
282. Addresses the main points or questions
293. Provides helpful information or next steps
304. Maintains a {tone} tone
315. Is concise (under 150 words)
32
33Write ONLY the email body, no subject line needed.
34"""
35
36    try:
37        response = openai.ChatCompletion.create(
38            model="gpt-4",
39            messages=[
40                {"role": "system", "content": "You are a professional email writer who drafts clear, helpful responses."},
41                {"role": "user", "content": prompt}
42            ],
43            temperature=0.7,
44            max_tokens=300
45        )
46        
47        draft = response.choices[0].message.content.strip()
48        return draft
49    
50    except Exception as e:
51        print(f"❌ Response generation error: {e}")
52        return None
53
54
55# Example: Responding to meeting request
56response_draft = generate_email_response(
57    original_subject="Can we schedule a call next week?",
58    original_body="Hi! I'd love to discuss the Q1 marketing campaign with you. Do you have 30 minutes available next week?",
59    sender="marketing@company.com",
60    context="You have availability on Tuesday and Thursday afternoons",
61    tone="friendly and professional"
62)
63
64print("DRAFT RESPONSE:")
65print(response_draft)

1def summarize_email_thread(emails):
2    """
3    Summarize a chain of emails into key points and action items.
4    
5    Args:
6        emails: List of dicts with 'sender', 'subject', 'body', 'date'
7    
8    Returns:
9        dict with summary and action items
10    """
11    
12    # Combine thread into single text
13    thread_text = ""
14    for i, email in enumerate(emails, 1):
15        thread_text += f"\nEmail {i} ({email['date']}):\n"
16        thread_text += f"From: {email['sender']}\n"
17        thread_text += f"Subject: {email['subject']}\n"
18        thread_text += f"Body: {email['body']}\n"
19        thread_text += "-" * 40
20    
21    prompt = f"""Summarize this email thread concisely.
22
23{thread_text}
24
25Provide:
261. MAIN TOPIC: One sentence describing what this thread is about
272. KEY DECISIONS: What was decided or agreed upon
283. ACTION ITEMS: What needs to be done and by whom
294. CURRENT STATUS: Where things stand now
305. NEXT STEPS: What should happen next
31
32Be concise and actionable.
33"""
34
35    try:
36        response = openai.ChatCompletion.create(
37            model="gpt-4",
38            messages=[
39                {"role": "system", "content": "You are an expert at summarizing email threads into actionable information."},
40                {"role": "user", "content": prompt}
41            ],
42            temperature=0.3,
43            max_tokens=400
44        )
45        
46        summary = response.choices[0].message.content
47        return summary
48    
49    except Exception as e:
50        print(f"❌ Summarization error: {e}")
51        return None

1def create_writing_style_profile(sample_emails):
2    """
3    Analyze sample emails to extract writing style characteristics.
4    
5    Args:
6        sample_emails: List of your previously sent emails
7    
8    Returns:
9        str: Style guide for AI to follow
10    """
11    
12    # Combine sample emails
13    samples = "\n\n---\n\n".join(sample_emails)
14    
15    prompt = f"""Analyze these email samples and create a writing style guide.
16
17SAMPLE EMAILS:
18{samples}
19
20Create a style guide that captures:
211. Typical greeting style
222. Sentence structure preferences (short vs. long)
233. Tone characteristics
244. Common phrases or words used
255. How they sign off
266. Formality level
277. Use of punctuation and formatting
28
29Be specific so AI can replicate this style.
30"""
31
32    try:
33        response = openai.ChatCompletion.create(
34            model="gpt-4",
35            messages=[
36                {"role": "system", "content": "You are an expert at analyzing and documenting writing styles."},
37                {"role": "user", "content": prompt}
38            ],
39            temperature=0.3,
40            max_tokens=500
41        )
42        
43        style_guide = response.choices[0].message.content
44        return style_guide
45    
46    except Exception as e:
47        print(f"❌ Style analysis error: {e}")
48        return None
49
50
51def generate_styled_response(original_email, style_guide):
52    """
53    Generate response matching your personal writing style.
54    
55    Args:
56        original_email: Email to respond to
57        style_guide: Your writing style characteristics
58    
59    Returns:
60        str: Response draft in your style
61    """
62    
63    prompt = f"""Write an email response following this specific writing style:
64
65WRITING STYLE GUIDE:
66{style_guide}
67
68ORIGINAL EMAIL:
69{original_email}
70
71Write a response that matches the style guide exactly while addressing the original email appropriately.
72"""
73
74    response = openai.ChatCompletion.create(
75        model="gpt-4",
76        messages=[
77            {"role": "system", "content": "You are a ghostwriter who perfectly mimics writing styles."},
78            {"role": "user", "content": prompt}
79        ],
80        temperature=0.8,
81        max_tokens=300
82    )
83    
84    return response.choices[0].message.content

1# Install: pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client
2
3from google.oauth2.credentials import Credentials
4from google_auth_oauthlib.flow import InstalledAppFlow
5from googleapiclient.discovery import build
6import base64
7
8SCOPES = ['https://www.googleapis.com/auth/gmail.modify']
9
10
11def authenticate_gmail():
12    """Authenticate with Gmail API."""
13    flow = InstalledAppFlow.from_client_secrets_file(
14        'credentials.json', SCOPES)
15    creds = flow.run_local_server(port=0)
16    return build('gmail', 'v1', credentials=creds)
17
18
19def get_unread_emails(service, max_results=10):
20    """Fetch unread emails from Gmail."""
21    try:
22        results = service.users().messages().list(
23            userId='me',
24            q='is:unread',
25            maxResults=max_results
26        ).execute()
27        
28        messages = results.get('messages', [])
29        
30        emails = []
31        for msg in messages:
32            message = service.users().messages().get(
33                userId='me',
34                id=msg['id'],
35                format='full'
36            ).execute()
37            
38            # Parse email details
39            headers = message['payload']['headers']
40            subject = next(h['value'] for h in headers if h['name'] == 'Subject')
41            sender = next(h['value'] for h in headers if h['name'] == 'From')
42            
43            # Get body
44            if 'parts' in message['payload']:
45                body = message['payload']['parts'][0]['body'].get('data', '')
46            else:
47                body = message['payload']['body'].get('data', '')
48            
49            body = base64.urlsafe_b64decode(body).decode('utf-8')
50            
51            emails.append({
52                'id': msg['id'],
53                'subject': subject,
54                'sender': sender,
55                'body': body
56            })
57        
58        return emails
59    
60    except Exception as e:
61        print(f"❌ Error fetching emails: {e}")
62        return []
63
64
65def send_gmail_reply(service, original_id, reply_text):
66    """Send a reply to an email."""
67    try:
68        # Create reply message
69        message = service.users().messages().get(
70            userId='me',
71            id=original_id
72        ).execute()
73        
74        thread_id = message['threadId']
75        
76        # TODO: Implement full reply sending logic
77        # This requires proper MIME formatting
78        
79        print(f"✅ Reply sent to thread {thread_id}")
80    
81    except Exception as e:
82        print(f"❌ Error sending reply: {e}")

1#!/usr/bin/env python3
2"""
3AI Email Assistant - Automate email analysis, prioritization, and responses.
4"""
5
6import openai
7import os
8from datetime import datetime
9
10
11class AIEmailAssistant:
12    """AI-powered email management system."""
13    
14    def __init__(self, api_key, style_guide=None):
15        """
16        Initialize the assistant.
17        
18        Args:
19            api_key: OpenAI API key
20            style_guide: Your writing style profile
21        """
22        openai.api_key = api_key
23        self.style_guide = style_guide
24    
25    def analyze_email(self, email):
26        """Analyze email for priority and content."""
27        prompt = f"""Analyze this email quickly:
28
29From: {email['sender']}
30Subject: {email['subject']}
31Body: {email['body']}
32
33Return JSON with: urgency (high/medium/low), category, action_required, sentiment
34"""
35        
36        response = openai.ChatCompletion.create(
37            model="gpt-3.5-turbo",
38            messages=[{"role": "user", "content": prompt}],
39            temperature=0.3,
40            max_tokens=150
41        )
42        
43        return response.choices[0].message.content
44    
45    def draft_response(self, email, context=""):
46        """Generate response draft."""
47        style_instruction = ""
48        if self.style_guide:
49            style_instruction = f"\n\nMatch this writing style:\n{self.style_guide}"
50        
51        prompt = f"""Draft a professional email response to:
52
53{email['body']}
54
55Context: {context}{style_instruction}
56
57Write a concise, helpful response (under 150 words).
58"""
59        
60        response = openai.ChatCompletion.create(
61            model="gpt-4",
62            messages=[{"role": "user", "content": prompt}],
63            temperature=0.7,
64            max_tokens=250
65        )
66        
67        return response.choices[0].message.content
68    
69    def prioritize_inbox(self, emails):
70        """Sort emails by urgency."""
71        scored_emails = []
72        
73        for email in emails:
74            analysis = self.analyze_email(email)
75            
76            # Simple scoring (in real implementation, parse JSON)
77            if 'high' in analysis.lower():
78                score = 3
79            elif 'medium' in analysis.lower():
80                score = 2
81            else:
82                score = 1
83            
84            scored_emails.append((email, score, analysis))
85        
86        # Sort by score (highest first)
87        scored_emails.sort(key=lambda x: x[1], reverse=True)
88        
89        return scored_emails
90    
91    def process_inbox(self, emails, auto_draft=True):
92        """
93        Process entire inbox with AI.
94        
95        Args:
96            emails: List of email dictionaries
97            auto_draft: Whether to generate response drafts
98        
99        Returns:
100            List of processed emails with analysis and drafts
101        """
102        processed = []
103        
104        # Prioritize
105        prioritized = self.prioritize_inbox(emails)
106        
107        for email, priority, analysis in prioritized:
108            result = {
109                'email': email,
110                'priority': priority,
111                'analysis': analysis,
112                'draft': None
113            }
114            
115            # Generate draft for high priority emails
116            if auto_draft and priority >= 2:
117                result['draft'] = self.draft_response(email)
118            
119            processed.append(result)
120        
121        return processed
122
123
124def main():
125    """Example usage."""
126    
127    # Initialize assistant
128    assistant = AIEmailAssistant(
129        api_key=os.getenv("OPENAI_API_KEY")
130    )
131    
132    # Example emails
133    test_emails = [
134        {
135            'sender': 'client@example.com',
136            'subject': 'Question about invoice',
137            'body': 'Hi, I noticed the invoice amount is different from our quote. Can you clarify?'
138        },
139        {
140            'sender': 'newsletter@company.com',
141            'subject': 'Weekly Newsletter',
142            'body': 'Check out our latest blog posts and updates!'
143        },
144        {
145            'sender': 'urgent@partner.com',
146            'subject': 'URGENT: Contract needs signature today',
147            'body': 'The contract expires today. Please review and sign ASAP.'
148        }
149    ]
150    
151    # Process inbox
152    print("🤖 Processing inbox with AI...\n")
153    processed = assistant.process_inbox(test_emails)
154    
155    for item in processed:
156        print(f"Priority: {'🔴' if item['priority'] == 3 else '🟡' if item['priority'] == 2 else '🟢'}")
157        print(f"From: {item['email']['sender']}")
158        print(f"Subject: {item['email']['subject']}")
159        print(f"Analysis: {item['analysis'][:100]}...")
160        
161        if item['draft']:
162            print(f"\n📝 DRAFT RESPONSE:\n{item['draft']}\n")
163        
164        print("-" * 60 + "\n")
165
166
167if __name__ == "__main__":
168    main()

1def needs_human_review(email, analysis):
2    """Determine if email needs human review before auto-responding."""
3    
4    high_stakes_keywords = [
5        'legal', 'contract', 'lawsuit', 'confidential',
6        'termination', 'complaint', 'urgent', 'emergency'
7    ]
8    
9    # Check for high-stakes content
10    content = (email['subject'] + ' ' + email['body']).lower()
11    if any(keyword in content for keyword in high_stakes_keywords):
12        return True
13    
14    # Check if from VIP sender
15    vip_domains = ['ceo@', 'board@', 'legal@']
16    if any(domain in email['sender'] for domain in vip_domains):
17        return True
18    
19    return False

1# Use GPT-3.5 for analysis (cheaper)
2# Use GPT-4 only for response generation (better quality)
3
4def smart_model_selection(task):
5    """Choose appropriate model based on task."""
6    if task in ['analyze', 'categorize', 'prioritize']:
7        return 'gpt-3.5-turbo'
8    elif task in ['draft', 'summarize']:
9        return 'gpt-4'
10    return 'gpt-3.5-turbo'