Smart Email Labeling Agent

1
"""
2
Smart Email Labeling Agent
3
4
An AI-powered email classification agent that automatically analyzes incoming
5
emails across multiple dimensions and applies appropriate labels.
6
"""
7
8
import os
9
import json
10
import time
11
from dotenv import load_dotenv
12
13
load_dotenv()
14
15
from flask import Flask, request, Response
16
import ngrok
17
from agentmail import AgentMail
18
from openai import OpenAI
19
20
# Configuration
21
PORT = int(os.getenv("PORT", "8080"))
22
INBOX_USERNAME = os.getenv("INBOX_USERNAME", "smart-labels")
23
WEBHOOK_DOMAIN = os.getenv("WEBHOOK_DOMAIN")
24
25
# Initialize
26
app = Flask(__name__)
27
client = AgentMail()
28
openai_client = OpenAI()
29
30
31
def setup_agentmail():
32
    """Create inbox and webhook with idempotency."""
33
    # Create inbox
34
    try:
35
        inbox = client.inboxes.create(
36
            username=INBOX_USERNAME,
37
            client_id=f"{INBOX_USERNAME}-inbox"
38
        )
39
    except Exception as e:
40
        if "already exists" in str(e).lower():
41
            inbox_id = f"{INBOX_USERNAME}@agentmail.to"
42
            class SimpleInbox:
43
                def __init__(self, inbox_id):
44
                    self.inbox_id = inbox_id
45
            inbox = SimpleInbox(inbox_id)
46
        else:
47
            raise
48
49
    # Start ngrok
50
    listener = ngrok.forward(PORT, domain=WEBHOOK_DOMAIN, authtoken_from_env=True)
51
52
    # Create webhook
53
    try:
54
        client.webhooks.create(
55
            url=f"{listener.url()}/webhook/agentmail",
56
            event_types=["message.received"],
57
            client_id=f"{INBOX_USERNAME}-webhook"
58
        )
59
    except Exception as e:
60
        if "already exists" not in str(e).lower():
61
            raise
62
63
    print(f"Ready: {inbox.inbox_id}\n")
64
    return inbox, listener
65
66
67
def analyze_email(subject, content):
68
    """Use AI to classify email across multiple dimensions with retry logic."""
69
    valid_values = {
70
        "sentiment": {"positive", "neutral", "negative"},
71
        "category": {"question", "complaint", "feature-request", "bug-report", "praise"},
72
        "priority": {"urgent", "high", "normal", "low"},
73
        "department": {"sales", "support", "billing", "technical"}
74
    }
75
76
    for attempt in range(1, 4):
77
        try:
78
            if attempt > 1:
79
                time.sleep(1)
80
81
            response = openai_client.chat.completions.create(
82
                model="gpt-4o-mini",
83
                messages=[
84
                    {
85
                        "role": "system",
86
                        "content": "You are an expert email classifier. Analyze emails and return structured classifications."
87
                    },
88
                    {
89
                        "role": "user",
90
                        "content": f"""Analyze this email across 4 dimensions:
91
92
                        Subject: {subject}
93
                        Content: {content}
94
95
                        Classify into:
96
                        1. sentiment: positive | neutral | negative
97
                        2. category: question | complaint | feature-request | bug-report | praise
98
                        3. priority: urgent | high | normal | low
99
                        4. department: sales | support | billing | technical
100
101
                        Consider:
102
                        - Sentiment: Overall tone and emotion
103
                        - Category: Primary intent of the email
104
                        - Priority: Urgency indicators (ASAP, urgent, immediately, deadline mentions, emergency)
105
                        - Department: Best team to handle this
106
107
                        Return ONLY valid JSON with these exact keys: sentiment, category, priority, department.
108
                        Example: {{"sentiment": "positive", "category": "question", "priority": "normal", "department": "sales"}}
109
                        """
110
                    }
111
                ],
112
                response_format={"type": "json_object"},
113
                temperature=0.3
114
            )
115
116
            # Parse and validate
117
            result = json.loads(response.choices[0].message.content)
118
119
            required_keys = ["sentiment", "category", "priority", "department"]
120
            missing_keys = [key for key in required_keys if key not in result]
121
            if missing_keys:
122
                raise ValueError(f"Missing keys: {missing_keys}")
123
124
            invalid_values = []
125
            for dimension, value in result.items():
126
                if dimension in valid_values and value not in valid_values[dimension]:
127
                    invalid_values.append(f"{dimension}={value}")
128
129
            if invalid_values:
130
                raise ValueError(f"Invalid values: {', '.join(invalid_values)}")
131
132
            return result
133
134
        except Exception as e:
135
            if attempt == 3:
136
                raise Exception(f"AI classification failed: {e}")
137
138
139
def apply_labels(inbox_id, message_id, classifications):
140
    """Apply labels based on classification results."""
141
    labels = [
142
        f"{classifications['sentiment']}",
143
        f"{classifications['category']}",
144
        f"{classifications['priority']}",
145
        f"{classifications['department']}"
146
    ]
147
148
    # Try batch first
149
    try:
150
        client.inboxes.messages.update(
151
            inbox_id=inbox_id,
152
            message_id=message_id,
153
            add_labels=labels
154
        )
155
        for label in labels:
156
            print(f"  ✓ {label}")
157
        return
158
    except Exception:
159
        pass
160
161
    # Try individually
162
    successful = []
163
    for label in labels:
164
        try:
165
            client.inboxes.messages.update(
166
                inbox_id=inbox_id,
167
                message_id=message_id,
168
                add_labels=[label]
169
            )
170
            successful.append(label)
171
            print(f"  ✓ {label}")
172
        except Exception:
173
            print(f"  ✗ {label}")
174
175
    if not successful:
176
        raise Exception("Failed to apply labels")
177
178
179
@app.route('/webhook/agentmail', methods=['POST'])
180
def receive_webhook():
181
    """Webhook endpoint to receive incoming email notifications."""
182
    try:
183
        payload = request.json
184
        event_type = payload.get('type') or payload.get('event_type')
185
186
        # Ignore outgoing messages
187
        if event_type == 'message.sent':
188
            return Response(status=200)
189
190
        message = payload.get('message', {})
191
        message_id = message.get('message_id')
192
        inbox_id = message.get('inbox_id')
193
        from_field = message.get('from_', '') or message.get('from', '')
194
195
        # Validate required fields
196
        if not message_id or not inbox_id or not from_field:
197
            return Response(status=200)
198
199
        # Extract sender email
200
        if '<' in from_field and '>' in from_field:
201
            sender_email = from_field.split('<')[1].split('>')[0].strip()
202
        else:
203
            sender_email = from_field.strip()
204
205
        subject = message.get('subject', '(no subject)')
206
        email_body = message.get('text', '') or message.get('body', '') or message.get('html', '')
207
208
        # Log
209
        print(f"\n📧 {sender_email}: {subject}")
210
211
        # Analyze
212
        classifications = analyze_email(subject, email_body)
213
214
        print(f"  Sentiment: {classifications['sentiment']}")
215
        print(f"  Category: {classifications['category']}")
216
        print(f"  Priority: {classifications['priority']}")
217
        print(f"  Department: {classifications['department']}")
218
219
        # Apply labels
220
        apply_labels(inbox_id, message_id, classifications)
221
        print("Done\n")
222
223
    except Exception as e:
224
        print(f"Error: {e}\n")
225
226
    return Response(status=200)
227
228
229
if __name__ == '__main__':
230
    print("SMART EMAIL LABELING AGENT\n")
231
    inbox, listener = setup_agentmail()
232
    print("Waiting for emails...\n")
233
    app.run(port=PORT)