Menu

Dokumentation

Einführung & Konzept

Das WilmaGPT Konzept

WilmaGPT ist die Antwort auf die größte Herausforderung für europäische Unternehmen bei der Einführung von Künstlicher Intelligenz: der Konflikt zwischen Innovation und den strengen Datenschutzrichtlinien der DSGVO. Während US-basierte Cloud-KI-Dienste den Markt dominieren, stellen sie für die Verarbeitung sensibler Unternehmens- und Kundendaten in der EU ein erhebliches rechtliches Risiko dar.

Wir schließen diese Lücke mit WilmaGPT, einer schlüsselfertigen, privaten KI-Lösung. Wir bieten Unternehmen dedizierte KI-Inferenz-Server, sicher gehostet in Deutschland, inklusive eines intuitiven Chat-Interfaces und einer leistungsstarken API. Unsere Kunden erhalten die volle Leistungsfähigkeit modernster Sprachmodelle bei 100%iger Datenhoheit und DSGVO-Konformität.

Die Philosophie: High-End KI-Technologie, so einfach wie ein Messenger, aber sicher wie ein Banktresor. Wir abstrahieren die Komplexität von GPU-Clustern, VRAM-Management und Modell-Deployment, sodass Sie sich voll auf Ihre Anwendungsfälle konzentrieren können.

Ihre Vorteile

  • 100% DSGVO-Konform: Verarbeiten Sie bedenkenlos personenbezogene Daten und sensible Unternehmensinformationen. Alle Server stehen in ISO 27001 zertifizierten deutschen Rechenzentren (Nürnberg/Falkenstein).
  • Vollständige Datenhoheit (Zero-Training Policy): Ihre Daten verlassen niemals Ihren privaten Server-Container. Wir garantieren vertraglich, dass Ihre Eingaben (Prompts) und Dokumente nicht für das Training unserer Modelle oder der Modelle Dritter verwendet werden.
  • Dedizierte Hardware & Performance: Im Gegensatz zu Shared-Services teilen Sie sich keine Ressourcen. Jeder Instanz sind dedizierte GPU-Cores und VRAM zugewiesen, was konstante Inferenzzeiten ohne “Noisy Neighbor”-Effekte garantiert.
  • Schlüsselfertige Lösung (Turnkey): Erhalten Sie eine sofort einsatzbereite Umgebung mit vorinstalliertem Chat-Frontend und konfigurierter API, ohne sich um Linux-Administration, Docker oder CUDA-Treiber kümmern zu müssen.
  • Maximale Flexibilität: Nutzen Sie das Frontend für Ihre Mitarbeiter und die API für Ihre Software-Integrationen parallel auf derselben Instanz.

Erste Schritte

Login & Single Sign-On (SSO)

Der Zugang zu Ihrer WilmaGPT Chat-Instanz erfolgt bequem und sicher über unser zentrales Kundenportal. Wir setzen auf einen modernen OAuth2/OIDC-basierten Single Sign-On (SSO) Mechanismus. Dies bedeutet für Sie höchste Sicherheit bei maximalem Komfort, da keine separaten Zugangsdaten für die Chat-Instanz verwaltet werden müssen.

