Skip to content

FBR65/MailHelper

BranchesTags

Repository files navigation

MailHelper

Eine umfassende Lösung zur Verwaltung und Automatisierung von Outlook-Postfächern mit Exchange-Server-Integration, KI-gestützter Mail-Analyse und erweiterbarem Plugin-System.

Übersicht

MailHelper ist eine moderne Anwendung zur Verwaltung von E-Mails mit folgenden Kernfunktionen:

  • Exchange-Server-Integration: Vollständige Integration mit Microsoft Exchange über Autodiscover
  • Intelligente Mail-Analyse: KI-gestützte Analyse von Mail-Inhalten mit Sentiment-Analyse
  • Automatisches Clustering: Thematische Gruppierung von Mails mit fortschrittlichen Algorithmen
  • Erweiterbares Plugin-System: Flexible Erweiterbarkeit durch Plugins für individuelle Anforderungen
  • Moderne Web-Oberfläche: Intuitive Benutzeroberfläche mit Gradio
  • Sichere Speicherung: Verschlüsselte Speicherung von Zugangsdaten und Mail-Daten

Features

Kernfunktionen

  • Mail-Management: Abrufen, Suchen, Organisieren und Verwalten von E-Mails
  • Automatische Antworten: KI-gestützte Generierung von professionellen Antworten
  • Mail-Clustering: Intelligente Gruppierung von thematisch ähnlichen Mails
  • Benachrichtigungen: Automatische Benachrichtigungen bei wichtigen Mails
  • Plugin-Architektur: Erweiterbar durch individuelle Plugins
  • PST-Datei-Verarbeitung: Analyse und Import von PST-Dateien

Technische Highlights

  • Modulare Architektur: Trennung von Kernfunktionalität und Erweiterungen
  • Multi-LLM-Unterstützung: Unterstützung für verschiedene LLM-Provider (Ollama, OpenAI, ONNX)
  • Asynchrone Verarbeitung: Effiziente Verarbeitung großer Mail-Mengen
  • Caching-System: Intelligentes Caching für verbesserte Performance
  • Sicherheit: Verschlüsselung und sichere Speicherung von Daten
  • Export/Import: Datenexport und -import für Backup und Migration

Installation

Voraussetzungen

  • Python 3.11 oder höher
  • Exchange-Server-Zugangsdaten
  • Optional: LLM-Provider (Ollama, OpenAI, etc.)

Schnellinstallation

# Repository klonen
git clone https://github.com/mailhelper/mailhelper.git
cd mailhelper

# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Abhängigkeiten installieren
pip install -e .

# Konfiguration einrichten
cp config/default.toml ~/.mailhelper/config.toml

# Anwendung starten
python main.py

Detaillierte Anleitung

Für eine detaillierte Installations- und Konfigurationsanleitung siehe INSTALL.md.

Erste Schritte

  1. Anwendung starten:

    python main.py

  2. Web-Oberfläche öffnen: http://localhost:7860

  3. Exchange-Verbindung einrichten:

    • E-Mail-Adresse und Passwort eingeben
    • Verbindung testen
    • Bei Erfolg: Mails werden automatisch geladen

  4. Clustering durchführen:

    • Zum Tab "Clustering" wechseln
    • "Clustering starten" klicken
    • Ergebnisse im Dashboard anzeigen

  5. LLM-Funktionen testen:

    • Mail auswählen
    • "Antwort generieren" klicken
    • Einstellungen anpassen
    • Generierte Antwort prüfen

  6. PST-Dateien verarbeiten:

    • Zum Tab "PST-Datei" wechseln
    • PST-Datei hochladen
    • Analyse durchführen oder Suche starten

Projektstruktur

