Lokale KI mit Ollama und LM Studio: Schulung für Local LLMs

Lokale KI verstehen: Warum das Sprachmodell auf den eigenen Rechner gehört

• Cloud-KI und lokale KI im Vergleich: Datenfluss, Antwortzeit, Kosten, Modellauswahl
• Open-Weight-Modelle: offene Gewichte, meist ohne offene Trainingsdaten – Unterschied zu Cloud-Modellen
• Modellfamilien einordnen: Llama, Gemma, Qwen, Mistral, DeepSeek, gpt-oss und Phi
• Datenschutz, Vertraulichkeit und Datenhoheit als Argumente für den lokalen Betrieb
• Offline arbeiten: Modelle vorab laden, Betrieb ohne Verbindung zu einem KI-Anbieter
• Kosten, Kontrolle und Unabhängigkeit: Hardware statt Tokenpreise, fest gewählte Modellversionen
• Typische Einsatzgebiete im Unternehmen: Zusammenfassen, Extrahieren, Klassifizieren, Codehilfe
• Grenzen realistisch einschätzen: Weltwissen, Schlussfolgern, Qualität auf Deutsch, Kontextlänge
• Einordnung: Workflow-Automatisierung im Seminar n8n und Ollama, Feintuning nur als Ausblick

Das richtige Modell finden: Nicht das größte Modell ist automatisch das beste

• Modellgrößen, Parameterzahl und Kontextfenster verstehen
• Dichte Modelle und Mixture of Experts: Gesamtparameter gegenüber aktiven Parametern
• Basismodelle, Instruct-Modelle und spezialisierte Modelle unterscheiden
• Reasoning-Modelle mit Denkphase: wann sie helfen, längere Laufzeit, Denkmodus abschalten
• Modelle für Text, Programmierung und multimodale Aufgaben auswählen
• Modellqualität gegen Geschwindigkeit und Ressourcenverbrauch abwägen
• Modelle recherchieren: Ollama-Bibliothek, Hugging Face, Bestenlisten kritisch lesen
• Model Cards lesen: Trainingsstand, Sprachen, Kontextlänge, Chat-Template, empfohlene Parameter
• Lizenzen prüfen: Apache 2.0 und MIT gegenüber Llama Community License; Gemma ab Version 4 unter Apache 2.0
• Modell für einen konkreten Anwendungsfall mit eigenen Testfragen statt Benchmarks auswählen

Hardware verstehen: Was läuft wirklich auf dem eigenen Rechner?

• CPU, GPU, RAM und VRAM im Zusammenspiel beim Laden und Ausführen eines Modells
• Warum Sprachmodelle so viel Speicher brauchen: Gewichte plus KV-Cache, der mit dem Kontext wächst
• Faustregel: Parameterzahl × Bits pro Gewicht ÷ 8, dazu Reserve für Kontext und System
• Laptop, Workstation und KI-Rechner: Apple Silicon mit gemeinsamem Speicher, NVIDIA- und AMD-GPUs
• GPU-Beschleunigung nutzen: CUDA, ROCm, Metal und Vulkan, Schichten teilweise auf die GPU auslagern
• Engpässe erkennen: Modell passt nicht ganz in den VRAM, Rechnen auf der CPU, Speicherdruck
• Verteilung prüfen: ollama ps und die Ressourcenanzeige in LM Studio zeigen den GPU-Anteil
• Performance messen: Tokens pro Sekunde, Zeit bis zum ersten Token, Ladezeit des Modells
• Vor dem Download prüfen, ob Modell und Quantisierung zur vorhandenen Hardware passen

Quantisierung: Große Modelle kleiner machen

• Was Quantisierung verändert: Gewichte mit 8, 6 oder 4 Bit statt 16 Bit speichern
• Warum lokale KI erst dadurch praktikabel wird: ein 8B-Modell schrumpft von rund 16 auf etwa 5 GB
• Speicherbedarf, Geschwindigkeit und Qualität gegeneinander abwägen
• Quantisierungsstufen lesen: Q8_0, Q6_K, Q5_K_M, Q4_K_M und IQ-Varianten
• GGUF als Format von llama.cpp: Gewichte, Tokenizer und Metadaten in einer Datei
• MLX-Modelle auf Apple Silicon als Alternative zu GGUF in LM Studio
• Auswirkungen auf die Ausgabequalität mit denselben Testfragen in mehreren Stufen vergleichen
• KV-Cache quantisieren: mehr Kontext im selben Speicher, mögliche Einbußen bei der Qualität
• Geeignete Varianten für die eigene Hardware auswählen
• Entscheidungsregeln statt Ausprobieren: größeres Modell in Q4 oder kleineres in Q8?

LM Studio: Lokale KI ohne komplizierten Einstieg

