1 Lokal heißt: Das Modell läuft bei dir

Ein KI-Modell ist am Ende eine Datei plus ein Programm, das sie ausführt. Bei Cloud-KI liegen beide in einem fremden Rechenzentrum — bei lokaler KI liegen beide auf deiner Hardware.

2 Vier gute Gründe

3 Ehrlich bleiben: Cloud vs. lokal

1 Ein LLM ist eine Datei voller Zahlen

Ein Large Language Model ist im Kern eine riesige Sammlung gelernter Zahlen — der Parameter (auch „Gewichte"). Heißt ein Modell gemma4:12b, dann steht 12b für 12 Milliarden Parameter.

In diesen Zahlen steckt alles, was das Modell beim Training „gelernt" hat: Sprachgefühl, Weltwissen, Muster. Grobe Faustregel: mehr Parameter ≈ mehr Können — aber auch mehr Speicherbedarf und langsamere Antworten auf gleicher Hardware.

2 Quantisierung: dasselbe Modell, viel kleiner

Standardmäßig belegt jeder Parameter 16 Bit (FP16). Quantisierung speichert die Gewichte mit weniger Bits — Q8 mit ~8, Q4 mit ~4. Das Modell wird drastisch kleiner, die Qualität sinkt meist nur minimal.

Merkregel: ~2 GB pro Milliarde Parameter bei FP16, ~0,5–0,6 GB bei Q4. Ein 8B-Modell in Q4 passt so in ~5 GB — machbar für viele Laptops.

3 VRAM ist die Währung

Damit ein Modell schnell antwortet, müssen seine Gewichte in den Grafikspeicher (VRAM) passen — bei Apple Silicon zählt der gemeinsame Unified Memory. Was nicht hineinpasst, wird langsam aus dem RAM nachgeladen.

4 Und welches Modell ist gerade wie stark?

Genau das ändert sich monatlich — deshalb steht es bewusst nicht als Tabelle in dieser Schulung.

Versionsstand: Modellfamilien & Größen · Stand Juli 2026 — tagesaktuell im verlinkten Board.

1 Was Ollama ist

Ollama ist Modell-Verwaltung und lokaler KI-Server in einem — so etwas wie „das Docker für LLMs": ollama pull lädt ein Modell, ollama run startet den Chat, und im Hintergrund lauscht ein Server auf http://localhost:11434, den jede App auf deinem Rechner nutzen kann.

Es gibt Alternativen (LM Studio mit grafischer Oberfläche, llama.cpp für Puristen) — wir nehmen Ollama, weil es auf allen drei Systemen gleich funktioniert und die Modell-Bibliothek direkt eingebaut ist.

2 Installieren

Wähle oben deine Plattform — ab Stufe 4 sind dann alle Befehle auf allen Systemen identisch.

3 Prüfen, dass alles läuft

4 Sicherheit: localhost bleibt localhost

Auch als Container geht's: docker run -d -v ollama:/root/.ollama -p 11434:11434 ollama/ollama — Details in der Docker-Schulung.

Versionsstand: Ollama 0.9.x · Stand Juli 2026

1 Modell wählen

Wähle nach deinem Speicher (Tabelle in Stufe 2): mit 8 GB VRAM z. B. qwen3.5:8b, mit 12–16 GB gemma4:12b. Klein anfangen — wechseln ist ein Einzeiler.

2 Laden und chatten

Nützlich im Alltag: ollama ls (was ist installiert), ollama ps (was ist gerade im Speicher), ollama rm <modell> (aufräumen).

3 Ollama ist ein Server — die API dahinter

Der Terminal-Chat ist nur eine Hülle: In Wahrheit spricht alles über HTTP mit localhost:11434. Denselben Chat kannst du per curl führen — und genau so binden Apps, Editoren und Skripte dein Modell an:

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:12b",
  "stream": false,
  "messages": [
    { "role": "user", "content": "Was ist ein Kontextfenster?" }
  ]
}'

4 Die Grenze erleben

Frag dein Modell jetzt etwas, das nur du wissen kannst: „Wann hat unsere Kantine geschlossen?", „Was steht in meinem Vertrag mit Firma X?"

Ergebnis: Es weiß es nicht — oder schlimmer, es erfindet eine plausible Antwort. Logisch: Sein Wissen wurde beim Training eingefroren, und deine Dokumente waren nie Teil davon.

1 Text rein, Vektor raus

Ein Embedding-Modell nimmt einen Text und liefert einen Vektor zurück — eine Liste von z. B. 768 Zahlen. Dieser Vektor ist die „Bedeutungs-Koordinate" des Textes in einem hochdimensionalen Raum.

Der Clou: Texte mit ähnlicher Bedeutung landen an ähnlichen Koordinaten. Wie nah sich zwei Vektoren sind, misst man mit der Kosinus-Ähnlichkeit (1 = gleiche Richtung, um 0 = nichts gemeinsam). Bedeutung wird damit — buchstäblich — berechenbar.

2 Der Aha-Moment: Suche ohne gemeinsame Wörter

