LLM-Dialog: Erstellen einer Go-Utility zum Vergleichen von Sprachmodellen

Automatisierte LLM-Dialoge: Go-GUI-Tool zum Vergleich von Sprachmodellen

Automatisierte Gespräche zwischen zwei Sprachmodellen eröffnen spannende Möglichkeiten für Tests, Vergleiche und Analysen von KI-Verhalten. Dieses auf Go basierende GUI-Tool, angetrieben von Fyne, visualisiert den Prozess und bietet Forschern und Entwicklern ein praktisches Werkzeug zur Arbeit mit lokalen LLMs über Ollama.

App-Architektur für LLM-Dialoge

Das Programm ist eine auf Fyne basierende Desktop-App mit intuitiver Oberfläche zur Einrichtung und Steuerung von Gesprächen. Im linken Bereich finden sich die Bedienelemente: Wählen Sie zwei Modelle aus der ollama list-Ausgabe, weisen Sie optional Rollen zu, geben Sie ein Gesprächsthema ein, legen Sie Rundenlimits und Timeouts in Minuten fest. Rechts wird der Chat-Verlauf mit farbcodierten Nachrichten und Zeitstempeln angezeigt.

Wichtige technische Highlights:

• Nutzt lokalen Ollama-Server auf Port 11434
• HTTP-API für Modellinteraktionen
• Kontextmanagement pro Modell mit den letzten 20 Nachrichten
• Timeout-Behandlung über Go-Kontexte, um Hänger zu vermeiden
• Reset-Mechanismus zum Löschen des Gesprächsverlaufs

Implementierung der Modellinteraktionen

Die App verfolgt einen strukturierten Ansatz zur Gesprächsverwaltung. Jedes Modell pflegt seinen eigenen Kontext, inklusive Systemnachricht mit Rolle und Chat-Verlauf, was kohärente Austausche ohne Kontextüberladung gewährleistet.

Gesprächsablauf:

• Initialisiere Kontexte für beide Modelle mit Systemprompts
• Wechsle abwechselnd Runden für die festgelegte Anzahl
• Aktualisiere Verläufe beider Modelle nach jeder Antwort
• Erzwinge Timeouts über Kontexte

Hier ein Code-Beispiel für den Ollama-API-Aufruf:

func callOllamaAPI(ctx context.Context, model string, messages []Message) (string, error) {
    requestBody := ChatRequest{
        Model:    model,
        Messages: messages,
        Stream:   false,
    }
    requestBody.Options.NumPredict = 1024
    
    jsonData, err := json.Marshal(requestBody)
    if err != nil {
        return "", fmt.Errorf("request marshal error: %v", err)
    }
    
    req, err := http.NewRequestWithContext(ctx, "POST",
        "http://localhost:11434/api/chat",
        bytes.NewBuffer(jsonData))
    if err != nil {
        return "", fmt.Errorf("request creation error: %v", err)
    }
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{Timeout: 0}
    resp, err := client.Do(req)
    if err != nil {
        return "", fmt.Errorf("HTTP request error: %v", err)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", fmt.Errorf("response read error: %v", err)
    }
    
    var response ChatResponse
    if err := json.Unmarshal(body, &response); err != nil {
        return "", fmt.Errorf("JSON parse error: %v", err)
    }
    return response.Message.Content, nil
}

Praktische Anwendungsfälle

Dieses Tool eignet sich hervorragend für Tech-Profis auf vielfältige Weise:

• Modellvergleich

- Testen von LLMs mit identischen Prompts

- Erkennen von Unterschieden in Stil, Ton und Inhalt

- Analysieren von Konsistenz und Widersprüchen in Chats

• Rolle-Einfluss-Studien

- Zuweisen von Personas zu Modellen

- Beobachten von Verhaltensänderungen je Rolle

- Experimentieren mit KI-Sozialdynamiken

• Edge-Case-Tests

- Prüfen der Stabilität in langen Gesprächen

- Erkunden der Handhabung kniffliger oder widersprüchlicher Themen

- Bewerten der Kontextretention

• Bildung und Demos

- Vorführen von LLM-Mechanismen

- Visualisieren der Textgenerierung

- Erforschen von Designmustern für KI-Apps

Implementierungsdetails

Aufgebaut mit:

• Fyne für die GUI
• Go-Standardbibliothek für Netzwerk und JSON
• Ollama-API für LLMs
• Goroutines und Mutexes für Parallelität
• Kontexte für Timeout-Steuerung

Kern-Datenstrukturen:

• Message für einzelne Nachrichten
• ChatRequest und ChatResponse für API-Aufrufe
• ModelContext für modellenspezifischen Zustand
• ConversationState für Chat-Tracking
• guiApp als Haupt-App-Struktur

Optimierungen und Erweiterungen

Zur Steigerung von Performance und Funktionen:

• Cachen von Modellantworten für Wiederholungen
• Hinzufügen von Echtzeit-Streaming
• Export von Chats nach JSON, Markdown, PDF
• Integration von Dialog-Qualitätsmetriken
• Unterstützung von Generierungsparametern (Temperatur, top_p)
• Laden benutzerdefinierter Prompts aus Dateien

Wichtige Erkenntnisse

• Automatisiert Head-to-Head-LLM-Chats ohne menschliche Eingabe
• Fyne-GUI macht Einstellungsanpassungen kinderleicht
• Lokale Ollama-Unterstützung ohne Cloud-Abhängigkeit
• Intelligentes Kontext- und Verlaufsmanagement sorgt für Kohärenz
• Ideal für KI-Vergleiche, Tests und Forschung

— Editorial Team