• LM Studio installieren, Bereiche für Chat, Modellsuche, Modellverwaltung und Server kennenlernen
• Modelle suchen und herunterladen: Suche auf Hugging Face, Quantisierung wählen, Hinweis zur Eignung
• Modelle laden, wechseln und verwalten; Speicherort und Festplattenbedarf im Blick
• Chat-Oberfläche: Verläufe, Nachrichten bearbeiten, Antworten neu erzeugen, Gespräche verzweigen
• System Prompts und Presets für wiederkehrende Aufgaben anlegen
• Chats in Ordnern organisieren, je Aufgabe ein festes Modell und Preset
• Kontextlänge und Laufzeitparameter beim Laden eines Modells konfigurieren
• Hardware- und Runtime-Einstellungen: GPU-Offload, CPU-Threads, Laufzeiten llama.cpp und MLX
• Kommandozeile lms: Modelle herunterladen, laden und entladen, Server starten

Mehr aus lokalen Modellen herausholen

• Temperature, Top K, Top P und Min P verständlich einordnen
• Kreativität und Determinismus gezielt beeinflussen: niedrige Temperatur, fester Seed
• Kontextfenster sinnvoll einsetzen: was passiert, wenn der Verlauf nicht mehr hineinpasst
• Flash Attention, KV-Cache-Typ und Batchgröße als Performance-Optionen verstehen
• Wiederholungen bremsen: Repeat Penalty und Stoppsequenzen
• System Prompts für wiederkehrende Aufgaben entwickeln und an Beispielen testen
• Few-Shot-Prompting: Beispiele im Prompt helfen kleinen Modellen besonders
• Strukturierte Ausgaben per JSON-Schema in LM Studio und Ollama erzwingen
• Lokale Modelle für Content und Code: Entwürfe, Umformulieren, Code erklären, Tests vorschlagen

Dokumente und Bilder lokal mit KI analysieren

• Multimodale Open-Weight-Modelle kennenlernen: Gemma 3/4, Qwen-VL, Llama Vision, Mistral Small
• Bildinhalte lokal analysieren: Fotos, Diagramme, Screenshots
• Text aus Bildern mit Vision-Modellen extrahieren, Tabellen als JSON zurückgeben
• OCR ohne Cloud: Vision-Modell gegenüber klassischer Texterkennung wie Tesseract
• PDF-Dokumente untersuchen: Dateien im LM-Studio-Chat anhängen, Text vorab extrahieren
• Lange Dokumente abschnittsweise zusammenfassen und Teilergebnisse zusammenführen
• Kleine Wissensabfrage: Embedding-Modell, Textabschnitte, passende Stellen zur Frage finden
• Sensible Unternehmensinformationen lokal verarbeiten: Ablage, Chatverläufe, Löschung
• Grenzen erkennen: Kontextgröße, Dokumentlänge, erfundene Zahlen und Zitate

Ollama: Lokale Modelle über die Kommandozeile betreiben