mailhelper/
├── src/                    # Quellcode
│   ├── core/              # Kernkomponenten
│   │   ├── engine.py       # Haupt-Engine
│   │   ├── plugin_manager.py # Plugin-Management
│   │   ├── mail_service.py # Mail-Dienst
│   │   ├── config.py      # Konfigurationsverwaltung
│   │   └── exceptions.py  # Ausnahmeklassen
│   ├── llm/               # LLM-Integration
│   │   ├── client.py      # LLM-Client
│   │   ├── prompts.py     # Prompt-Management
│   │   ├── providers.py   # LLM-Provider
│   │   └── onnx/          # ONNX-Modelle
│   ├── exchange/          # Exchange-Integration
│   │   ├── connector.py   # Exchange-Connector
│   │   └── models.py      # Mail-Modelle
│   ├── clustering/        # Mail-Clustering
│   │   ├── engine.py      # Clustering-Engine
│   │   └── preprocessing.py # Daten-Präprocessing
│   ├── storage/           # Speicherverwaltung
│   │   ├── manager.py     # Storage-Manager
│   │   └── credentials.py # Zugangsdaten
│   ├── frontend/          # Web-Oberfläche
│   │   ├── app.py         # Hauptanwendung
│   │   ├── components.py  # UI-Komponenten
│   │   └── plugin_interface.py # Plugin-Interface
│   ├── plugins/           # Plugin-Verzeichnis
│   ├── pst/               # PST-Verarbeitung
│   │   ├── pst_reader.py  # PST-Reader
│   │   └── pst_analyzer.py # PST-Analysator
│   └── llm/onnx/          # ONNX-Modelle
├── config/                # Konfigurationsdateien
│   └── default.toml      # Standardkonfiguration
├── docs/                 # Dokumentation
│   ├── README.md         # Hauptdokumentation
│   ├── API.md            # API-Referenz
│   ├── INSTALL.md        # Installationsanleitung
│   └── PLUGIN_DEVELOPMENT.md # Plugin-Entwicklung
├── tests/                # Tests
├── main.py              # Hauptstartdatei
├── pyproject.toml       # Projektmetadaten
└── LICENSE              # AGPLv3-Lizenz

Konfiguration

Die Anwendung wird über TOML-Konfigurationsdateien gesteuert:

# Exchange-Server-Einstellungen
[exchange]
server = "outlook.office365.com"
username = ""
password = ""
use_ssl = true
timeout = 30
autodiscover = true
access_type = "delegate"
server_url = ""

# LLM-Konfiguration
[llm]
provider = "ollama"
base_url = "http://localhost:11434/v1"
model = "qwen2.5:latest"
temperature = 0.5
api_key = ""
max_tokens = ""

# Clustering-Parameter
[clustering]
algorithm = "kmeans"
n_clusters = 5
min_cluster_size = 3
max_cluster_size = 100
similarity_threshold = 0.7
enable_clustering = true
clustering_interval = 24
auto_clustering = true
subject_weight = 0.4
body_weight = 0.6

# Speicher-Einstellungen
[storage]
storage_type = "file"
storage_path = "storage"
base_path = "storage"
backup_enabled = true
backup_interval = 24
encryption_enabled = false
compression_enabled = true
retention_days = 30

# Frontend-Einstellungen
[frontend]
theme = "monochrome"
title = "MailHelper"
port = 7860
share = false
height = 800
width = 1200

# Plugin-Einstellungen
[plugin]
plugin_dir = "plugins"
enabled_plugins = []
disabled_plugins = []
auto_load = true
plugin_timeout = 30

Umgebungsvariablen

  • OPENAI_API_KEY: API-Schlüssel für OpenAI (falls verwendet)
  • MAILHELPER_CONFIG_PATH: Pfad zur Konfigurationsdatei
  • MAILHELPER_LOG_LEVEL: Log-Level (DEBUG, INFO, WARNING, ERROR)

Plugin-Entwicklung

MailHelper bietet ein flexibles Plugin-System zur Erweiterung der Funktionalität:

Plugin-Typen

  • MailProcessorPlugin: Verarbeitet Mails basierend auf Kriterien
  • NotificationPlugin: Sendet Benachrichtigungen
  • Hook-Plugin: Reagiert auf Systemereignisse
  • IntegrationPlugin: Integriert externe Dienste

Plugin-Beispiel

from src.core.plugin_manager import BasePlugin, PluginInfo

class MyPlugin(BasePlugin):
    def initialize(self) -> bool:
        return True
    
    def execute(self, *args, **kwargs) -> Any:
        # Plugin-Logik
        return {"result": "success"}
    
    def get_info(self) -> PluginInfo:
        return PluginInfo(
            name="MyPlugin",
            version="1.0.0",
            description="Mein Plugin",
            author="Mein Name"
        )

