Nutzung der lokalen KI-Fähigkeiten von ServBay: Müheloses Batch-Übersetzen von Markdown-Dokumenten

Dheeraj MalhotraDheeraj Malhotra
22 min read

Einführung

In der heutigen zunehmend globalisierten Welt explodiert die Nachfrage nach mehrsprachigen Inhalten. Ob technische Dokumentation, Blogbeiträge, Forschungsberichte oder persönliche Notizen – die Übersetzung in verschiedene Sprachen kann deren Publikum und Wirkung erheblich erweitern. Herkömmliche Übersetzungsmethoden wie die manuelle Übersetzung sind jedoch kostspielig und zeitaufwändig. Die Nutzung von Online-Übersetzungsdiensten (wie Google Translate, DeepL usw.) kann Bedenken hinsichtlich Datenschutz, API-Aufrufgebühren und Einschränkungen bei der Netzwerkverbindung mit sich bringen.

Gibt es für Entwickler, Content-Ersteller und Technikbegeisterte, die Effizienz, Datenschutz und Kosteneffizienz suchen, eine Möglichkeit, hochwertige Batch-Übersetzungen lokal, offline und kostengünstig durchzuführen? Die Antwort lautet ja! Mit der Reife und Verbreitung der Technologie lokaler Großer Sprachmodelle (LLM) können wir nun leistungsstarke KI-Modelle auf unseren eigenen Computern ausführen, um verschiedene Aufgaben zu erledigen, einschließlich Textübersetzung.

Und für ServBay-Benutzer wird dies noch einfacher und integrierter. ServBay, als leistungsstarke integrierte Webentwicklungsumgebung, bietet nicht nur eine komfortable Verwaltung von Webservern, Datenbanken und Sprachumgebungen, sondern seine neueste Version hält auch mit technologischen Trends Schritt, indem sie integrierte Unterstützung für KI/LLM enthält, insbesondere durch die Integration des beliebten Ollama-Frameworks. Das bedeutet, dass Sie lokale KI-Modelle problemlos in der ServBay-Umgebung bereitstellen und verwalten können, ohne komplexe Konfigurationen, und deren leistungsstarke Fähigkeiten nutzen können.

Dieses Tutorial, basierend auf ServBay, wird Sie detailliert anleiten, wie Sie:

  1. Die neueste KI/LLM-Unterstützung von ServBay verstehen, insbesondere die integrierten Ollama-Funktionen.

  2. Den Ollama-Dienst einfach innerhalb von ServBay installieren und konfigurieren.

  3. Ollama-Modelle, die für Übersetzungsaufgaben geeignet sind, über die grafische Oberfläche von ServBay suchen, herunterladen und verwalten.

  4. Ein Python-Skript schreiben, das den von ServBay bereitgestellten Ollama-API-Endpunkt nutzt, um die Batch-Übersetzung aller Markdown-Dateien (.md) in einem angegebenen Ordner (z. B. docs) zu automatisieren.

Durch dieses Tutorial werden Sie eine leistungsstarke, private und effiziente Lösung für die lokale Dokumentenübersetzung beherrschen und das volle Potenzial von ServBay und lokaler KI ausschöpfen. Lassen Sie uns diese aufregende Reise der lokalen KI beginnen!

Bildbeschreibung

Teil 1: ServBays neue Ära von KI / LLM: Lokale Intelligenz nutzen

ServBay hat sich schon immer verpflichtet, Entwicklern eine zentrale, effiziente und komfortable lokale Entwicklungsumgebung zu bieten. Von der Verwaltung mehrerer Versionen von PHP, Python, Java, .Net, Node.js, dem Wechsel zwischen Nginx/Apache/Caddy bis hin zur Unterstützung von MySQL/PostgreSQL/MongoDB-Datenbanken vereinfacht ServBay die Einrichtung und Wartung von Entwicklungsumgebungen erheblich. Jetzt ist ServBay wieder an vorderster Front und integriert leistungsstarke KI/LLM-Fähigkeiten in seine Kernfunktionen, um ein neues Kapitel der lokalen Intelligenz für seine Benutzer zu öffnen.

Integration von Ollama: Das Schweizer Taschenmesser für lokale LLMs

Der Kern der KI-Funktionalität von ServBay ist die Integration von Ollama. Ollama ist ein Open-Source-Projekt, das es Benutzern ermöglichen soll, große Sprachmodelle wie Llama 3, Mistral, Phi-3, Gemma3 usw. einfach lokal auszuführen. Es vereinfacht den Prozess der Einrichtung, Ausführung und Verwaltung von Modellen erheblich und bietet eine standardisierte API-Schnittstelle, die es Entwicklern ermöglicht, so bequem wie beim Aufrufen von Cloud-Diensten mit lokalen Modellen zu interagieren.

Die Integration von Ollama durch ServBay bringt zahlreiche Vorteile:

  • Ein-Klick-Installation und -Konfiguration: ServBay bietet eine dedizierte grafische Oberfläche zur Verwaltung von Ollama. Benutzer müssen Ollama nicht manuell herunterladen, Umgebungsvariablen konfigurieren oder komplexe Abhängigkeiten verwalten. Aktivieren und konfigurieren Sie es einfach kurz im KI-Panel von ServBay, und Sie haben einen einsatzbereiten lokalen LLM-Dienst.

  • Visuelle Konfigurationsverwaltung: ServBay bietet umfangreiche Konfigurationsoptionen wie Model Download Threads (Modell-Download-Threads), Bind IP, Bind Port (standardmäßig 127.0.0.1:11434, die Standard-Ollama-Konfiguration), Debug-Schalter (Debug, Flash Attention, No History, No Prune, Schedule Spread, Multi-user Cache), Cache-Typ (K/V Cache Type), GPU-Optimierung (GPU Overhead), Verbindungsaufrechterhaltung (Keepalive), Lade-Timeout (Load Timeout), maximal geladene Modelle (Max loaded models), maximale Warteschlange (Max Queue), Anzahl paralleler Verarbeitungen (Parallel Num.), LLM-Bibliothekspfad (LLM Library), Modellspeicherpfad (Models folder) und Zugriffsquellenkontrolle (origins). Dies ermöglicht es Benutzern, die Laufzeitparameter von Ollama basierend auf ihrer Hardware und ihren Bedürfnissen fein abzustimmen, ohne sich Befehlszeilenargumente merken zu müssen.

  • Einheitliches Ökosystem: Die Integration von Ollama in ServBay bedeutet, dass Ihre Webentwicklungsumgebung und Ihre KI-Inferenzumgebung auf derselben Verwaltungsplattform zusammenarbeiten können. Dies bietet großen Komfort bei der Entwicklung von Webanwendungen, die KI-Funktionen erfordern (wie intelligenter Kundenservice, Inhaltserstellung, lokale Datenanalyse usw.).

