E-Mail-Automatisierung mit KI-Agenten
Was dieser Artikel über E-Mail-Automatisierung mit KI-Agenten behandelt
- Wie Du E-Mail-Automatisierung mit KI-Agenten umsetzt.
- Wie Agenten E-Mails klassifizieren, Antworten entwerfen und weiterleiten.
- Wie Du Spam-Filter, Priorisierung und Auto-Antworten mit lokaler KI baust.
- Praxisbeispiele für Support-Postfächer, Sales-Anfragen und interne Verteilung.
- Best Practices für Sicherheit, Datenschutz und Qualitätssicherung.
Einleitung: E-Mail-Automatisierung mit KI-Agenten verständlich erklärt
E-Mail ist einer der zeitaufwändigsten Kommunikationskanäle. Jeden Tag landen hunderte E-Mails im Postfach: Support-Anfragen, Sales-Leads, Spam, interne Nachrichten. Manuell sortieren, beantworten und weiterleiten kostet Stunden. KI-Agenten können das automatisieren: Sie lesen E-Mails, klassifizieren sie, entwerfen Antworten und leiten sie an die richtige Person weiter. Mit lokaler KI laufen diese Agenten vollständig auf Deiner Hardware, ohne dass E-Mail-Inhalte an Cloud-Provider gehen.
Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die E-Mail-Automatisierung mit KI-Agenten bauen wollen. Du solltest verstehen, was KI-Agenten sind und wie man sie lokal mit Ollama betreibt. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.
Warum brauche ich E-Mail-Automatisierung mit KI-Agenten?
Stell Dir vor, Du betreibst einen Support-Postfach mit 200 E-Mails pro Tag. Jede E-Mail muss gelesen, kategorisiert, beantwortet oder weitergeleitet werden. Manuell kostet das 4-6 Stunden pro Tag. Ein KI-Agent kann das in Minuten erledigen: Er liest, klassifiziert, entwirft Antworten und leitet weiter. Du musst nur noch die Antworten prüfen und abschicken.
E-Mail-Automatisierung ist besonders wertvoll, wenn Du viele E-Mails bekommst, wenn die Klassifikation komplex ist (mehrere Kategorien, mehrdeutige Anfragen) oder wenn Du schnelle Antwortzeiten brauchst.
E-Mail-Automatisierung mit KI-Agenten kurz erklärt
Ein E-Mail-Agent ist ein KI-Agent, der E-Mails verarbeitet. Er liest eingehende E-Mails, klassifiziert sie nach Kategorie, priorisiert sie, entwirft Antworten und leitet sie an die richtige Person weiter. Der Agent nutzt Tools für E-Mail-Zugriff (IMAP/SMTP) und das Sprachmodell für Klassifikation und Antwortentwurf.
Der Kerngedanke lautet: Der Agent ist der Postfach-Assistent, die Tools sind IMAP und SMTP, das Modell ist das Gehirn.
Für wen ist dieser Artikel gedacht?
- Support-Teams, die E-Mail-Volumen automatisieren wollen.
- Sales-Teams, die Leads automatisch klassifizieren und priorisieren wollen.
- Entwicklerinnen und Entwickler, die E-Mail-Agenten bauen.
- Systemadministratoren, die E-Mail-Automatisierung aufsetzen.
Vorkenntnisse in Python, KI-Agenten und Ollama sind erforderlich.
Wichtige Begriffe rund um E-Mail-Automatisierung
- E-Mail-Agent - KI-Agent, der E-Mails verarbeitet. Wann nützlich: für automatisierte E-Mail-Bearbeitung.
- IMAP - Protokoll für E-Mail-Empfang. Wann nützlich: damit der Agent E-Mails liest.
- SMTP - Protokoll für E-Mail-Versand. Wann nützlich: damit der Agent Antworten verschickt.
- Klassifikation - Einteilung in Kategorien. Wann nützlich: um E-Mails zu sortieren.
- Priorisierung - Bewertung der Wichtigkeit. Wann nützlich: um dringende E-Mails zuerst zu bearbeiten.
- Function Calling - Strukturierte KI-Antworten. Wann nützlich: für Klassifikation und Antwortentwurf.
- Ollama - Lokaler Modellserver. Wann nützlich: als Gehirn des Agenten.
- KI-Agenten - Programme, die eigenständig Aufgaben lösen. Wann nützlich: als Basis.
- Node-RED - Visueller Flow-Editor. Wann nützlich: als Alternative für E-Mail-Workflows.
Architektur eines E-Mail-Agenten
Ein typischer E-Mail-Agent besteht aus folgenden Komponenten:
- E-Mail-Empfang: IMAP-Polling oder Webhook für neue E-Mails.
- E-Mail-Parsing: Betreff, Absender, Text extrahieren.
- Klassifikation: Modell ordnet E-Mail einer Kategorie zu.
- Priorisierung: Modell bewertet Wichtigkeit.
- Antwortentwurf: Modell schlägt Antwort vor.
- Weiterleitung: E-Mail wird an richtige Person weitergeleitet.
- Auto-Antwort: Antwort wird verschickt (optional, mit Freigabe).
- Logging: Alle Aktionen werden protokolliert.
E-Mail-Zugriff mit Python
IMAP für Empfang
import imaplib
import email
from email import policy
def fetch_emails(host, user, password, folder="INBOX", limit=10):
mail = imaplib.IMAP4_SSL(host)
mail.login(user, password)
mail.select(folder)
_, data = mail.search(None, "UNSEEN")
email_ids = data[0].split()[:limit]
emails = []
for eid in email_ids:
_, msg_data = mail.fetch(eid, "(RFC822)")
msg = email.message_from_bytes(msg_data[0][1], policy=policy.default)
emails.append({
"from": msg["from"],
"subject": msg["subject"],
"body": get_body(msg),
"date": msg["date"]
})
mail.logout()
return emails
def get_body(msg):
if msg.is_multipart():
for part in msg.walk():
if part.get_content_type() == "text/plain":
return part.get_content()
return msg.get_content()SMTP für Versand
import smtplib
from email.mime.text import MIMEText
def send_email(host, user, password, to, subject, body):
msg = MIMEText(body)
msg["Subject"] = subject
msg["From"] = user
msg["To"] = to
with smtplib.SMTP_SSL(host, 465) as server:
server.login(user, password)
server.send_message(msg)Klassifikation mit Ollama
import requests
def classify_email(subject, body):
prompt = f"""
Klassifiziere diese E-Mail in eine der Kategorien:
- support: Technische Frage oder Problem
- sales: Kaufinteresse oder Angebot
- billing: Rechnung oder Zahlung
- spam: Werbung oder Phishing
- other: Sonstiges
Betreff: {subject}
Inhalt: {body[:1000]}
Antworte nur mit der Kategorie.
"""
response = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": "Du bist ein E-Mail-Klassifikator. Antworte nur mit einer Kategorie."},
{"role": "user", "content": prompt}
],
"stream": False
}
)
return response.json()["message"]["content"].strip().lower()Priorisierung mit Function Calling
def prioritize_email(subject, body):
tools = [
{
"type": "function",
"function": {
"name": "set_priority",
"parameters": {
"type": "object",
"properties": {
"priority": {"type": "string", "enum": ["high", "medium", "low"]},
"reason": {"type": "string"}
},
"required": ["priority", "reason"]
}
}
}
]
response = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": "Bewerte die Priorität dieser E-Mail."},
{"role": "user", "content": f"Betreff: {subject}\nInhalt: {body[:1000]}"}
],
"tools": tools,
"stream": False
}
)
# Tool-Call extrahieren
msg = response.json()["message"]
if msg.get("tool_calls"):
return msg["tool_calls"][0]["function"]["arguments"]
return {"priority": "medium", "reason": "Unbekannt"}Antwortentwurf mit Ollama
def draft_response(subject, body, category):
prompt = f"""
Du bist ein E-Mail-Assistent. Entwirf eine höfliche, professionelle Antwort.
Kategorie: {category}
Betreff: {subject}
E-Mail: {body[:2000]}
Entwirf eine passende Antwort. Wenn Du unsicher bist, schlage vor, die E-Mail an einen Menschen weiterzuleiten.
"""
response = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": "Du bist ein E-Mail-Assistent. Schreibe höfliche, professionelle Antworten."},
{"role": "user", "content": prompt}
],
"stream": False
}
)
return response.json()["message"]["content"]Praxisbeispiel 1: Support-Postfach
Ein Agent, der Support-E-Mails klassifiziert, priorisiert und Antworten entwirft.
def support_agent(emails):
results = []
for email in emails:
# Klassifikation
category = classify_email(email["subject"], email["body"])
# Nur Support-E-Mails bearbeiten
if category != "support":
continue
# Priorisierung
priority = prioritize_email(email["subject"], email["body"])
# Antwortentwurf
draft = draft_response(email["subject"], email["body"], category)
results.append({
"email": email,
"category": category,
"priority": priority,
"draft": draft
})
# Nach Priorität sortieren
results.sort(key=lambda x: {"high": 0, "medium": 1, "low": 2}[x["priority"]["priority"]])
return resultsPraxisbeispiel 2: Sales-Lead-Qualifizierung
Ein Agent, der Sales-Anfragen qualifiziert und an den richtigen Vertriebler weiterleitet.
def sales_agent(email):
# Qualifizierung
qualification = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": """
Qualifiziere diese Sales-Anfrage. Bewerte:
- budget: Budget erkennbar? (yes/no/unknown)
- authority: Entscheider? (yes/no/unknown)
- need: Bedarf erkennbar? (yes/no/unknown)
- timeline: Zeitrahmen erkennbar? (yes/no/unknown)
Antworte als JSON.
"""},
{"role": "user", "content": f"Betreff: {email['subject']}\nInhalt: {email['body'][:2000]}"}
],
"format": "json",
"stream": False
}
).json()["message"]["content"]
# Weiterleitung basierend auf Qualifikation
score = sum(1 for v in json.loads(qualification).values() if v == "yes")
if score >= 3:
return {"action": "forward_to_senior", "qualification": qualification}
elif score >= 1:
return {"action": "forward_to_junior", "qualification": qualification}
else:
return {"action": "auto_reply_info", "qualification": qualification}Praxisbeispiel 3: Spam-Filter mit KI
Ein Agent, der Spam und Phishing erkennt.
def spam_agent(email):
result = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": """
Bewerte, ob diese E-Mail Spam oder Phishing ist.
Kriterien:
- Ungewöhnliche Absender-Domain
- Dringende Handlungsaufforderung
- Links zu unbekannten Seiten
- Fordert persönliche Daten
- Grammatik-/Rechtschreibfehler
Antworte als JSON: {"is_spam": true/false, "confidence": "high/medium/low", "reason": "..."}
"""},
{"role": "user", "content": f"Absender: {email['from']}\nBetreff: {email['subject']}\nInhalt: {email['body'][:2000]}"}
],
"format": "json",
"stream": False
}
).json()["message"]["content"]
return json.loads(result)Sicherheitshinweise
- Keine sensiblen Daten an Cloud: Nutze lokale KI, damit E-Mail-Inhalte nicht an Cloud-Provider gehen.
- Human-in-the-Loop: Für kritische Antworten sollte ein Mensch freigeben. Siehe Menschliche Freigabe.
- Audit Logging: Protokolliere alle Agenten-Aktionen. Siehe Audit Logging.
- Prompt Injection Schutz: E-Mails können Prompt Injection enthalten. Siehe Prompt Injection Schutz.
- Keine Auto-Antworten ohne Freigabe: Automatische Antworten sollten von einem Menschen geprüft werden.
- E-Mail-Authentifizierung: Sichere SMTP/IMAP mit OAuth2 oder App-Passwörtern.
Typische Stolpersteine
- Falsche Klassifikation: Das Modell kann sich irren. Nutze Confidence-Scores und Human-in-the-Loop.
- Prompt Injection: E-Mails können das Modell manipulieren. Schütze den System-Prompt.
- Auto-Antworten ohne Freigabe: Ungeprüfte Antworten können peinlich oder schädlich sein.
- Endlosschleifen: Wenn der Agent auf eigene Antworten reagiert, kann eine Schleife entstehen.
- Kontextlänge: Lange E-Mail-Threads sprengen den Kontext. Nutze Summary Memory.
- Datenschutz: E-Mail-Inhalte sind sensibel. Nutze lokale KI.
Weiterführende Links und Infos zu E-Mail-Automatisierung
- KI-Agenten Grundlagen - Was KI-Agenten sind.
- KI-Agenten mit Ollama - Agenten lokal betreiben.
- Function Calling - Tool-Use-Grundlagen.
- Node-RED - Visuelle Alternative für E-Mail-Workflows.
- Menschliche Freigabe - Human-in-the-Loop.
- Prompt Injection Schutz - Sicherheit bei E-Mail-Inhalten.
- Audit Logging - Nachvollziehbarkeit.
- Recherche-Workflows - Ähnliche Workflow-Architektur.
Key Takeaways:
- E-Mail-Agenten automatisieren Klassifikation, Priorisierung, Antwortentwurf und Weiterleitung.
- IMAP für Empfang, SMTP für Versand, Ollama für Klassifikation und Antworten.
- Praxisbeispiele: Support-Postfach, Sales-Qualifizierung, Spam-Filter.
- Sicherheit: lokale KI, Human-in-the-Loop, Audit Logging, Prompt Injection Schutz.
- Keine Auto-Antworten ohne Freigabe.
FAQ: E-Mail-Automatisierung mit KI-Agenten - Typische Fragen
Was ist ein E-Mail-Agent?
Ein E-Mail-Agent ist ein KI-Agent, der E-Mails automatisch verarbeitet. Er liest, klassifiziert, priorisiert, entwirft Antworten und leitet weiter.
Wie klassifiziert der Agent E-Mails?
Der Agent sendet Betreff und Inhalt an das Sprachmodell mit einem System-Prompt, der die Kategorien definiert. Das Modell antwortet mit der passenden Kategorie.
Sollte ich Auto-Antworten aktivieren?
Vorsicht. Auto-Antworten ohne Freigabe können peinlich oder schädlich sein. Nutze Human-in-the-Loop: Der Agent entwirft, ein Mensch prüft und gibt frei.
Kann ich E-Mail-Agenten lokal betreiben?
Ja. Mit Ollama als Backend läuft das Sprachmodell lokal. E-Mail-Inhalte bleiben auf Deiner Hardware, kein Datenabfluss an Cloud-Provider.
Was ist Prompt Injection bei E-Mails?
Prompt Injection ist, wenn eine E-Mail Inhalte enthält, die das Modell manipulieren sollen, z.B. Ignoriere vorherige Anweisungen. Schütze den System-Prompt und validiere Ausgaben.
Welches Modell eignet sich für E-Mail-Agenten?
Für Klassifikation reicht ein kleines Modell wie llama3.1:8b. Für Antwortentwürfe nutze ein größeres Modell wie qwen2.5:32b oder mistral für bessere Qualität.
Brauche ich IMAP und SMTP?
Ja. IMAP für den Empfang (Agent liest E-Mails), SMTP für den Versand (Agent verschickt Antworten). Beide sind Standard-Protokolle, die alle E-Mail-Provider unterstützen.
Wie sichere ich E-Mail-Agenten ab?
Nutze lokale KI, damit Inhalte nicht in die Cloud gehen. Aktiviere Audit Logging, nutze Human-in-the-Loop für kritische Antworten und schütze vor Prompt Injection.
Kann ich Node-RED statt Python nutzen?
Ja. Node-RED hat IMAP- und SMTP-Nodes und lässt sich mit Ollama verbinden. Siehe Node-RED für KI-Automatisierung für Details.
Was tun bei Endlosschleifen?
Wenn der Agent auf eigene Antworten reagiert, kann eine Schleife entstehen. Nutze Filter, die eigene Antworten ignorieren, und begrenze die Anzahl der Agenten-Schritte.
Quellen und weiterführende Literatur
- Python imaplib - IMAP für Python.
- Python smtplib - SMTP für Python.
- Ollama - Lokaler Modellserver.
- Node-RED - Visuelle Alternative.