Der Anmelde-Workflow im Detail:

  1. Navigieren Sie zu Ihrem Kunden-Dashboard auf https://wilmagpt.com.
  2. Identifizieren Sie Ihre Server-Instanz in der Übersicht.
  3. Klicken Sie auf den Button “Login to Chat UI”.
  4. Das System generiert im Hintergrund einen kryptografisch signierten Einmal-Token (Nonce) und leitet Ihren Browser automatisch an Ihre dedizierte Subdomain (z.B. https://chat.ihrfirma.wilmagpt.com) weiter.
  5. Ihre Instanz validiert den Token und gewährt Ihnen sofortigen Zugriff auf die Oberfläche.

Das Chat-Interface

Grundlagen der Bedienung

Die Chat-Oberfläche unter Ihrer chat.-Subdomain ist der zentrale Ort für die Interaktion mit den KI-Modellen. Sie ist bewusst als “Single Page Application” (SPA) konzipiert, um schnelle Reaktionszeiten zu gewährleisten.

  • Eingabefeld & Kontext: Geben Sie Ihre Fragen oder Anweisungen (Prompts) in das Textfeld ein. Das System hält den Kontext der aktuellen Unterhaltung im Arbeitsspeicher (VRAM), sodass Sie Bezug auf vorherige Aussagen nehmen können.
  • Markdown & Code: Die Ausgabe unterstützt volles Markdown-Rendering. Tabellen, Listen und Code-Blöcke (mit Syntax-Highlighting für Python, JS, HTML etc.) werden sauber formatiert dargestellt. Code kann mit einem Klick in die Zwischenablage kopiert werden.
  • Streaming Generation: Die Antworten der KI werden via Server-Sent Events (SSE) Wort für Wort in Echtzeit aufgebaut. Dies reduziert die gefühlte Wartezeit signifikant, da Sie bereits lesen können, während die KI noch “denkt”.
  • Spracheingabe (Whisper Integration): Über das Mikrofon-Symbol können Sie Sprachnachrichten aufnehmen. Diese werden browserseitig encodiert, an Ihre Instanz gesendet, dort von der Whisper-KI transkribiert und automatisch in das Textfeld eingefügt.

Modellauswahl & Technische Spezifikationen

Vor dem Start einer neuen Konversation (oder mitten im Gespräch) können Sie über das Dropdown-Menü das aktive KI-Modell wechseln. Für die Nutzung über die API ist die Angabe der korrekten API-ID im Feld model des JSON-Payloads erforderlich.

Verfügbare Modelle im Detail:

Modell-Name (UI) API-ID Technische Basis Parameter-Größe Kontext-Fenster Empfohlener Einsatzzweck
Qwen Fast qwen-fast Qwen 3 (Instruct) 8B 32k Token Der Standard für schnelle Interaktion. Ideal für E-Mail-Entwürfe, Zusammenfassungen und einfache Chat-Aufgaben.
Qwen Faster qwen-faster Qwen 3 (Instruct) 4B (Q8) 32k Token Extrem schnell bei hoher Präzision (Q8). Bestes Verhältnis zwischen Geschwindigkeit und Textqualität für automatisierte Abläufe.
Qwen Fastest qwen-fastest Qwen 3 (Instruct) 4B (Q4) 32k Token Maximale Geschwindigkeit / Niedrigste Latenz. Optimiert für einfachste Aufgaben oder Echtzeit-Klassifizierungen.
Qwen Mini qwen-mini Qwen 3 (Instruct) 0.6B 32k Token Ultra-leichtes Modell für sofortige Antworten. Ideal für minimalste Hardware-Ressourcen oder extrem einfache Logik-Aufgaben.
Qwen Large qwen-large Qwen 3 (Instruct) 32B 32k Token Deep Reasoning & Coding. Für komplexe logische Probleme, Programmierung und tiefe Inhaltsanalyse.
Qwen Code qwen-code Qwen 3 (Code) 32B 32k Token Deep Coding & Reasoning. Hoch spezialisiert auf Softwareentwicklung, SQL-Generierung und komplexe Logik-Aufgaben.
GPT OSS gpt-oss GPT-NeoX Arch. 20B 8k Token Der Allrounder. Solide Balance zwischen Performance und kreativem Schreibstil.

Hinweis: Die Modelle laufen vollständig isoliert auf Ihrer Instanz, gehostet am Standort Deutschland. Es werden keine API-Calls zu externen Anbietern (wie OpenAI, Google oder Anthropic) getätigt. Damit sind datenschutzkonforme (z.B. DSGVO & EU AI-Act) Anwendungen umsetzbar.

Konversationsverlauf

Ihre vergangenen Konversationen werden automatisch in einer lokalen Datenbank (SQLite/JSON) auf Ihrem Server-Container gespeichert. Ein Klick auf einen Eintrag in der linken Seitenleiste lädt den gesamten bisherigen Dialog wieder in den Kontext.

Technische Limitierung: Bitte beachten Sie das Kontext-Fenster (siehe Tabelle oben). Wenn eine Konversation zu lang wird, beginnt das Modell, die ältesten Nachrichten zu “vergessen”, da diese aus dem aktiven VRAM-Speicher geschoben werden (Rolling Window Context).

Desktop Workflow Tool (“Speech-to-Clipboard”)

Für maximale Produktivität bei der täglichen Arbeit bieten wir unser exklusives Python-Tool an. Es ermöglicht Ihnen, die Transkriptions-Power Ihres Servers systemweit zu nutzen.

  • Globaler Hotkey: Drücken Sie überall in Windows/macOS/Linux die Tastenkombination Strg + Alt + Y, um die Aufnahme zu starten und zu stoppen.
  • Backend-Prozess: Das Tool nimmt das Audio lokal auf, sendet es verschlüsselt an Ihren API-Endpunkt (api.subdomain...) und empfängt den Text.
  • Clipboard-Integration: Der transkribierte Text wird automatisch in Ihre Zwischenablage kopiert, sodass Sie ihn sofort mit Strg + V in Word, Outlook oder Ihr CRM einfügen können.

Das Kunden-Dashboard

Status-Überblick & Monitoring

Ihr persönliches Kunden-Dashboard auf wilmagpt.com ist die Kommandozentrale für Ihre KI-Instanz. Es kommuniziert über einen sicheren Management-Kanal mit Ihrem Container.

  • Subdomains: Hier sehen Sie die zugewiesenen Adressen. In der Regel chat.[kunde].wilmagpt.com für das Frontend und api.[kunde].wilmagpt.com für die API.
  • API-Schlüssel: Hier finden Sie Ihren “Master API Key”. Dieser Schlüssel gewährt Vollzugriff auf alle API-Funktionen Ihrer Instanz. Behandeln Sie ihn wie ein Passwort.
  • Live-Metriken:
    • GPU VRAM: Zeigt an, wie viel Grafikspeicher durch die geladenen Modelle belegt ist. Ein voller VRAM kann zu langsameren Antworten führen.
    • System Load: CPU und RAM Auslastung des Host-Containers.

Server-Aktionen

Direkt aus dem Dashboard können Sie den Lifecycle Ihrer Instanz steuern:

  • Login to Chat UI: Der primäre Weg, um die Chat-Oberfläche zu öffnen (via SSO).
  • Restart Server: Diese Aktion sendet ein SIGTERM an die Prozessgruppe Ihrer Instanz. Dies ist hilfreich, wenn sich ein Modell im VRAM “festgefressen” hat oder die API nicht mehr reagiert. Der Neustart dauert ca. 15-30 Sekunden, bis die Modelle wieder in den Speicher geladen sind.

Anwendungsbeispiele & ROI

Automatisierte Rechnungsverarbeitung (JSON Extraction)

Ein mächtiger Anwendungsfall für unsere API ist die Extraktion strukturierter Daten aus unstrukturiertem Text (z.B. OCR-Scans von PDFs). Das Modell Qwen Large (32B) eignet sich hierfür hervorragend, da es Anweisungen sehr präzise befolgt.

Der technische Workflow:

  1. OCR: Sie scannen eine Rechnung und wandeln sie mittels OCR in rohen Text um.
  2. API Request: Sie senden diesen Text an den /v1/chat/completions Endpunkt Ihrer Instanz.
  3. System Prompt: Sie geben dem Modell die Anweisung: “Du bist ein Daten-Extraktor. Antworte ausschließlich mit einem validen JSON-Objekt. Extrahiere: Rechnungsnummer, Datum, Netto-Betrag, Steuer-Betrag, Brutto-Betrag, Kreditor.”
  4. Integration: Das Modell liefert ein sauberes JSON zurück, welches Ihr ERP-System (z.B. SAP, Datev) direkt parsen und verbuchen kann.

ROI: Dies reduziert die manuelle Datenerfassung von Minuten auf Millisekunden und eliminiert Tippfehler.

Strukturierte Datenerfassung aus unformatierten Quellen

Jenseits von Rechnungen fallen in Unternehmen täglich unzählige Datenpunkte in E-Mails, Support-Tickets oder Freitext-Formularen an. WilmaGPT kann diese Informationen klassifizieren und in maschinenlesbare Formate (JSON/XML) überführen, um CRM- oder Ticketsysteme automatisch zu befüllen.

Anwendungsbeispiel: E-Mail Routing & Lead-Erfassung

  • Input: Eine unstrukturierte Kunden-E-Mail mit einer Anfrage zu einem Produkt.
  • Verarbeitung: Die E-Mail wird an die API gesendet mit dem Prompt: “Analysiere die Anfrage. Extrahiere: Kundenname, Firma, Interesse (Produktkategorie), Dringlichkeit (1-5) und Sentiment (Positiv/Neutral/Negativ). Ausgabe als JSON.”
  • Output: Das System liefert ein strukturiertes Objekt, das automatisch einen Lead im CRM anlegt und das Ticket basierend auf der Dringlichkeit priorisiert dem Sales-Team zuweist.

Meeting-Protokollierung & Voice-Analytics

Durch die Kombination des Whisper-Modells (Speech-to-Text) mit den analytischen Fähigkeiten unserer LLMs können Sie den gesamten Prozess der Meeting-Nachbereitung automatisieren. Dies spart pro Meeting ca. 15-20 Minuten Arbeitszeit.

Der Workflow im Detail:

  1. Aufnahme: Das Meeting (Teams, Zoom, oder Präsenz) wird aufgezeichnet.
  2. Transkription: Die Audiodatei wird an den Endpoint /v1/audio/transcriptions gesendet. Das Ergebnis ist ein wortgenaues Transkript inklusive Zeitstempeln.
  3. Analyse: Das Transkript wird im zweiten Schritt an den Chat-Endpoint gesendet mit der Anweisung: “Fasse das Meeting zusammen. Liste alle beschlossenen To-Dos auf und weise sie den Personen zu. Erstelle eine Liste der offenen Fragen.”
  4. Ergebnis: Sie erhalten ein fertig formatiertes Protokoll, das direkt per E-Mail an alle Teilnehmer versendet werden kann.

API-Dokumentation

Die API ist das Herzstück für Entwickler. Sie ist RESTful, nutzt JSON und ist weitestgehend kompatibel zur OpenAI-API-Spezifikation, was den Einsatz bestehender Libraries (LangChain, AutoGen, OpenAI SDKs) ermöglicht.

Basis-URL: https://api.[IHRE-SUBDOMAIN].wilmagpt.com

Authentifizierung

Jeder Request gegen die API muss authentifiziert werden. Wir nutzen hierfür Standard Bearer Tokens im HTTP-Header. Ihren persönlichen Token finden Sie im Dashboard.

Header-Format:

HTTP Header Beispiel

Authorization: Bearer sk-wilma-xxxxxxxxxxxxxxxxxxxx
Content-Type: application/json

Endpunkt: Chat Completions

Dieser Endpunkt generiert Textantworten. Er unterstützt sowohl Single-Turn (Frage-Antwort) als auch Multi-Turn (Chat) Interaktionen.

URL: /v1/chat/completions

Wichtige JSON-Parameter:

  • model (string, erforderlich): Die ID des zu nutzenden Modells. Exakte Werte: qwen-fast, qwen-faster, qwen-fastest, qwen-mini, qwen-large, qwen-code, gpt-oss.
  • messages (array, erforderlich): Liste der Nachrichten. Jedes Objekt braucht role ("system", "user", "assistant") und content.
  • temperature (float, optional): Steuert die Kreativität. 0.1 für Fakten/Datenextraktion, 0.7 (Default) für Chat, 0.9 für kreatives Schreiben.
  • stream (boolean, optional): Wenn true, wird die Antwort als Stream (Server-Sent Events) zurückgegeben.

JavaScript Implementierung

// JavaScript (Fetch API) Beispiel für einen Chat-Request
const API_URL = "https://api.ihre-subdomain.wilmagpt.com/v1/chat/completions";
const API_KEY = "sk-wilma-...";

async function getAIResponse() {
 const response = await fetch(API_URL, {
 method: "POST",
 headers: {
 "Content-Type": "application/json",
 "Authorization": `Bearer ${API_KEY}`
 },
 body: JSON.stringify({
 model: "qwen-large", // Wir nutzen das 32B Modell für Intelligenz
 messages: [
 { role: "system", content: "Du bist ein hilfreicher Assistent." },
 { role: "user", content: "Erkläre mir die Relativitätstheorie in einem Satz." }
 ],
 temperature: 0.7
 })
 });

 const data = await response.json();
 console.log(data.choices[0].message.content);
}

getAIResponse();

PHP cURL Implementierung

<?php
// PHP cURL Beispiel
$apiKey = "sk-wilma-...";
$url = "https://api.ihre-subdomain.wilmagpt.com/v1/chat/completions";

$data = [
 "model" => "qwen-fast", // Das schnelle 8B Modell
 "messages" => [
 ["role" => "user", "content" => "Fasse diesen langen Text zusammen: ..."]
 ],
 "temperature" => 0.5
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 "Content-Type: application/json",
 "Authorization: Bearer " . $apiKey
]);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
echo $result['choices'][0]['message']['content'];
?>