Komfortable Modellverwaltung

Nur ein laufendes Framework zu haben, reicht nicht aus; die Auswahl und Verwaltung geeigneter KI-Modelle ist ebenso wichtig. ServBay zeichnet sich auch in diesem Bereich aus:

  • Modellauflistung und -suche: ServBay bietet eine Modelllisten-Oberfläche, über die Benutzer direkt nach verfügbaren Modellen in der offiziellen Ollama-Modellbibliothek suchen können (z. B. zeigt der Screenshot die Suche nach deeps, die verschiedene Versionen von deepseek-r1 anzeigt).

  • Ein-Klick-Download und -Löschung: Für gesuchte Modelle zeigt die Oberfläche deutlich den Modellnamen (einschließlich Tags wie latest, 1.5b, 7b usw.), das Basismodell, die Anzahl der Parameter (Parameters), die Dateigröße (File Size) und Aktionsschaltflächen (Herunterladen + oder Löschen) an. Benutzer klicken einfach auf eine Schaltfläche, und ServBay kümmert sich automatisch um den Download und die Speicherung des Modells (der Speicherpfad kann in der Ollama-Konfiguration angegeben werden, standardmäßig /Applications/ServBay/db/ollama/models).

  • Lokale Modellübersicht: In der Ollama Config-Oberfläche (erster Screenshot) zeigt die linke Liste die aktuell lokal heruntergeladenen Modelle an (z. B. alfred, all-minilm, codellama usw.). Dies gibt Benutzern einen klaren Überblick über die lokalen KI-"Gehirne", die sie besitzen.

Kernwert der lokalen KI

Warum lokale KI (über Ollama in ServBay) für die Übersetzung verwenden, anstatt weiterhin Online-Dienste zu nutzen?

  • Datenschutz und Sicherheit: Dies ist der entscheidendste Vorteil. Die gesamte Datenverarbeitung erfolgt auf Ihrem eigenen Computer; der Inhalt Ihrer Dokumente muss nicht an Server von Drittanbietern gesendet werden. Dies ist unerlässlich für Dokumente, die sensible Informationen oder Geschäftsgeheimnisse enthalten.

  • Kosteneffizienz: Das lokale Ausführen von LLMs verursacht keine API-Aufrufgebühren. Obwohl möglicherweise eine anfängliche Hardware-Investition erforderlich ist (insbesondere wenn GPU-Beschleunigung benötigt wird), sind die langfristigen Kosten für große oder häufige Aufgaben weitaus geringer als bei Pay-as-you-go-Cloud-Diensten.

  • Offline-Verfügbarkeit: Sobald ein Modell lokal heruntergeladen wurde, können Sie Übersetzungen oder andere KI-Aufgaben ohne Internetverbindung durchführen, was in Umgebungen mit instabilen Netzwerken oder Szenarien, die einen vollständigen Offline-Betrieb erfordern, sehr nützlich ist.

  • Anpassung und Kontrolle: Sie haben die Freiheit, das für Ihre Aufgabe und Hardware am besten geeignete Modell auszuwählen, mit verschiedenen Modellversionen und Parametern zu experimentieren und sogar Feinabstimmungen (Fine-Tuning) durchzuführen (obwohl ServBay selbst keine direkten Feinabstimmungsfunktionen bietet, legt die lokalisierte Ollama-Umgebung den Grundstein dafür).

  • Geringe Latenz: Anfragen werden direkt an den lokal ausgeführten Dienst gesendet, was im Vergleich zum Aufrufen von Remote-APIs über das Internet typischerweise zu geringerer Latenz und schnelleren Antworten führt.

Zusammenfassend lässt sich sagen, dass ServBay durch die Integration von Ollama die Hürde für Benutzer, lokale große Sprachmodelle zu nutzen, erheblich senkt, deren leistungsstarke KI-Fähigkeiten nahtlos in eine vertraute Entwicklungsumgebung integriert und eine solide Grundlage für die Implementierung fortgeschrittener Automatisierungsaufgaben wie der Batch-Dokumentenübersetzung bietet.

Bildbeschreibung

Teil 2: Installation und Konfiguration von Ollama und Modellen in ServBay

Lassen Sie uns nun Schritt für Schritt den Ollama-Dienst in ServBay einrichten und ein für Übersetzungsaufgaben geeignetes Modell herunterladen.

Schritt 1: Navigieren Sie zur KI-Konfiguration von ServBay

  1. Starten Sie die ServBay-Anwendung.

  2. Finden und klicken Sie in der linken Navigationsleiste der ServBay-Hauptoberfläche auf AI.

  3. Klicken Sie im AI-Untermenü auf Ollama. Sie sollten eine Oberfläche ähnlich der Ollama Config sehen, die im ersten Screenshot gezeigt wird.

Schritt 2: Überprüfen und (optional) Anpassen der Ollama-Konfiguration