„Der Hund bellt laut" und „Ein Vierbeiner macht Krach" teilen kein einziges Wort — ihre Vektoren liegen trotzdem direkt nebeneinander. Strg+F kann das nicht. Probier die Fragen aus:

3 Embedding-Modell ≠ LLM

Beide stammen aus derselben Transformer-Familie — aber sie haben völlig verschiedene Jobs:

4 Sofort anfassen

Ein Embedding-Modell lädst du genauso wie ein LLM — nur der Endpunkt ist ein anderer:

1 Das Problem: eingefrorenes Wissen + teurer Kontext

Zwei Dinge stehen zwischen deinem LLM und deinen Dokumenten:

• Eingefrorenes Wissen: Das Modell kennt nur, was beim Training da war. Deine Verträge, Notizen und Handbücher waren es nicht.
• Kontextfenster-Ökonomie: „Dann kippe ich halt alles in den Prompt!" scheitert schnell — jedes Token kostet Rechenzeit und Speicher (den KV-Cache, Stufe 9), 500 Seiten passen schlicht nicht hinein. Und selbst wenn: Bei riesigen Prompts übersehen Modelle nachweislich Details in der Mitte („lost in the middle").

2 Die Arbeitsteilung

Deshalb lädst du zwei Modelle nebeneinander — mit klar verteilten Rollen:

3 RAG in zwei Phasen

4 Einordnung

Genau nach diesem Muster arbeiten „Chat mit deinem PDF"-Tools, Firmen-Wissensbots und die Dokumenten-Funktionen vieler KI-Plattformen. Du kennst jetzt den Maschinenraum.

1 Wonach auswählen? (In dieser Reihenfolge)

1. Sprache: Für deutsche Texte muss das Modell mehrsprachig sein. Die klassische Falle: Die alten Ollama-Nummer-1-Modelle nomic-embed-text (v1.5) und mxbai-embed-large sind englisch-zentriert — mit deutschen Dokumenten sinkt die Trefferqualität spürbar.
2. Dimensionen: Mehr Zahlen pro Vektor = feinere Bedeutung, aber mehr Speicher pro Chunk und langsamere Vergleiche. „Matryoshka"-Modelle lassen sich verlustarm kürzen (768 → 256).
3. Kontextlänge: Bestimmt, wie groß ein einzelner Chunk sein darf (2k Tokens reichen für normale Absätze locker).
4. Größe/Tempo: Das Modell läuft bei jeder Frage — klein ist hier eine Tugend. CPU reicht oft völlig.

2 Die typischen Modelle im Überblick

* Matryoshka/MRL: Vektor lässt sich verlustarm kürzen. — Versionsstand: Ollama-Library · Stand Juli 2026. Tags vor dem pull auf ollama.com prüfen.

3 Die goldene Regel

4 Welches nehme ich?

1 Vorbereitung

1. Beide Modelle bereit? ollama pull embeddinggemma plus dein LLM aus Stufe 4 (jedes funktioniert).
2. Node.js ≥ 18 installiert? Prüfen mit node --version. Falls nicht: 🪟 winget install OpenJS.NodeJS.LTS brew install node🐧 sudo apt install nodejs (oder via nodesource) — mehr braucht es nicht, wir nutzen nur Bordmittel.
3. Schnelltest: /api/embed nimmt auch ein Array — mehrere Texte, ein Request:

2 Das komplette Mini-RAG

Speichere das als mini-rag.js. Unser „Wissen" sind sechs Fakten über die fiktive Firma Nordwerk — ersetze sie später durch deine eigenen:

// Mini-RAG mit Ollama (Node ≥ 18, keine Pakete nötig)
// Nutzung: node mini-rag.js "Deine Frage"
const OLLAMA = 'http://localhost:11434';
const EMBED_MODEL = 'embeddinggemma';   // das Gedächtnis
const CHAT_MODEL  = 'gemma4:12b';       // das Sprachzentrum (dein LLM aus Stufe 4)

// 1) Unser "Wissen": 6 Fakten über die fiktive Firma Nordwerk
const WISSEN = [
  'Die Kantine von Nordwerk ist freitags geschlossen.',
  'Urlaubsanträge gehen per Mail an personal@nordwerk.example.',
  'Nordwerk hat 42 Mitarbeitende an zwei Standorten.',
  'Das WLAN-Passwort für Gäste lautet Besuch2026.',
  'Die IT-Hotline ist unter Durchwahl 555 erreichbar.',
  'Firmenwagen müssen freitags bis 16 Uhr zurückgegeben werden.'
];

// Texte -> Vektoren (ein Request, input darf ein Array sein)
async function embed(texts) {
  const res = await fetch(OLLAMA + '/api/embed', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: EMBED_MODEL, input: texts })
  });
  return (await res.json()).embeddings;
}

// Kosinus-Ähnlichkeit: 1 = gleiche Richtung, um 0 = nichts gemeinsam
function cosine(a, b) {
  let dot = 0, na = 0, nb = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i];
  }
  return dot / (Math.sqrt(na) * Math.sqrt(nb));
}