C# .NET Implementierung

// C# / .NET HttpClient Beispiel
using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer sk-wilma-...");

var requestData = new
{
 model = "gpt-oss",
 messages = new[] 
 {
 new { role = "user", content = "Schreibe ein Gedicht über KI." }
 }
};

var content = new StringContent(JsonSerializer.Serialize(requestData), Encoding.UTF8, "application/json");
var response = await client.PostAsync("https://api.ihre-subdomain.wilmagpt.com/v1/chat/completions", content);
var responseString = await response.Content.ReadAsStringAsync();

Console.WriteLine(responseString);

Endpunkt: Speech-to-Text

Dieser Endpunkt akzeptiert Audiodateien und gibt den gesprochenen Text zurück. Wir nutzen hierfür eine optimierte Instanz von Whisper Large v3.

URL: /v1/audio/transcriptions (POST)

Format: multipart/form-data

Parameter:

  • file (Binary, erforderlich): Die Audiodatei (mp3, wav, m4a, ogg). Max. 25 MB pro Request.
  • language (string, optional): ISO-Code der Sprache (z.B. “de”, “en”). Hilft bei der Genauigkeit, ist aber nicht zwingend (Auto-Detect).

Python Audio Upload

# Python Requests Beispiel für Audio-Upload
import requests