Für eine detaillierte Anleitung zur Plugin-Entwicklung siehe docs/PLUGIN_DEVELOPMENT.md.

API-Dokumentation

Die Anwendung bietet eine umfassende API für die Integration in andere Systeme:

  • Core API: Hauptkomponenten und Engine
  • Exchange API: Mail-Operationen und Exchange-Integration
  • LLM API: KI-Funktionen und Textverarbeitung
  • Clustering API: Mail-Clustering und Analyse
  • Storage API: Speicherverwaltung und Datenpersistenz
  • Plugin API: Plugin-Management und Erweiterungen

Die vollständige API-Referenz finden Sie in docs/API.md.

Beispiele

1. Mail-Verarbeitungspipeline

from src.core.engine import MailHelperEngine

# Engine initialisieren
engine = MailHelperEngine()
engine.initialize_all()

# Mails abrufen und verarbeiten
mail_service = engine.storage_manager.mail_service
llm_client = engine.llm_client

# Ungelesene Mails abrufen
unread_mails = mail_service.get_unread_mails(limit=50)

# Jeden Mail mit LLM analysieren
for mail in unread_mails:
    analysis = llm_client.analyze_text(mail.body, "sentiment")
    print(f"Mail: {mail.subject}, Sentiment: {analysis['sentiment']}")

2. Plugin-Nutzung

from src.core.plugin_manager import PluginManager

# Plugin-Manager initialisieren
plugin_manager = PluginManager()

# Plugin abrufen und ausführen
plugin = plugin_manager.get_plugin("MailAnalyzer")
if plugin:
    result = plugin.execute(mail_data)
    print(f"Analyse-Ergebnis: {result}")

3. Custom LLM-Prompts

from src.llm.prompts import PromptManager

# PromptManager initialisieren
prompt_manager = PromptManager()

# Custom Prompt hinzufügen
prompt_manager.add_prompt(
    "response_generation",
    "professional_email",
    "Erstelle eine professionelle Antwort auf: {content}"
)

# Prompt verwenden
prompt = prompt_manager.get_prompt(
    "response_generation",
    "professional_email",
    content="Ich hätte gerne ein Angebot..."
)

4. PST-Datei-Analyse

from src.pst.pst_reader import PSTReader
from src.pst.pst_analyzer import PSTAnalyzer

# PST-Datei laden
pst_reader = PSTReader("path/to/file.pst")
pst_reader.open()

# PST analysieren
analyzer = PSTAnalyzer(pst_reader)
analyzer.load_emails()

# Statistiken abrufen
stats = analyzer.get_email_statistics()
sentiment = analyzer.get_sentiment_analysis()
patterns = analyzer.get_email_patterns()

print(f"Anzahl Mails: {stats['total_emails']}")
print(f"Sentiment: {sentiment['percentages']}")

Abhängigkeiten

Hauptabhängigkeiten

  • exchangelib>=4.8.0: Exchange-Server-Integration
  • gensim>=4.3.0: Clustering-Algorithmen
  • openai>=1.0.0: LLM-Integration
  • gradio>=4.40.0: Web-Oberfläche
  • cryptography>=41.0.0: Verschlüsselung
  • pydantic>=2.0.0: Datenvalidierung
  • tomli>=2.0.0: TOML-Konfiguration
  • transformers>=4.35.0: NLP-Modelle
  • onnxruntime>=1.16.0: ONNX-Inferenz
  • libpff-python>=20231205: PST-Datei-Verarbeitung

Entwicklungsumgebung

  • pytest>=7.0.0: Tests
  • black>=23.0.0: Code-Formatierung
  • isort>=5.0.0: Import-Organisation
  • mypy>=1.0.0: Typ-Prüfung
  • pre-commit>=3.0.0: Pre-commit-Hooks

Lizenz

Dieses Projekt ist unter der AGPLv3-Lizenz lizenziert.

Support

Dokumentation

Open-Source-Bibliotheken

MailHelper basiert auf folgenden großartigen Open-Source-Bibliotheken:

About

MailHelper is a Python email assistant that integrates with Microsoft Exchange, supports plugins, and uses AI models for processing emails, featuring a Gradio web interface.

Topics

python nlp automation ai email plugins assistant microsoft-exchange gradio email-processing

Resources

Readme

License

AGPL-3.0 license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages