In diesem Leitfaden erkläre ich, wie man ein automatisiertes System erstellt, das Kundenanfragen verarbeitet, personalisierte KI-/LLM-Antworten generiert und E-Mails ohne menschliches Eingreifen versendet.
Die effiziente Bearbeitung von Kundenanfragen ist für jedes Unternehmen entscheidend. Doch jede E-Mail manuell zu beantworten, ist zeitaufwendig und führt oft zu Inkonsistenzen. Viele Unternehmen kämpfen damit, die Balance zwischen personalisierter Kommunikation und Skalierbarkeit zu finden – insbesondere bei Anfragen, die differenzierte Antworten erfordern. KI-gesteuerte Automatisierung bietet nun eine Möglichkeit, diesen Prozess zu optimieren: Sie stellt sicher, dass Kundenanfragen zeitnah und individuell beantwortet werden, während wertvolle menschliche Ressourcen freigesetzt werden.
In dieser Anleitung zeige ich Ihnen, wie Sie ein vollständig automatisiertes System zur Beantwortung von Kunden-E-Mails implementieren können – ohne dabei die Qualität und den persönlichen Charakter der Kommunikation zu verlieren.
Inhalt
- Die Vorgeschichte: Vor fünf Jahren wäre das nicht möglich gewesen!
- Vorbereitung: Checkliste für Ihr KI-gestütztes E-Mail-System
- Script #1: Der E-Mail-Parser
- Script #2: Der Antwort-Generator
- Zwischenschritt: Das richtige Modell wählen oder ein eigenes trainieren
- Script #3: Der Email-Versand
- Zusammenführung mit Cron-Jobs
- Wichtige Hinweise zum Thema Sicherheit
- Zusammenfassung & Ergebnisse
Die Vorgeschichte: Vor fünf Jahren wäre das nicht möglich gewesen!
Vor einigen Jahren kam ein Kunde auf mich zu und fragte, ob ich Antworten auf Anfragen, die über das Kontaktformular seiner Website eingehen, automatisieren könnte. Nach eingehender Analyse war meine Antwort: Nein.
Ich hatte zuvor bereits mit dem Kunden zusammengearbeitet, um Vorlagen für die Erstantworten zu entwickeln, und kannte die Anforderungen daher genau. Das Unternehmen bietet ein hochgradig personalisierbares Produkt an. Das Kontaktformular ermöglicht es potenziellen Käufern, aus zahlreichen Optionen zu wählen und zusätzliche Wünsche oder Fragen zu hinterlassen. Diese Faktoren beeinflussen die Antworten stark, sodass eine vollständige Automatisierung damals nicht praktikabel war.
Ein Beispiel: Die Schreibweise unterscheidet sich zwischen männlichen und weiblichen Kunden. Einige Kunden erwähnen persönliche Details, auf die eine sorgfältige Antwort höflich eingehen sollte. Bei besonderen Fällen, etwa wenn das Produkt als Geschenk gedacht ist, sind spezifische Formulierungen erforderlich. Obwohl diese „Erstkontakt“-E-Mails zu 99 % auf Vorlagen basieren, war das korrekte Zusammenstellen der Inhalte damals zu komplex für eine rein geskriptete Lösung.
Eine vollständige Automatisierung hätte damals eine umfassende Neugestaltung des Kontaktformulars erfordert – was sich negativ auf die bestehende, bereits erfolgreiche Customer Journey hätte auswirken können. Meine Empfehlung war daher, die Beantwortung weiterhin in menschlicher Hand zu belassen.
Heute ist das anders: Dank der Fortschritte in generativer KI können wir nun personalisierte E-Mails automatisieren und gleichzeitig die hohe Qualität der Kundenkommunikation beibehalten, für die mein Kunde bekannt ist. Dieser Artikel erklärt, wie man ein System aufsetzt, das eingehende E-Mails verarbeitet, sie an GPT-4 (oder ein anderes LLM-Modell) übergibt und vollständig individualisierte Antworten generiert.
Vorbereitung: Checkliste für Ihr KI-gestütztes E-Mail-System
Um unser System einzurichten, haben wir drei verschiedene Python-Skripte entwickelt, die durch Cron-Jobs ausgelöst werden. Diese stellen sicher, dass Kundenanfragen nicht zu schnell beantwortet werden (Mindestverzögerung: 1 Stunde 30 Minuten) und keine E-Mails außerhalb der Geschäftszeiten (8:30 PM – 7:30 AM) versendet werden.
Bevor wir die Skripte Schritt für Schritt durchgehen, hier die benötigten Ressourcen:
Systemanforderungen / Checkliste
- Ein Linux-basiertes Hosting-Umfeld, das Cron-Jobs ausführen kann (mein Kunde nutzt All-inkl.com)
- SSH-Zugriff auf den Server (verwenden Sie Putty, wenn Sie Windows nutzen)
- FTP-Zugang (z. B. FileZilla)
- IMAP- und SMTP-Konten & Server-Zugangsdaten
- Eine MySQL-Datenbank mit einer Tabelle, die Felder für jedes Formularfeld enthält, plus id, status, parsed_timestamp und sent_timestamp
- OpenAI API-Schlüssel
- Python 3.12 oder neuer
- Erforderliche Python-Bibliotheken: openai, pymysql, imaplib, email, beautifulsoup4, dotenv
Stellen Sie sicher, dass Sie Zugriff auf all diese Ressourcen haben, bevor Sie mit der Einrichtung der Automatisierungsskripte beginnen.
Script #1: Der E-Mail-Parser
Der erste Schritt besteht darin, neue Kundenanfragen im Posteingang zu erkennen und für die weitere Verarbeitung vorzubereiten. Dafür benötigen wir keine KI – ein einfaches Python-Skript reicht aus, email_parser.py.
Das Skript macht folgendes:
- Verbindet sich mit dem E-Mail-Server über imaplib
- Prüft E-Mails mit einer bestimmten Betreffzeile
- Extrahiert die Daten aus den Formularfeldern
- Speichert die Daten in MySQL mit dem Status „new“
- Erfasst den Zeitstempel in parsed_timestamp
- Verschiebt verarbeitete E-Mails in einen separaten Ordner
- Implementiert grundlegendes Fehlerhandling und Logging
Beispiel Code Snipped für Datenextrahierung:
def parse_email_content(raw_email):
"""Parses the content of the email and extracts required fields."""
msg = email.message_from_bytes(raw_email)
body = None
if msg.is_multipart():
for part in msg.walk():
if part.get_content_type() == "text/html":
html_content = part.get_payload(decode=True).decode()
body = BeautifulSoup(html_content, "html.parser")
break
else:
body = BeautifulSoup(msg.get_payload(decode=True).decode(), "html.parser")
# Extract data
parsed_data = {
"Name": clean_text(body.find(["strong", "b"], string="Name")) or "Unknown",
"Phone": clean_text(body.find(["strong", "b"], string="Phone")) or "Unknown",
"Color": clean_text(body.find(["strong", "b"], string="Color")) or "Unknown",
"Version": clean_text(body.find(["strong", "b"], string="I’m interested in version")) or "Unknown",
"Comment": clean_text(body.find(["strong", "b"], string="Comment")) or "",
}
return parsed_data Natürlich müssen Sie Ihr Skript an die spezifischen Anforderungen Ihres Anwendungsfalls anpassen. Später werden wir Cron-Jobs einrichten, um das Skript in regelmäßigen Abständen auszuführen. Zu Testzwecken können Sie es jedoch direkt in der Shell mit folgendem Befehl ausführen:
python3 email_parser.pySobald unser erstes Skript läuft, können wir uns dem zweiten Skript zuwenden, das die Datenbank auf neue Einträge überprüft und einen LLM-Agenten dazu veranlasst, entsprechende Antworten zu generieren.
Script #2: Der Antwort-Generator
Das zweite Skript — response_generator.py — ist das Herzstück unseres Systems, da es die Erstellung der Antworten verwaltet, die später versendet werden sollen. Dies ist auch der Teil des Systems, der vermutlich die meiste Feinabstimmung erfordert, da wir konsistent hochwertige Antworten sicherstellen müssen.
Funktionsweise des Skripts:
- Es überprüft die Datenbank auf Einträge mit dem Status „new“ und extrahiert die entsprechenden Daten.
- Die Daten werden in eine Prompt-Vorlage eingebettet, die spezifische Regeln, Anweisungen und Templates enthält.
- Dieser Prompt wird über die OpenAI-API an GPT-4 gesendet (die E-Mail-Adresse wird dabei ausgeschlossen, da sie für die Antwortgenerierung nicht erforderlich ist).
- Die generierte Antwort wird in der Datenbank gespeichert.
- Der Eintrag in der Datenbank wird auf „pending“ aktualisiert.
Der Prompt ist der kritischste Teil. In unserem Anwendungsfall war es notwendig, verschiedene Vorlagen und Beispiele für unterschiedliche Szenarien zu integrieren sowie eine ausführliche Liste von Regeln zu definieren. Da API-Kosten eine Rolle spielen, sollte der Prompt so kompakt wie möglich sein, während er gleichzeitig präzise genug bleibt, um die gewünschten Ergebnisse zu erzielen.
GPT-4 kann mit der folgenden Funktion angesprochen werden, die einen statischen Prompt mit dynamischen Anfragedaten kombiniert:
def generate_expanded_prompt(email_data):
# Customer Request Data
customer_request_data = f"""
Customer Request Data:
- Name: {email_data.get('name', 'Unknown')}
- Product Preference: {email_data.get('option', 'Unspecified')}
- Special Request: {email_data.get('comments', 'None')}
"""
# Refinement Instructions
refinement_instructions = """
Here come your instructions. E.g:
- Ensure a warm, friendly, and professional tone.
- Include all provided customer details in a structured manner.
- Adhere to approved templates and response styles.
- Conclude with a polite closing and an invitation for further questions.
"""
# Final Prompt
prompt = f"""
ROLE:
You are an AI assistant responsible for drafting customer service emails.
{customer_request_data}
RESPONSE GUIDELINES:
{refinement_instructions}
TASK:
Generate a well-structured email response based on the above details.
"""
return promptDieser Teil sendet den strukturierten Prompt an GPT-4 und weist es an, eine Kundenservice-E-Mail basierend auf den bereitgestellten Details zu generieren. Zudem werden Parameter für die Antwortlänge (max_tokens) und das Kreativitätsniveau (temperature) für eine optimale Ausgabe festgelegt.
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "You are a professional customer service assistant."},
{"role": "user", "content": prompt}
],
max_tokens=1000,
temperature=0.7
)Sie sollten die Ergebnisse gründlich testen, bevor Sie fortfahren, da Ihr Prompt möglicherweise Anpassungen benötigt. Füllen Sie die Datenbank mit Beispielanfragen, die alle möglichen Szenarien abdecken, führen Sie das Skript aus und überprüfen Sie die Ergebnisse. Verfeinern Sie den Prompt und die Anweisungen so lange, bis die Ergebnisse zu 100 % zufriedenstellend sind.
Natürlich hat auch die Wahl des KI-Modells Einfluss auf die Ergebnisse. Mehr dazu im nächsten Abschnitt.
Zwischenschritt: Das richtige Modell wählen oder ein eigenes trainieren
Sie müssen nicht zwingend GPT-4 für dieses System verwenden. Jedes Modell mit API-Anbindung kann genutzt werden. In diesem speziellen Anwendungsfall hätte es sich gelohnt, ein eigenes Modell zu trainieren, da ausreichend Trainingsdaten vorhanden waren.
Allerdings erlaubt OpenAI derzeit nur das Fine-Tuning von GPT-3.5 Turbo und kleineren Modellen. Aufgrund der Komplexität unserer Aufgabe und der Anforderungen an sprachliche Präzision war GPT-3.5 Turbo keine Option.
Falls Sie ausreichend Trainingsdaten haben, können Sie Ihr eigenes Modell mit diesen Schritten fine-tunen:
- Trainingsdaten im JSONL-Format vorbereiten und auf den Server hochladen.
- Daten mit folgendem Befehl validieren: openai tools fine_tunes.prepare_data -f dataset.jsonl
- Datensatz zu OpenAI hochladen: openai api files.create -f dataset.jsonl -p „fine-tune“
- Fine-Tuning starten: openai api fine_tuning.jobs.create -t „file-id“ -m „model-name“ (e.g., gpt-3.5-turbo)
- Status des Trainings abrufen: openai api fine_tuning.jobs.list
Sobald das Training abgeschlossen ist (meist innerhalb weniger Stunden), erhalten Sie eine Modell-ID, die Sie im Skript verwenden können, indem Sie model=“gpt-4″ durch Ihre Modell-ID ersetzen.
Hinweis zu API-Kosten
Die Kosten für API-Aufrufe variieren je nach Modell erheblich. Zum Beispiel:
- GPT-4o: $2,50 pro 1M Eingabetokens und $10,00 pro 1M Ausgabetokens
- GPT-4o Mini: $0,15 pro 1M Eingabetokens und $0,60 pro 1M Ausgabetokens
Aufgrund unseres detaillierten Prompts belaufen sich die API-Kosten für GPT-4 auf knapp $0,09 pro Anfrage. Mit GPT-4o Mini sind die Kosten weniger als 10 % davon, bei immer noch sehr guten Ergebnissen.
Da diese E-Mails den ersten Kundenkontakt darstellen, wollte mein Kunde keine Abstriche bei der Qualität machen. Die manuelle Beantwortung der Anfragen nahm täglich mehrere Arbeitsstunden in Anspruch, sodass sich selbst einige Dollar pro Tag für die API-Nutzung lohnen, wenn die Ergebnisse überzeugen.
Script #3: Der Email-Versand
Der Antwortgenerator stellt sicher, dass neue Datenbankeinträge geprüft und Antworten generiert werden. Anschließend wird der Status auf „pending“ aktualisiert.
Falls eine menschliche Überprüfung gewünscht ist, könnte hier ein manueller Schritt hinzugefügt werden, in dem Mitarbeiter die Antworten prüfen, bevor sie als versandfertig markiert werden. In unserem Fall vertrauen wir jedoch auf GPT-4 und setzen auf maximale Automatisierung.
Um dies zu erreichen, benötigen wir ein drittes Skript – email_sender.py.
Dieses Skript führt folgende Aufgaben aus:
- Prüft die Datenbank auf Einträge mit dem Status „pending“.
- Formatiert die Antworten (Farbe, Schriftart und Größe).
- Fügt die Signatur hinzu.
- Ergänzt die Betreffzeile.
- Sendet die E-Mail.
- Speichert eine Kopie im Gesendet-Ordner.
- Aktualisiert den Datenbankeintrag auf „answered“.
Dieses Skript ist relativ einfach und war schnell geschrieben. Der wichtigste Punkt ist, sicherzustellen, dass die Formatierung korrekt ist und keine Informationen verloren gehen (einschließlich Zeilenumbrüche).
Zusammenführung mit Cron-Jobs
Nun, da unsere drei Skripte ihren jeweiligen Zweck erfüllen, können wir Cron-Jobs verwenden, um das gesamte System nach unseren Anforderungen zu automatisieren.
Wir haben es so eingerichtet, dass:
- Der Antwortgenerator jede volle Stunde ausgeführt wird.
- Der E-Mail-Parser einmal pro Stunde um 15 Minuten nach der vollen Stunde läuft.
- Der E-Mail-Versand einmal pro Stunde um 45 Minuten nach der vollen Stunde ausgeführt wird.
Diese Konfiguration stellt sicher, dass zwischen dem Empfang einer Anfrage und der Antwort mindestens 90 Minuten liegen, um eine zu schnelle Beantwortung zu vermeiden. Zudem wird der E-Mail-Versand nur von Montag bis Samstag zwischen 7:30 Uhr und 20:30 Uhr ausgeführt, sodass Kunden keine Nachrichten zu ungewöhnlichen Zeiten erhalten.
Hier ist die Cron-Job-Konfiguration:
# Run email parser every hour at 15 minutes past
15 * * * * /path/to/email_parser.py
# Run response generator every hour at 00 minutes past
0 * * * * /path/to/response_generator.py
# Run email sender every hour at 45 minutes past
45 * * * * /path/to/email_sender.py
# Run email sender only Monday to Saturday from 07:30 to 20:30
30 7-20 * * 1-6 /path/to/email_sender.pyDiese Konfiguration stellt sicher, dass unsere automatisierten E-Mails nicht nur qualitativ hochwertig, sondern auch zeitlich optimal abgestimmt sind. Abhängig vom Anwendungsfall kann es jedoch sinnvoll sein, entweder kürzere oder längere Verzögerungen zwischen dem Empfang einer Anfrage und der Antwort einzuführen.
Wichtige Hinweise zum Thema Sicherheit
Einige wichtige Sicherheitsaspekte sollten beachtet werden. Erstens können LLMs Halluzinationen erzeugen, und egal wie gründlich Sie Ihr System testen – unerwartete Antworten sind immer möglich.
Im Hinblick auf Cybersicherheit gibt es einige wesentliche Maßnahmen, um die Sicherheit Ihres Projekts zu verbessern:
- API-Schlüssel & Zugangsdaten schützen: Speichern Sie vertrauliche Schlüssel und Passwörter (OpenAI, E-Mail, Datenbank) in einer .env-Datei, niemals direkt im Code.
- Dateiberechtigungen korrekt setzen: Verwenden Sie chmod 600 .env, um den Zugriff zu beschränken.
- Datenbankzugriff auf das notwendige Minimum beschränken: Gewähren Sie nur die erforderlichen Berechtigungen.
- Datenbankeingaben validieren: Nutzen Sie parametrisierte Abfragen, um SQL-Injektionen zu verhindern.
- E-Mail-Verarbeitung absichern: Entfernen Sie HTML und Skripte mit BeautifulSoup, um XSS-Angriffe zu vermeiden.
- IMAP-Anfragen begrenzen: Verhindern Sie eine Serverüberlastung durch Rate-Limiting.
- SSH-Zugriff einschränken: Nutzen Sie key-basierte Authentifizierung und deaktivieren Sie den Root-Login.
- Firewall aktivieren: Verwenden Sie ufw oder iptables, um den Zugriff auf notwendige Ports zu beschränken.
- Software regelmäßig aktualisieren: Führen Sie apt update && apt upgrade regelmäßig aus.
- Fehlerprotokolle sorgfältig verwalten: Vermeiden Sie es, Passwörter oder sensible Daten zu protokollieren.
- API-Rate-Limits implementieren: Verhindern Sie übermäßige oder missbräuchliche Anfragen.
- OpenAI-API-Zugriff beschränken: Erlauben Sie nur notwendige Modelle und Endpunkte.
Diese Maßnahmen sind nur Empfehlungen, und ich übernehme keine Verantwortung für eventuelle Probleme oder Sicherheitslücken, die bei der Umsetzung dieser Softwarearchitektur entstehen können. 😉
Zusammenfassung & Ergebnisse
In diesem Beitrag haben wir gezeigt, wie sich komplexe E-Mail-Antworten mit KI automatisieren lassen, indem wir ein System entwickelt haben, das:
- Kundenanfragen verarbeitet
- Personalisierte Antworten generiert
- E-Mails vollständig automatisiert versendet
Wir haben außerdem Prompt-Engineering, Modellauswahl, API-Kosten und Sicherheitsmaßnahmen behandelt, um ein zuverlässiges und sicheres KI-gestütztes E-Mail-System aufzubauen.
Das System ist nun seit mehreren Wochen live, und mein Kunde ist sehr zufrieden. Die Antwortrate (also der Anteil an Kunden, die auf die erste Antwort-E-Mail reagieren) ist sogar leicht gestiegen – vermutlich, weil die Antworten besser getimt sind als zuvor.
Darüber hinaus sind die Zeitersparnisse erheblich: Mein Kunde bearbeitet täglich 20-25 Anfragen, und jede manuelle Antwort nahm 5-10 Minuten in Anspruch. Dank der Automatisierung werden jetzt mehrere Stunden pro Tag eingespart, sodass sich das Team auf wichtigere Aufgaben konzentrieren kann.
Der nächste Schritt? Noch mehr E-Mail-Prozesse automatisieren – zum Beispiel automatisierte Follow-ups. Dieses und viele weitere Features könnten auf der beschriebenen Systemarchitektur aufgebaut werden. Ich bin gespannt, wie viel mehr repetitive Arbeit wir an ein LLM auslagern können.
Falls möglich, werde ich hier in Zukunft weitere Einblicke teilen. Bleiben Sie also dran oder schauen Sie bald wieder vorbei!
Interessiert daran, KI-gestützte E-Mail-Automatisierung in Ihrem Unternehmen umzusetzen? Kontaktieren Sie mich für eine Beratung!