API_URL = "https://api.ihre-subdomain.wilmagpt.com/v1/audio/transcriptions"
API_KEY = "sk-wilma-...
FILE_PATH = "meeting_recording.mp3"

# Wichtig: Datei im Binärmodus öffnen
with open(FILE_PATH, 'rb') as f:
 files = {'file': (FILE_PATH, f, 'audio/mpeg')}
 headers = {'Authorization': f'Bearer {API_KEY}'}
 
 # Hinweis: Bei 'files' setzt requests den Content-Type automatisch auf multipart/form-data
 response = requests.post(API_URL, files=files, headers=headers)

if response.status_code == 200:
 print("Transkription:", response.json().get('text'))
else:
 print("Fehler:", response.text)

JavaScript Audio Upload

// JavaScript FormData Beispiel (z.B. im Browser)
const API_URL = "https://api.ihre-subdomain.wilmagpt.com/v1/audio/transcriptions";
const API_KEY = "sk-wilma-...";

async function uploadAudio(fileObject) {
 const formData = new FormData();
 formData.append("file", fileObject); // fileObject kommt z.B. aus <input type="file">

 const response = await fetch(API_URL, {
 method: "POST",
 headers: {
 "Authorization": `Bearer ${API_KEY}`
 // WICHTIG: Content-Type NICHT manuell setzen! Der Browser macht das inkl. Boundary.
 },
 body: formData
 });

 const result = await response.json();
 console.log("Erkannter Text:", result.text);
}

PHP Audio Upload

<?php
// PHP cURL File Upload (modern, ab PHP 5.5+)
$apiKey = "sk-wilma-...";
$url = "https://api.ihre-subdomain.wilmagpt.com/v1/audio/transcriptions";
$filePath = realpath("sprachmemo.wav");

$file = new CURLFile($filePath, 'audio/wav', 'sprachmemo.wav');
$data = ['file' => $file];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 "Authorization: Bearer " . $apiKey
]);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
echo $result['text'];
?>

C# Audio Upload

// C# MultipartFormDataContent Beispiel
using System.Net.Http;
using System.Net.Http.Headers;
using System.IO;

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "sk-wilma-...");

using var form = new MultipartFormDataContent();
using var fileStream = File.OpenRead("interview.mp3");
using var fileContent = new StreamContent(fileStream);

fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("audio/mpeg");
form.Add(fileContent, "file", "interview.mp3");

var response = await client.PostAsync("https://api.ihre-subdomain.wilmagpt.com/v1/audio/transcriptions", form);
var result = await response.Content.ReadAsStringAsync();

Console.WriteLine(result);

Sicherheit & Datenschutz

DSGVO-Konformität

WilmaGPT wurde mit “Privacy by Design” entwickelt. Wir agieren rechtlich als reiner Auftragsverarbeiter gemäß Art. 28 DSGVO. Wir garantieren vertraglich:

  • Serverstandort: Ausschließlich Deutschland (Nürnberg / Falkenstein).
  • Kein Drittstaatentransfer: Es fließen keine Daten an Server in den USA oder andere Drittländer.
  • Auftragsverarbeitungsvertrag (AVV): Ein standardisierter AVV ist Teil des Vertragsabschlusses.