ServBay bietet normalerweise einen vernünftigen Satz von Standardkonfigurationen, die oft für die erstmalige Verwendung oder grundlegende Aufgaben ausreichen. Das Verständnis dieser Optionen hilft jedoch bei der zukünftigen Optimierung:

  • Ollama-Dienststatus: Oben in der Oberfläche befindet sich normalerweise ein Kippschalter oder eine Statusanzeige (ein grüner Punkt im Screenshot). Stellen Sie sicher, dass der Ollama-Dienst aktiviert ist. Wenn ServBay Start/Stopp-Schaltflächen bereitstellt, stellen Sie sicher, dass er ausgeführt wird.

  • Bind IP und Bind Port: Die Standardwerte 127.0.0.1 und 11434 sind Standardkonfigurationen, was bedeutet, dass der Ollama-Dienst nur Anfragen vom lokalen Rechner auf Port 11434 entgegennimmt. Dies ist die Adresse, mit der unser Python-Skript später eine Verbindung herstellen muss. Normalerweise sind keine Änderungen erforderlich.

  • Models folder (Modellordner): Dies ist der Pfad, unter dem heruntergeladene LLM-Modelle gespeichert werden. Der Screenshot zeigt /Applications/ServBay/db/ollama/models. Sie können dies bei Bedarf an einen anderen Speicherort mit ausreichend Speicherplatz ändern, aber stellen Sie sicher, dass der Pfad existiert und ServBay Schreibberechtigungen hat. Notieren Sie sich diesen Pfad; obwohl das Skript ihn nicht direkt verwendet, ist es hilfreich zu wissen, wo sich die Modelle befinden.

  • Model Download Threads (Modell-Download-Threads): Die Anzahl der gleichzeitigen Threads, die beim Herunterladen von Modellen verwendet werden. Wenn Sie eine gute Netzwerkverbindung haben, können Sie dies leicht erhöhen, um Downloads zu beschleunigen. Der Standardwert ist 10.

  • Andere Optionen (z. B. GPU Overhead, Max loaded models usw.): Dies sind fortgeschrittenere Optionen zur Leistungsoptimierung. Wenn Sie eine kompatible GPU (NVIDIA oder Apple Silicon) haben, erkennt und verwendet Ollama diese normalerweise automatisch. Max loaded models begrenzt die Anzahl der Modelle, die gleichzeitig in den Speicher/VRAM geladen werden, abhängig von Ihrer RAM/VRAM-Größe. Für Batch-Übersetzungsaufgaben wird normalerweise nur ein Modell gleichzeitig geladen, sodass der Standardwert im Allgemeinen ausreicht.

  • Origins (Ursprünge): Dies ist die CORS-Einstellung (Cross-Origin Resource Sharing), die steuert, welche Webseiten (Ursprünge) auf die Ollama-API zugreifen können. Der Standardwert umfasst verschiedene Variationen von http://localhost und http://127.0.0.1, was normalerweise für lokale Skripte oder lokale Webanwendungen ausreicht.

Wichtiger Hinweis: Wenn Sie eine Konfiguration ändern, klicken Sie unbedingt auf die Schaltfläche Save in der unteren rechten Ecke der Oberfläche, um die Änderungen zu übernehmen. Wenn Probleme auftreten, können Sie versuchen, auf Reset zu klicken, um die Standardeinstellungen wiederherzustellen.

Schritt 3: Navigieren Sie zur Modellverwaltungsoberfläche

  1. Klicken Sie in der linken Navigationsleiste von ServBay unter der Kategorie AI auf Models (Ollama).

  2. Sie sehen eine Modellverwaltungsoberfläche ähnlich dem zweiten Screenshot. Hier werden Modelle aufgelistet, die zum Download verfügbar sind, sowie solche, die bereits lokal installiert sind.

Schritt 4: Suchen und Herunterladen eines Übersetzungsmodells

Nun müssen wir ein für Übersetzungsaufgaben geeignetes LLM auswählen und herunterladen. Die Übersetzungsfähigkeit eines LLM hängt oft mit seiner allgemeinen Fähigkeit zur Befolgung von Anweisungen und seinen mehrsprachigen Trainingsdaten zusammen. Einige gute Optionen könnten (zum Zeitpunkt des Schreibens) sein:

  • Llama 3-Serie (z. B. llama3:8b): Das neueste Open-Source-Modell von Meta AI mit starken allgemeinen Fähigkeiten und guter Befolgungsfähigkeit von Anweisungen, das normalerweise Übersetzungsaufgaben gut bewältigt. Die 8B-Version hat relativ moderate Hardwareanforderungen.

  • Mistral-Serie (z. B. mistral:7b): Ein weiteres sehr beliebtes Hochleistungs-Open-Source-Modell, das für seine Effizienz bekannt ist.

  • DeepSeek Coder/LLM-Serie (z. B. deepseek-llm:7b-chat): Obwohl DeepSeek für seine Programmierfähigkeiten bekannt ist, besitzen seine allgemeinen Chat-Modelle normalerweise auch Übersetzungsfähigkeiten. deepseek-r1 im Screenshot könnte eine seiner Varianten oder eine bestimmte Version sein.

  • Spezialisierte Übersetzungsmodelle (falls in der Ollama-Bibliothek verfügbar): Manchmal gibt es Modelle, die speziell für die Übersetzung optimiert sind, aber starke allgemeine Modelle zur Befolgung von Anweisungen funktionieren oft auch sehr gut.

Durchführung der Suche und des Downloads:

  1. Geben Sie im Suchfeld oben in der Modellverwaltungsoberfläche den Namen des Modells ein, das Sie finden möchten, z. B. llama3 oder mistral.

  2. Die Oberfläche zeigt dynamisch eine Liste übereinstimmender Modelle an, einschließlich verschiedener Parametergrößen (wie 7b, 8b, 70b usw.) und Tags (wie latest, instruct, chat).

  3. Überlegungen bei der Auswahl eines Modells:

    • Parameter (Parameters): Wie 7b (7 Milliarden), 8b (8 Milliarden), 70b (70 Milliarden). Größere Parameterzahlen bedeuten normalerweise stärkere Fähigkeiten, aber auch höhere Anforderungen an Speicher (RAM) und Videospeicher (VRAM) sowie eine langsamere Inferenzgeschwindigkeit. Für Batch-Übersetzungen ist ein 7b- oder 8b-Modell oft ein guter Ausgangspunkt, um Leistung und Ressourcenverbrauch auszugleichen.

    • Tags (Tags): Modelle mit den Tags instruct oder chat sind normalerweise besser darin, Anweisungen zu befolgen (wie "Bitte übersetzen Sie den folgenden Text in...").

    • Dateigröße (File Size): Beachten Sie, dass Modelldateien groß sein können (von mehreren GB bis zu Dutzenden von GB). Stellen Sie sicher, dass Sie über ausreichend Speicherplatz verfügen.

  4. Finden Sie die Modellversion, die Sie herunterladen möchten (z. B. llama3:8b), und klicken Sie daneben auf das Download-Symbol (normalerweise ein Pfeil nach unten).

  5. ServBay beginnt mit dem Herunterladen des Modells. Sie können den Download-Fortschritt sehen. Die Download-Zeit hängt von Ihrer Netzwerkgeschwindigkeit und der Modellgröße ab.

Schritt 5: Überprüfen Sie die Modellinstallation

Sobald der Modelldownload abgeschlossen ist, sollte es in der Liste der installierten Modelle auf der linken Seite der Ollama Config-Oberfläche erscheinen. Außerdem könnte sich in der Models (Ollama)-Oberfläche die Aktionsschaltfläche für dieses Modell in ein Löschsymbol (🗑️) ändern.

Schritt 6: Bestätigen Sie, dass der Ollama-Dienst läuft

Stellen Sie sicher, dass die Statusanzeige oben in der Ollama Config-Oberfläche grün oder einen laufenden Zustand anzeigt. ServBay startet den Ollama-Dienst normalerweise automatisch, wenn Sie die Anwendung starten oder die KI-Funktionen aktivieren. Wenn der Dienst nicht läuft, suchen Sie nach einer Startschaltfläche und aktivieren Sie ihn.

An diesem Punkt ist Ihre ServBay-Umgebung mit dem konfigurierten Ollama-Dienst ausgestattet, und Sie haben ein lokales LLM heruntergeladen, das für die Übersetzung bereit ist. Als Nächstes schreiben wir das Python-Skript, um diesen lokalen KI-Dienst aufzurufen.

Teil 3: Schreiben des Python-Skripts für die Batch-Übersetzung

Da wir nun ein LLM lokal ausführen und über eine API (http://127.0.0.1:11434) darauf zugreifen können, schreiben wir ein Python-Skript, um den Übersetzungsprozess zu automatisieren: Iterieren Sie durch alle Markdown-Dateien im angegebenen docs-Ordner, senden Sie deren Inhalt zur Übersetzung an Ollama und speichern Sie die Ergebnisse in neuen Dateien.

Voraussetzungen

  1. Python-Umgebung: Stellen Sie sicher, dass Python auf Ihrem System installiert ist. Sie können dies überprüfen, indem Sie python --version oder python3 --version in Ihrem Terminal ausführen. ServBay wird mit Python 3 geliefert. Falls nicht installiert, installieren Sie es über ServBays Packages -> Python.

Bildbeschreibung

  1. requests-Bibliothek: Wir benötigen die requests-Bibliothek, um HTTP-Anfragen an die Ollama-API zu senden. Falls noch nicht installiert, führen Sie dies in Ihrem Terminal aus:

     pip install requests
 # oder
 pip3 install requests

  2. Projektstruktur erstellen:

    • Erstellen Sie einen Projektordner, zum Beispiel servbay_translator.

    • Erstellen Sie innerhalb des Ordners servbay_translator einen Unterordner namens docs. Platzieren Sie die Markdown-Dateien (.md), die Sie übersetzen müssen, in den Ordner docs und seine Unterordner. Zum Beispiel:

        servbay_translator/
  ├── docs/
  │   ├── introduction.md
  │   ├── chapter1/
  │   │   └── setup.md
  │   └── chapter2/
  │       └── usage.md
  └── translate_script.py  (Wir werden diese Datei erstellen)

    • Das Skript erstellt automatisch einen Ordner translated_docs, um die übersetzten Dateien zu speichern, wobei die ursprüngliche Verzeichnisstruktur beibehalten wird.

Python-Skript (translate_script.py)

import os
import requests
import json
import time

# --- Konfigurationskonstanten ---

# Ollama API-Adresse und Port (konsistent mit ServBay-Konfiguration)
OLLAMA_API_URL = "http://127.0.0.1:11434/api/generate"

# Der Modellname, den Sie in ServBay heruntergeladen haben und für die Übersetzung verwenden möchten
# Stellen Sie sicher, dass er genau mit dem Modellnamen in Ollama übereinstimmt
# Beispiele: "llama3:8b", "mistral:7b", "deepseek-llm:7b-chat" etc.
MODEL_NAME = "llama3:8b"  # <--- Ändern Sie dies zu Ihrem gewählten Modellnamen!

# Verzeichnis mit den Quell-Markdown-Dateien
SOURCE_DIR = "docs"

# Verzeichnis zum Speichern der übersetzten Dateien (Skript erstellt es)
TARGET_DIR = "translated_docs"

# Die Zielsprache, in die Sie die Dokumente übersetzen möchten
TARGET_LANGUAGE = "German" # Beispiele: "English", "Simplified Chinese", "French", "Japanese", "Spanish"

# Optional: Fügen Sie eine Verzögerung (in Sekunden) zwischen Anfragen hinzu, um Überlastung zu vermeiden oder dem System Zeit zum Reagieren zu geben
REQUEST_DELAY = 1 # 1 Sekunde Verzögerung, bei Bedarf anpassen

# --- Ollama API-Aufruffunktion ---

def translate_text_ollama(text_to_translate, model_name, target_language):
    """
    Übersetzt den gegebenen Text mithilfe der Ollama-API.

    Args:
        text_to_translate (str): Der zu übersetzende Originaltext.
        model_name (str): Der Name des zu verwendenden Ollama-Modells.
        target_language (str): Die Zielsprache für die Übersetzung.

    Returns:
        str: Der übersetzte Text oder None, wenn ein Fehler aufgetreten ist.
    """
    # Einen klaren Übersetzungsanweisungs-Prompt erstellen
    prompt = f"""Translate the following Markdown text into {target_language}.
Preserve the original Markdown formatting (like headings, lists, bold text, code blocks, etc.).
Only output the translated text, without any introductory phrases like "Here is the translation:".

Original Text:
---
{text_to_translate}
---
Translated Text ({target_language}):"""

    headers = {'Content-Type': 'application/json'}
    data = {
        "model": model_name,
        "prompt": prompt,
        "stream": False, # Auf False setzen, um die vollständige Antwort auf einmal zu erhalten, nicht als Streaming
        # Optionale Parameter, bei Bedarf anpassen, z. B. temperature steuert die Kreativität (niedriger ist konservativer)
        # "options": {
        #     "temperature": 0.3
        # }
    }

    try:
        print(f"  Sende Anfrage an Ollama (Modell: {model_name})...")
        # Timeout auf 300 Sekunden erhöhen für potenziell lange Übersetzungen
        response = requests.post(OLLAMA_API_URL, headers=headers, json=data, timeout=300)
        response.raise_for_status() # Auf HTTP-Fehler prüfen (z. B. 404, 500)

        response_data = response.json()

        # Den übersetzten Text aus der Antwort extrahieren
        # Die /api/generate-Antwortstruktur von Ollama enthält normalerweise die vollständige Ausgabe im Feld 'response'
        if 'response' in response_data:
            translated_text = response_data['response'].strip()
            print(f"  Übersetzung empfangen (Länge: {len(translated_text)} Zeichen).")
            return translated_text
        else:
            print(f"  Fehler: Schlüssel 'response' nicht in Ollama-Ausgabe gefunden: {response_data}")
            return None

    except requests.exceptions.RequestException as e:
        print(f"  Fehler beim Aufrufen der Ollama-API: {e}")
        return None
    except json.JSONDecodeError:
        print(f"  Fehler beim Dekodieren der JSON-Antwort von Ollama: {response.text}")
        return None
    except Exception as e:
        print(f"  Ein unerwarteter Fehler ist während der Übersetzung aufgetreten: {e}")
        return None

# --- Hauptverarbeitungslogik ---

def process_directory(source_base, target_base):
    """
    Durchläuft rekursiv das Quellverzeichnis, übersetzt .md-Dateien
    und speichert sie unter Beibehaltung der Struktur im Zielverzeichnis.
    """
    print(f"\nVerarbeite Verzeichnis: {source_base}")
    for item in os.listdir(source_base):
        source_path = os.path.join(source_base, item)
        target_path = os.path.join(target_base, item)

        if os.path.isdir(source_path):
            # Wenn es ein Unterverzeichnis ist, rekursiv verarbeiten
            print(f"- Unterverzeichnis gefunden: {item}")
            process_directory(source_path, target_path)
        elif os.path.isfile(source_path) and item.lower().endswith(".md"):
            # Wenn es eine Markdown-Datei ist, übersetzen
            print(f"- Markdown-Datei gefunden: {item}")

            # Sicherstellen, dass das übergeordnete Verzeichnis der Zieldatei existiert
            target_file_dir = os.path.dirname(target_path)
            if not os.path.exists(target_file_dir):
                print(f"  Erstelle Zielverzeichnis: {target_file_dir}")
                os.makedirs(target_file_dir)

            # Optional: Prüfen, ob die Zieldatei bereits existiert und überspringen
            # if os.path.exists(target_path):
            #     print(f"  Überspringe, Zieldatei existiert bereits: {target_path}")
            #     continue

            try:
                # Den Inhalt der Quelldatei lesen
                print(f"  Lese Quelldatei: {source_path}")
                with open(source_path, 'r', encoding='utf-8') as f_in:
                    original_content = f_in.read()

                if not original_content.strip():
                    print("  Überspringe leere Datei.")
                    continue

                # Ollama zur Übersetzung aufrufen
                translated_content = translate_text_ollama(original_content, MODEL_NAME, TARGET_LANGUAGE)

                if translated_content:
                    # Den übersetzten Inhalt in die Zieldatei schreiben
                    print(f"  Schreibe übersetzte Datei: {target_path}")
                    with open(target_path, 'w', encoding='utf-8') as f_out:
                        f_out.write(translated_content)
                    print("  Übersetzung für diese Datei abgeschlossen.")
                else:
                    print(f"  Fehler beim Übersetzen der Datei: {source_path}. Überspringe.")

                # Verzögerung zwischen API-Anfragen hinzufügen
                if REQUEST_DELAY > 0:
                    print(f"  Warte {REQUEST_DELAY} Sekunde(n)...")
                    time.sleep(REQUEST_DELAY)

            except Exception as e:
                print(f"  Fehler beim Verarbeiten der Datei {source_path}: {e}")
        else:
            print(f"- Überspringe Nicht-Markdown-Datei oder anderes Element: {item}")

# --- Skript-Einstiegspunkt ---

if __name__ == "__main__":
    print("Starte Markdown-Batch-Übersetzungsprozess...")
    print(f"Quellverzeichnis: {SOURCE_DIR}")
    print(f"Zielverzeichnis: {TARGET_DIR}")
    print(f"Zielsprache: {TARGET_LANGUAGE}")
    print(f"Verwende Ollama-Modell: {MODEL_NAME} unter {OLLAMA_API_URL}")
    print("-" * 30)

    # Prüfen, ob das Quellverzeichnis existiert
    if not os.path.isdir(SOURCE_DIR):
        print(f"Fehler: Quellverzeichnis '{SOURCE_DIR}' nicht gefunden.")
        print("Bitte erstellen Sie das Verzeichnis 'docs' und legen Sie Ihre Markdown-Dateien darin ab.")
        exit(1)

    # Zielverzeichnis prüfen/erstellen
    if not os.path.exists(TARGET_DIR):
        print(f"Erstelle Zielverzeichnis: {TARGET_DIR}")
        os.makedirs(TARGET_DIR)

    # Verarbeitung starten
    try:
        process_directory(SOURCE_DIR, TARGET_DIR)
        print("\n" + "=" * 30)
        print("Batch-Übersetzungsprozess abgeschlossen!")
        print(f"Übersetzte Dateien werden im Verzeichnis '{TARGET_DIR}' gespeichert.")
    except Exception as e:
        print(f"\nWährend des Prozesses ist ein Fehler aufgetreten: {e}")

Code-Erklärung:

  1. Bibliotheken importieren (import os, requests, json, time):

    • os: Für Datei- und Verzeichnisoperationen (Durchlaufen von Verzeichnissen, Prüfen von Pfaden, Erstellen von Verzeichnissen usw.).

    • requests: Zum Senden von HTTP-POST-Anfragen an die Ollama-API.

    • json: Zur Verarbeitung von JSON-Daten in API-Anfragen/-Antworten (obwohl requests hier viel davon intern erledigt).

    • time: Zum Hinzufügen von Verzögerungen zwischen Anfragen (time.sleep).

  2. Konfigurationskonstanten:

    • OLLAMA_API_URL: Der Endpunkt für die Ollama-Generierungs-API. Stellen Sie sicher, dass dies mit der IP und dem Port in Ihrer ServBay-Konfiguration übereinstimmt.

    • MODEL_NAME: Entscheidend! Muss genau mit dem Namen (einschließlich des Tags) des Modells übereinstimmen, das Sie in ServBay heruntergeladen haben und verwenden möchten. Ändern Sie dies entsprechend Ihrem gewählten Modell.

    • SOURCE_DIR: Der Name des Ordners, der die ursprünglichen .md-Dateien enthält.

    • TARGET_DIR: Der Name des Ordners, in dem die übersetzten .md-Dateien gespeichert werden.

    • TARGET_LANGUAGE: Der Name der Sprache, in die Sie übersetzen möchten. Verwenden Sie klare Sprachnamen wie "Simplified Chinese", "French", "German", "English", "Spanish". LLMs verstehen normalerweise diese natürlichen Sprachanweisungen.

    • REQUEST_DELAY: Wie viele Sekunden nach der Verarbeitung einer Datei gewartet werden soll, bevor die nächste gestartet wird. Dies hilft, eine Überlastung des Ollama-Dienstes oder eine Erschöpfung der lokalen Maschinenressourcen zu verhindern, insbesondere bei der Verarbeitung vieler Dateien oder der Verwendung ressourcenintensiver Modelle.

  3. Funktion translate_text_ollama:

    • Nimmt den Originaltext, den Modellnamen und die Zielsprache als Eingabe entgegen.

    • Prompt erstellen: Dies ist der Schlüssel zur Kommunikation mit dem LLM. Wir erstellen eine klare Anweisung, die dem Modell mitteilt:

      • Die Aufgabe ist "Übersetzen Sie den folgenden Markdown-Text in [Zielsprache]".

      • Betonen Sie "Behalten Sie die ursprüngliche Markdown-Formatierung bei". Dies ist für die Dokumentenübersetzung unerlässlich.

      • Fordern Sie "Geben Sie nur den übersetzten Text aus", um zusätzliche erklärende Sätze des Modells (wie "Hier ist die Übersetzung:") zu vermeiden.

      • Verwenden Sie ----Trennzeichen, um den Originaltext klar zu markieren.

    • API-Anfrage vorbereiten: Legen Sie die Anfrageheader (Content-Type: application/json) und den Anfragekörper (data) fest.

      • model: Gibt das zu verwendende Modell an.

      • prompt: Unsere sorgfältig ausgearbeitete Anweisung.

      • stream: False: Wir möchten das vollständige Übersetzungsergebnis auf einmal erhalten, nicht als gestreamte Fragmente.

      • options (auskommentierter optionaler Teil): Sie können zusätzliche Ollama-Parameter wie temperature übergeben (steuert Zufälligkeit/Kreativität; für Übersetzungen sind oft niedrigere Werte wie 0,2-0,5 besser).

    • Anfrage senden: Verwenden Sie requests.post, um die Anfrage an die Ollama-API zu senden. Ein längeres timeout (300 Sekunden) wird festgelegt, um potenziell große Dateien oder langsamere Modellantworten zu bewältigen.

    • Fehlerbehandlung:

      • response.raise_for_status(): Prüft auf Fehler auf HTTP-Ebene (wie 404 Not Found, 500 Internal Server Error).

      • Der try...except-Block fängt Netzwerkanfragefehler (requests.exceptions.RequestException), JSON-Parsing-Fehler (json.JSONDecodeError) und andere unerwartete Fehler ab.

    • Antwort parsen: Wenn die Anfrage erfolgreich ist, extrahieren Sie das response-Feld aus den zurückgegebenen JSON-Daten, das normalerweise den vom LLM generierten vollständigen Text (d. h. die Übersetzung) enthält. .strip() entfernt führende/nachgestellte Leerzeichen.

    • Ergebnis zurückgeben: Gibt den übersetzten Text zurück oder None, wenn ein Fehler aufgetreten ist.

  4. Funktion process_directory:

    • Dies ist eine rekursive Funktion zur Verarbeitung der Verzeichnisstruktur.

    • Nimmt den aktuellen Quellverzeichnispfad (source_base) und den entsprechenden Zielverzeichnispfad (target_base) entgegen.

    • Verwendet os.listdir, um alle Dateien und Unterverzeichnisse im aktuellen Verzeichnis abzurufen.

    • Iteriert:

      • Wenn es ein Unterverzeichnis ist: Gibt Informationen aus und ruft process_directory rekursiv für dieses Unterverzeichnis auf, wobei die aktualisierten Quell- und Zielpfade übergeben werden.

      • Wenn es eine Datei ist, die auf .md endet:

        • Gibt Informationen aus.

        • Zielverzeichnis erstellen: Verwendet os.path.dirname, um das erwartete übergeordnete Verzeichnis der Zieldatei abzurufen. Wenn dieses Verzeichnis nicht existiert, erstellt os.makedirs es (einschließlich aller erforderlichen Zwischenverzeichnisse).

        • Quelldatei lesen: Verwendet with open(...), um den Inhalt der .md-Datei mit UTF-8-Kodierung zu lesen.

        • Leere Dateien überspringen: Wenn der Dateiinhalt leer ist, überspringen Sie ihn.

        • Übersetzungsfunktion aufrufen: Übergibt den Dateiinhalt zur Übersetzung an die Funktion translate_text_ollama.

        • Zieldatei schreiben: Wenn die Übersetzung erfolgreich war (ungleich None zurückgegeben), schreibt das übersetzte Ergebnis mit UTF-8-Kodierung in die entsprechende Zieldatei.

        • Fehler behandeln: Wenn die Übersetzung fehlgeschlagen ist, gibt eine Fehlermeldung aus und überspringt die Datei.

        • Verzögerung anwenden: Ruft time.sleep(REQUEST_DELAY) auf, um die angegebene Anzahl von Sekunden zu warten.

      • Wenn es keine .md-Datei oder kein Verzeichnis ist: Gibt eine Überspringmeldung aus.

  5. Hauptausführungsblock (if __name__ == "__main__":):

    • Dies ist der Einstiegspunkt des Skripts.

    • Gibt Startinformationen aus und zeigt die Konfigurationsparameter an.

    • Quellverzeichnis prüfen: Stellt sicher, dass SOURCE_DIR existiert; bricht mit einem Fehler ab, wenn nicht.

    • Zielverzeichnis erstellen: Erstellt TARGET_DIR, falls es nicht existiert.

    • Verarbeitung starten: Ruft die Funktion process_directory auf, beginnend mit dem obersten SOURCE_DIR und TARGET_DIR.

    • Abschluss & Fehlerabfang: Verwendet einen try...except-Block, um potenzielle Fehler während des gesamten Prozesses abzufangen, und gibt am Ende eine Abschlussmeldung oder Fehlerinformationen aus.

Teil 4: Ausführen des Skripts und Überlegungen

So führen Sie das Skript aus:

  1. Öffnen Sie das Terminal.

  2. Navigieren Sie zum Projektverzeichnis: Verwenden Sie den Befehl cd, um in den von Ihnen erstellten Ordner servbay_translator zu wechseln.

     cd /pfad/zu/ihrem/servbay_translator
 # Beispiel bei Verwendung des Standard-www-Speicherorts von ServBay:
 # cd /Applications/ServBay/www/servbay_translator

  3. Stellen Sie sicher, dass ServBay und der Ollama-Dienst laufen: Gehen Sie zurück zur ServBay-Oberfläche und bestätigen Sie, dass der Dienst AI -> Ollama aktiv ist.

  4. Führen Sie das Python-Skript aus:

     python translate_script.py
 # Oder verwenden Sie python3, wenn 'python' auf Ihrem System auf Python 2 verweist
 # python3 translate_script.py

  5. Beobachten Sie die Ausgabe: Das Skript beginnt zu laufen und gibt Fortschrittsinformationen im Terminal aus, einschließlich des aktuell verarbeiteten Verzeichnisses und der Datei, des Status der gesendeten Anfragen und kurzer Informationen über die Übersetzungsergebnisse oder Fehler.

  6. Überprüfen Sie die Ergebnisse: Nachdem das Skript abgeschlossen ist, überprüfen Sie den Ordner translated_docs. Sie sollten eine Verzeichnisstruktur sehen, die mit dem Ordner docs identisch ist und die übersetzten .md-Dateien enthält. Öffnen Sie einige Dateien, um die Übersetzungsqualität und die Beibehaltung der Markdown-Formatierung zu überprüfen.

Überlegungen und potenzielle Optimierungen:

  1. Modellauswahl und Übersetzungsqualität:

    • Die Übersetzungsqualität hängt stark vom gewählten LLM (MODEL_NAME) ab. Unterschiedliche Modelle können bei verschiedenen Sprachpaaren und Texttypen unterschiedlich abschneiden.

    • Experimentieren Sie mit verschiedenen Modellen (z. B. verschiedenen Versionen von llama3, mistral, qwen, gemma3 usw.) und Parametergrößen, um herauszufinden, was für Ihre Bedürfnisse am besten funktioniert.

    • Für bestimmte Sprachpaare gibt es möglicherweise speziell feinabgestimmte Modelle, die besser funktionieren; überprüfen Sie die Ollama-Community oder Plattformen wie Hugging Face.

  2. Prompt Engineering:

    • Der prompt in der Funktion translate_text_ollama beeinflusst das Übersetzungsergebnis erheblich. Sie können versuchen, die Anweisungen anzupassen, zum Beispiel:

      • Explizites Angeben der Ausgangssprache (falls das LLM dies benötigt).

      • Spezifischere Anforderungen an die Formatbeibehaltung stellen.

      • Verschiedene Tonalitäten ausprobieren (formell, informell).

    • Wenn die Übersetzungsergebnisse unbefriedigend sind, ist die Verfeinerung des Prompts oft der erste Schritt.

  3. Beibehaltung der Markdown-Formatierung:

    • Obwohl der Prompt die Beibehaltung des Formats anfordert, können LLMs manchmal komplexe Markdown-Syntax (wie verschachtelte Listen, Tabellen, Sprachkennzeichner für Codeblöcke usw.) übersehen oder falsch behandeln.

    • Überprüfen Sie die übersetzten Dateien immer stichprobenartig, insbesondere Abschnitte mit komplexer Formatierung. Eine manuelle Korrektur kann erforderlich sein.

  4. Leistung und Ressourcenverbrauch:

    • Das Ausführen von LLMs ist rechenintensiv. Die Übersetzungsgeschwindigkeit hängt von Ihrer CPU, Ihrem Arbeitsspeicher (RAM) und davon ab, ob eine GPU-Beschleunigung verfügbar ist.

    • Große Modelle (z. B. 7B+) können ohne GPU sehr langsam sein. Die Ollama-Integration von ServBay nutzt normalerweise verfügbare GPUs (NVIDIA oder Apple Silicon) automatisch. Sie können die entsprechenden Einstellungen in der Ollama-Konfiguration von ServBay überprüfen.

    • Wenn Sie auf Leistungsengpässe oder Systemverzögerungen stoßen:

      • Erhöhen Sie den Wert von REQUEST_DELAY.

      • Versuchen Sie, kleinere Modelle (z. B. 3B oder 4B) oder quantisierte Modelle zu verwenden (oft durch q4, q5, q8 usw. im Modellnamen gekennzeichnet). Quantisierte Modelle tauschen eine geringe Menge an Präzision gegen höhere Geschwindigkeit und geringeren Ressourcenverbrauch. Die Modellverwaltungsoberfläche von ServBay listet diese quantisierten Versionen normalerweise auf.

      • Überprüfen Sie in der Ollama-Konfiguration von ServBay, ob Max loaded models und Parallel Num. vernünftig eingestellt sind (für die Batch-Verarbeitung einzelner Aufgaben müssen sie normalerweise nicht hoch sein).

  5. Umgang mit großen Dateien:

    • Sehr große Markdown-Dateien können verursachen:

      • Ollama-Verarbeitungs-Timeouts (das Skript setzt ein Timeout von 300 Sekunden, das möglicherweise länger sein muss).

      • Überschreiten des Kontextfensterlimits des Modells, was zu abgeschnittenem Inhalt oder unvollständigen Übersetzungen führt.

      • Hoher Speicherverbrauch.

    • Für extrem große Dateien müssen Sie möglicherweise eine Chunking-Strategie implementieren: Teilen Sie die große Datei in kleinere Blöcke (z. B. nach Absatz oder fester Zeichenanzahl), senden Sie jeden Block separat zur Übersetzung an Ollama und führen Sie dann die Ergebnisse zusammen. Dies erhöht die Komplexität des Skripts.

  6. Fehlerbehandlung und Wiederholungsversuche:

    • Das Skript enthält eine grundlegende Fehlerbehandlung, könnte aber verbessert werden. Zum Beispiel durch Implementierung eines automatischen Wiederholungsmechanismus: Wenn ein API-Aufruf fehlschlägt (aufgrund von Netzwerkproblemen oder weil Ollama vorübergehend nicht reagiert), warten Sie eine kurze Zeit und versuchen Sie es automatisch einige Male erneut.

    • Protokollieren Sie Fehler detaillierter zur einfacheren Fehlerbehebung.

  7. Inkrementelle Übersetzung:

    • Das aktuelle Skript verarbeitet bei jedem Durchlauf alle Dateien (es sei denn, Sie brechen manuell ab). Es könnte so geändert werden, dass überprüft wird, ob die Zieldatei existiert und ob ihre Änderungszeit neuer ist als die der Quelldatei. Wenn ja, überspringen Sie sie und implementieren Sie so eine inkrementelle Übersetzung (nur neue oder geänderte Dateien übersetzen).

  8. Parallele Verarbeitung:

    • Wenn Ihre Hardware leistungsstark genug ist (insbesondere Multi-Core-CPU oder starke GPU) und Ihre Ollama-Konfiguration parallele Verarbeitung zulässt (Parallel Num. > 0), erwägen Sie die Verwendung von Pythons multiprocessing- oder threading-Bibliotheken, um mehrere Dateien gleichzeitig zu verarbeiten. Dies könnte die Gesamtübersetzungszeit erheblich beschleunigen, erhöht jedoch den Ressourcenverbrauch und die Codekomplexität.

Fazit: Beginnen Sie Ihre lokale KI-Reise

Herzlichen Glückwunsch! Indem Sie diesem Tutorial gefolgt sind, haben Sie die integrierte Ollama-Funktionalität von ServBay erfolgreich genutzt, um einen lokalen, privaten und automatisierten Batch-Übersetzungs-Workflow für Markdown-Dokumente einzurichten. Sie haben nicht nur die leistungsstarken Integrationsfähigkeiten von ServBay im Bereich KI/LLM kennengelernt, sondern auch gelernt, wie Sie über ein einfaches Python-Skript mit lokal ausgeführten großen Sprachmodellen interagieren, um reale Probleme zu lösen.

Der Hauptvorteil dieser lokalen KI-Lösung liegt darin, dass Ihre Daten vollständig in Ihren eigenen Händen bleiben, wodurch Bedenken hinsichtlich Datenschutzverletzungen oder hoher API-Kosten beseitigt werden. Gleichzeitig erhalten Sie immense Flexibilität und Kontrolle – Sie können Modelle frei wählen, Parameter anpassen, Arbeitsabläufe optimieren und sogar offline arbeiten.

ServBay, als ausgezeichnete integrierte Entwicklungsumgebung, beweist erneut seine zukunftsorientierte Natur, indem es Ollama integriert und Entwicklern sowie Technikbegeisterten eine komfortable Plattform bietet, um modernste KI-Technologien zu erkunden und anzuwenden. Die Dokumentenübersetzung ist nur die Spitze des Eisbergs. Basierend auf diesem Framework können Sie viele weitere Anwendungen der lokalen KI erkunden, wie zum Beispiel:

  • Code-Generierung und -Erklärung: Verwendung von Modellen wie codellama oder deepseek-coder zur Unterstützung beim Programmieren.

  • Textzusammenfassung und Informationsextraktion: Schnelles Erfassen des Kerninhalts langer Dokumente oder Berichte.

  • Inhaltserstellung und -politur: Generieren von Blogbeiträgen, E-Mail-Entwürfen, kreativem Schreiben usw.

  • Lokale Wissensdatenbank-Q&A: Kombination von RAG-Techniken (Retrieval-Augmented Generation), um LLMs Fragen basierend auf Ihren lokalen Dokumenten beantworten zu lassen.

In Zukunft, da sich die lokale LLM-Technologie weiterentwickelt und die Funktionen von ServBay iterieren, haben wir allen Grund zu der Annahme, dass das Ausführen leistungsstarker, effizienter und sicherer KI-Anwendungen auf PCs immer häufiger wird. Beginnen Sie jetzt mit diesem Batch-Übersetzungsprojekt und erkunden Sie frei die unendlichen Möglichkeiten, die ServBay und Ollama Ihren lokalen KI-Bemühungen bieten!

1
Subscribe to my newsletter

Read articles from Dheeraj Malhotra directly inside your inbox. Subscribe to the newsletter, and don't miss out.

AIservbayllmmarkdown

Written by

Dheeraj Malhotra
Dheeraj Malhotra