(async () => {
  const frage = process.argv[2] || 'Wann hat die Kantine zu?';

  // 2) Alles einbetten: Wissen + Frage — mit DEMSELBEN Modell (Stufe 7!)
  const wissenVecs = await embed(WISSEN);
  const frageVec = (await embed([frage]))[0];

  // 3) Retrieval: die 2 nächsten Nachbarn per Kosinus-Ähnlichkeit
  const treffer = WISSEN
    .map((text, i) => ({ text, score: cosine(frageVec, wissenVecs[i]) }))
    .sort((x, y) => y.score - x.score)
    .slice(0, 2);

  console.log('Frage:', frage);
  treffer.forEach(t => console.log('  ' + t.score.toFixed(2) + '  ' + t.text));

  // 4) Generation: Treffer + Frage ans LLM — antworten NUR aus dem Kontext
  const res = await fetch(OLLAMA + '/api/chat', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: CHAT_MODEL, stream: false,
      messages: [
        { role: 'system', content: 'Antworte NUR anhand des Kontexts. Steht die Antwort nicht im Kontext, sag genau das.' },
        { role: 'user', content: 'Kontext:\n' + treffer.map(t => '- ' + t.text).join('\n') + '\n\nFrage: ' + frage }
      ]
    })
  });
  console.log('\nAntwort:', (await res.json()).message.content.trim());
})();

3 Laufen lassen

Deine Scores werden leicht abweichen — die Rangfolge ist das, was zählt.

4 Zwei Experimente, die alles zeigen

• Experiment 1 — Synonyme: „Mittags etwas zu essen" enthält kein Wort aus dem Kantinen-Satz — das Embedding findet ihn trotzdem. Der Aha-Moment aus Stufe 5, jetzt in deinem eigenen Code.
• Experiment 2 — Halluzinations-Bremse: Fragst du nach etwas, das nicht im Wissen steht, sagt das LLM das ehrlich — weil der System-Prompt es auf den Kontext festnagelt. RAG macht Antworten überprüfbar.

5 So fühlt sich das Retrieval an

Ohne Terminal, direkt hier: Wähle eine Frage und sieh, wie die Ähnlichkeits-Scores gegen die sechs Nordwerk-Fakten ausfallen (vorberechnete Beispielwerte — dein Ollama läuft auf deinem localhost, eine Webseite kommt da absichtlich nicht dran):

6 Und wenn es mehr als 6 Fakten sind?

1 VRAM-Faustregeln (Q4_K_M)

2 Der versteckte Speicherfresser: Kontext

Neben den Gewichten belegt der KV-Cache Speicher — das „Arbeitsgedächtnis" für den aktuellen Kontext. Er wächst mit dem Kontextfenster und kann bei sehr großen Kontexten die Gewichte überholen:

3 Quantisierung in der Praxis

• Q4_K_M ist der Standard-Kompromiss — die meisten Ollama-Tags liefern genau das.
• Q8 ist fast verlustfrei, braucht aber doppelten Speicher; FP16 lohnt fast nur zum Benchmarken.
• Merksatz: „Klein und ganz im VRAM schlägt groß und ausgelagert" — sobald Schichten in den RAM auslagern, bricht das Tempo um eine Größenordnung ein.

4 Betrieb im Alltag

• ollama ps zeigt, was gerade im Speicher liegt; Modelle werden nach Inaktivität automatisch entladen (steuerbar per keep_alive).
• Updates = einfach erneut ollama pull <modell>; Aufräumen mit ollama rm.
• Speicherort der Modelle: 🪟 C:\Users\<du>\.ollama\models ~/.ollama/models🐧 /usr/share/ollama/.ollama/models (Dienst) bzw. ~/.ollama/models — Platte im Blick behalten, Modelle sind Gigabyte-Brocken.

5 Die ehrliche Bilanz

Die pragmatische Praxis ist hybrid: lokal für Sensibles und den Alltag, Cloud (idealerweise EU-/DSGVO-konform gehostet) für Spitzenaufgaben.

Versionsstand: Faustregeln & Ollama-Verhalten · Stand Juli 2026

🦙 Ollama-Befehle

# Modell laden / aktualisieren
ollama pull gemma4:12b

# Chat im Terminal (beenden: /bye)
ollama run gemma4:12b

# Was ist installiert? / Was ist gerade im Speicher?
ollama ls
ollama ps

# Details & Aufräumen
ollama show gemma4:12b
ollama rm gemma4:12b

🔌 API-Endpunkte (localhost:11434)

📐 VRAM-Faustregeln

🧲 Embedding-Kurzliste (Stand Juli 2026)

• Deutsch → multilingual ist Pflicht: embeddinggemma (klein) · qwen3-embedding (Spitze) · bge-m3 (bewährt)
• Nur Englisch: nomic-embed-text, mxbai-embed-large
• Goldene Regel: Index und Modell gehören zusammen — Modellwechsel = alles neu einbetten.

🧩 RAG-Checkliste