Technische Isolation & Datenhoheit

Unsere Sicherheitsarchitektur basiert auf strikter Trennung:

  • Single-Tenant Architektur: Jeder Kunde erhält eigene Docker-Container. Es gibt kein “Shared Memory” oder “Shared Vector Database” zwischen Kunden.
  • VRAM Flüchtigkeit: Während der Inferenz liegen Ihre Daten kurzzeitig im Grafikkartenspeicher (VRAM). Sobald die Antwort generiert ist, wird dieser Speicherbereich für den nächsten Request freigegeben und überschrieben.
  • Verschlüsselung: Jeglicher Datenverkehr (Frontend & API) ist durch TLS 1.3/1.2 verschlüsselt. Daten im Ruhezustand (Data at Rest) auf den SSDs sind ebenfalls verschlüsselt.
  • Löschkonzept: Bei Kündigung wird die gesamte Instanz unwiderruflich gelöscht (Secure Erase).

Support & Kontakt

Hilfe & Implementierung

Wir lassen Sie nicht allein. Unser Support-Team besteht aus Entwicklern und ML-Ingenieuren, die Ihre Sprache sprechen.

  • Level 1 Support: Allgemeine Fragen zur Bedienung und Account-Verwaltung.
  • Level 2 / Developer Support: Hilfe bei der API-Integration, Debugging von Requests und Beratung zur Wahl des richtigen Modells für Ihren Use-Case.

Sie erreichen uns jederzeit über das Ticketsystem im Dashboard oder per E-Mail an support@wilmagpt.com.

Wichtiger Haftungshinweis: Große Sprachmodelle (LLMs) arbeiten probabilistisch. Sie können überzeugend klingende, aber faktisch falsche Informationen generieren (“Halluzinationen”). Wir empfehlen dringend, bei kritischen Entscheidungen (Rechtsberatung, medizinische Diagnosen, Finanztransaktionen) stets eine menschliche Prüfung (Human-in-the-Loop) nachzuschalten.