• Ollama unter macOS, Windows und Linux installieren und starten
• Modelle finden, herunterladen und ausführen: Tags wie qwen3:8b, ollama pull, ollama run
• GGUF-Modelle direkt von Hugging Face starten: ollama run hf.co/<nutzer>/<repository>
• Mit Modellen im Terminal interagieren: Befehle /set, /show, /clear und /bye
• Modelle und ihre Eigenschaften untersuchen: ollama show mit Parametern, Template, Lizenz
• System Messages und Parameter in der Sitzung ändern: /set system, /set parameter
• Sessions mit /save und /load sichern, Modelle mit ollama list, ps, stop und rm verwalten
• Mehrzeilige Prompts mit """ und Bildeingaben über den Dateipfad verwenden
• Ollama mit grafischer Oberfläche kombinieren: Ollama-App oder Open WebUI
• Cloud-Modelle in Ollama von lokalen Modellen unterscheiden und gezielt ausschließen

Eigene Modellkonfigurationen mit Ollama erstellen

• Modelfiles verstehen: Anweisungen FROM, PARAMETER, SYSTEM, TEMPLATE und MESSAGE
• Eigene Modellkonfiguration mit ollama create -f Modelfile definieren
• System Prompts dauerhaft hinterlegen, Beispieldialoge per MESSAGE vorgeben
• Modellparameter zentral festlegen: num_ctx, temperature, stop
• Bestehende Modelle als Ausgangspunkt: FROM mit Modellnamen, ollama show --modelfile
• Chat-Templates in Go-Template-Syntax lesen und anpassen
• GGUF-Dateien mit FROM ./modell.gguf integrieren; LoRA-Adapter per ADAPTER als Feintuning-Ausblick
• Wiederverwendbare Konfigurationen für Teams: Modelfiles im Git-Repository, ollama cp und push

Lokale LLMs über APIs ansprechen

• Vom Chatfenster zur programmierbaren KI: Anfrage, Antwort, Streaming
• Lokale Inference-Server einordnen: llama.cpp-Server, Ollama, LM Studio und vLLM
• Ollama als lokalen Dienst betreiben: Port 11434, OLLAMA_HOST, OLLAMA_KEEP_ALIVE
• LM Studio als lokalen Server auf Port 1234 einsetzen, Modelle bei Anfrage automatisch laden
• OpenAI-kompatible Endpunkte verstehen: /v1/chat/completions, /v1/embeddings, /v1/models
• Native Ollama-API mit /api/chat und /api/generate neben der OpenAI-Schicht
• Prompts programmgesteuert an lokale Modelle senden, erste Anfragen mit curl
• Antworten und strukturierte Outputs verarbeiten: Streaming, JSON-Schema, Tokenstatistik
• Tool Calling über die API: Funktion beschreiben, Aufruf ausführen, Ergebnis zurückgeben
• Lokale KI in Anwendungen und Workflows integrieren; Automatisierung im Seminar n8n und Ollama
• Zugriff absichern: Server nur an localhost binden oder hinter einen Proxy mit Anmeldung stellen

Python und JavaScript mit lokalen LLMs verbinden

• Lokale Modelle aus eigenen Python- und JavaScript-Programmen aufrufen
• SDKs wählen: openai mit lokaler base_url, Bibliothek ollama, LM-Studio-SDK lmstudio
• Nachrichten, Rollen und Parameter programmatisch übergeben
• Strukturierte Ergebnisse mit Pydantic- oder Zod-Schema erzeugen und validieren
• Fehler behandeln: Zeitüberschreitung, Modell nicht geladen, ungültiges JSON, erneuter Versuch
• Embeddings lokal erzeugen und für eine Ähnlichkeitssuche nutzen
• Kleine KI-Funktionen in bestehende Anwendungen einbauen: Zusammenfassung, Klassifikation, Extraktion
• Cloud-API und lokale API architektonisch vergleichen, Anbieter per Konfiguration austauschen
• Antwortqualität automatisch prüfen: Testfälle mit erwarteten Feldern und Werten
• Vom Experiment zum wiederverwendbaren KI-Baustein: Prompt, Schema und Modellversion versioniert

Eigene lokale KI-Umgebung aufbauen: Vorgehen Schritt für Schritt

• Einen konkreten Anwendungsfall auswählen, Anforderungen an Qualität, Laufzeit und Datenschutz festhalten
• Hardwareanforderungen aus Modellgröße, Kontextlänge und Zahl der Nutzer:innen bestimmen
• Zwei bis drei Kandidaten auswählen und mit denselben Testfragen vergleichen
• Modell installieren und als Modelfile oder LM-Studio-Preset konfigurieren
• Prompt und System Prompt entwickeln, Beispiele für schwierige Fälle ergänzen
• Qualität und Performance testen: Trefferquote, Tokens pro Sekunde, Speicherbedarf
• Ergebnisse per JSON-Schema strukturiert ausgeben
• Integration in Unternehmensprozesse konzipieren: Server, Zugriffsrechte, Updates, Modellwechsel

Lokale Modelle für Coding-Agenten

• Continue in VS Code mit Ollama oder LM Studio als Modellanbieter: Chat, Autovervollständigung, Codesuche
• Codex CLI mit --oss gegen ein lokales gpt-oss-Modell in Ollama starten
• Agententauglichkeit vorab testen: zuverlässige Werkzeugaufrufe und gültiges JSON mit festen Testfällen
• Kontextlänge für Arbeit im Repository anheben und den zusätzlichen KV-Cache im VRAM einplanen
• Agent schreibt Vergleichsskripte gegen die lokale API, die Modelle und Quantisierungen bewerten
• Aufgaben trennen: lokales Modell für Vervollständigung und Commit-Texte, große Umbauten nur nach Freigabe in der Cloud

Praxisprojekt: Lokaler Auswerter für technische Datenblätter

• Datenblätter als PDF und Foto einlesen, Kenndaten mit einem Vision-Modell als JSON extrahieren
• Zwei Modelle in je zwei Quantisierungen an 20 Datenblättern vergleichen: Trefferquote und Laufzeit
• Siegermodell als Modelfile festschreiben und per Python-Skript über die OpenAI-kompatible API ansprechen
• Kurzbericht: Hardwarebedarf, Grenzen des Modells und Weg in den Betrieb für die Fachabteilung

Lernziele

• Sie schätzen aus Parameterzahl, Quantisierung und Kontextlänge ab, ob ein Modell in Ihren Arbeits- und Grafikspeicher passt
• Sie wählen Open-Weight-Modelle nach Aufgabe, Lizenz und Model Card aus und vergleichen sie mit eigenen Testfragen
• Sie betreiben Modelle in LM Studio und Ollama und stellen Sampling-Parameter, Kontextlänge und GPU-Offload gezielt ein
• Sie erstellen eigene Modellkonfigurationen mit Ollama-Modelfiles
• Sie analysieren PDFs und Bilder lokal mit multimodalen Modellen und kennen deren Grenzen
• Sie rufen lokale Modelle aus Python und JavaScript über OpenAI-kompatible Endpunkte auf und validieren strukturierte Antworten
• Sie prüfen, ob ein lokales Modell als Anbieter für einen Coding-Agenten taugt

Zielgruppe

• Entwickler:innen, die Sprachmodelle in eigene Anwendungen einbinden, ohne Daten an Cloud-Anbieter zu senden
• IT-Teams, die lokale KI auf Workstations oder Servern für Kolleg:innen bereitstellen
• Datenschutzbewusste Fachleute, die vertrauliche Dokumente mit KI auswerten wollen
• Technisch Interessierte mit Grundkenntnissen im Terminal; Programmierkenntnisse für die API-Module hilfreich