Top 20 AI-Konzepte in LLMs: detaillierte Erklärung mit Beispielen

1. Übersicht

Wenn du ein Java-Entwickler bist, der damit beginnt, LLMs (ChatGPT, Gemini, Claude…) in dein System zu integrieren, wirst du auf viele unbekannte Begriffe stoßen: Token, Embedding, RAG, Fine-Tuning, Halluzination… Dieser Artikel fasst die 20 wichtigsten AI-Konzepte rund um LLMs zusammen, mit einer kurzen Erklärung und Beispielen für jedes Konzept (größtenteils in Java/Spring AI). Nach dem Lesen hast du das nötige Vokabular, um die API-Dokumentation von OpenAI oder Anthropic zu lesen oder ein grundlegendes RAG-System zu entwerfen.

2. Token und Tokenization

LLMs lesen nicht “Wörter”, sondern Tokens — kleinere Einheiten als Wörter, die einzelne Wörter, Wortteile oder Satzzeichen sein können. Tokenization ist der Prozess, Text in diese Tokens aufzuteilen, bevor er ins Modell eingegeben wird.

Input:  "Spring Boot ist sehr mächtig"
Tokens: ["Spring", " Boot", " ist", " sehr", " mächtig"]  (5 Tokens)

Die Anzahl der Tokens bestimmt die Kosten für API-Aufrufe (Abrechnung nach Tokens) und die maximale Länge von Ein- und Ausgaben.

Hinweis: Nicht-englische Sprachen mit Diakritika werden oft in mehr Tokens aufgeteilt als Englisch für denselben Text, daher sind die API-Kosten für nicht-englische Inhalte oft höher.

3. Embedding

Embedding ist der Prozess, einen Text in einen Vektor aus reellen Zahlen (z.B. 1536-dimensional) zu konvertieren, sodass zwei Texte mit ähnlicher Bedeutung auch ähnliche Vektoren haben. Dies ist die Grundlage für semantische Suche.

EmbeddingModel embeddingModel = ...; // Bean, automatisch konfiguriert von Spring AI
EmbeddingResponse response = embeddingModel.embedForResponse(
        List.of("Kunde möchte Bestellung stornieren"));
float[] vector = response.getResult().getOutput();
System.out.println(vector.length); // 1536

embedForResponse ruft das Embedding-Modell auf und gibt den Vektor zurück. Zwei Sätze wie “Bestellung stornieren” und “cancel order” haben ähnliche Vektoren, obwohl sie in verschiedenen Sprachen sind.

Um die semantische Nähe zu vergleichen, verwenden wir Kosinus-Ähnlichkeit:

double cosineSimilarity(float[] a, float[] b) {
    double dot = 0, normA = 0, normB = 0;
    for (int i = 0; i < a.length; i++) {
        dot += a[i] * b[i];
        normA += a[i] * a[i];
        normB += b[i] * b[i];
    }
    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

@Test
void similarVectorsShouldScoreHigh() {
    float[] a = {1f, 0f, 1f};
    float[] b = {1f, 0.1f, 0.9f};
    assertThat(cosineSimilarity(a, b)).isGreaterThan(0.95);
}

Ein Wert nahe 1 bedeutet, dass die beiden Vektoren (und damit auch die beiden Sätze) sehr ähnlich sind.

4. Context Window

Das Context Window ist die maximale Anzahl von Tokens, die ein Modell in einem Aufruf verarbeiten kann — einschließlich Prompt und Antwort. Wird diese Grenze überschritten, kann das Modell den Anfang abschneiden oder einen Fehler zurückgeben.

GPT-4o:        128.000 Tokens
Claude 3.5:    200.000 Tokens
Gemini 1.5 Pro: 1.000.000 Tokens

Bei Chatbot-Anwendungen mit langen Gesprächsverläufen musst du proaktiv frühere Nachrichten kürzen oder zusammenfassen, bevor das Context Window voll wird, sonst verlierst du Kontext vom Anfang des Gesprächs ohne klare Warnung.

5. Prompt und Prompt Engineering

Ein Prompt ist der Text, den du an ein LLM sendest, um es aufzufordern, etwas zu tun. Prompt Engineering ist die Kunst, Prompts so zu gestalten, dass das Modell präzise und im gewünschten Format antwortet.

Zuerst füge die Spring-AI-Abhängigkeit hinzu:

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

@Service
class OrderSummaryService {
    private final ChatClient chatClient;

    OrderSummaryService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    String summarize(String orderNote) {
        return chatClient.prompt()
                .user("Fasse die Kundenanfrage in einem Satz zusammen: " + orderNote)
                .call()
                .content();
    }
}

ChatClient ist ein Wrapper von Spring AI, um das Modell aufzurufen, ohne HTTP manuell zu handhaben. .user(...) setzt den Prompt-Inhalt, .call().content() gibt das Ergebnis als String zurück.

6. System Prompt vs User Prompt

Ein System Prompt ist eine “versteckte” Anweisung, die die Rolle und Regeln des Modells für das gesamte Gespräch definiert; ein User Prompt ist die spezifische Frage oder Anfrage des Benutzers.

chatClient.prompt()
        .system("Du bist ein Kundenservice-Assistent eines Schuhgeschäfts. Antworte immer kurz und höflich.")
        .user("Wann wird meine Bestellung #1023 geliefert?")
        .call()
        .content();

Der System Prompt wird einmal gesetzt, der User Prompt ändert sich bei jedem Request. Diese Trennung hilft dir, die “Persönlichkeit” des Modells zu kontrollieren, ohne die Anleitung in jeder Frage zu wiederholen.

7. Zero-shot, One-shot, Few-shot Learning

Dies beschreibt, wie du (oder nicht) Musterbeispiele im Prompt bereitstellst, um das Modell anhand von Beispielen lernen zu lassen, ohne das Modell neu zu trainieren.

Zero-shot: Keine Beispiele, nur Anforderungsbeschreibung.
Few-shot:  2-5 Beispiele von Input → Output-Paaren vor der eigentlichen Frage.

String fewShotPrompt = """
    Klassifiziere Bewertungen nach Sentiment (positiv/negativ):
    Bewertung: "Schnelle Lieferung, gute Qualität" -> positiv
    Bewertung: "Defektes Produkt, eine Woche verspätet" -> negativ
    Bewertung: "%s" ->
    """.formatted(userReview);

Few-shot produziert normalerweise stabilere Ergebnisse als Zero-shot bei speziellen Klassifizierungs- oder Format-Aufgaben, verbraucht aber pro Aufruf mehr Tokens.

8. Chain-of-Thought (CoT)

CoT ist eine Technik, bei der du das Modell auforderst, “Schritt für Schritt zu denken”, bevor es die endgültige Antwort gibt. Das erhöht die Genauigkeit bei Aufgaben, die Argumentation erfordern (Mathematik, Logik).

chatClient.prompt()
        .user("""
            Eine Bestellung hat 3 Produkte für 120€, 85€, 45€, 10% Rabatt.
            Berechne Schritt für Schritt und gib die Gesamtsumme am Ende an.
            """)
        .call()
        .content();

Wenn es aufgefordert wird, “Schritt für Schritt” zu arbeiten, neigt das Modell dazu, das Problem in kleinere Berechnungen zu zerlegen, was Rechenfehler reduziert.

9. Temperature und Top-p

Temperature und Top-p sind zwei Parameter, die steuern, wie “zufällig” das Modell das nächste Wort auswählt. Niedrige Temperature → konsistente, wiederholbare Antworten; hohe Temperature → kreativer, aber möglicherweise vom Thema abweichend.

ChatOptions options = OpenAiChatOptions.builder()
        .withTemperature(0.2)
        .withTopP(0.9)
        .build();

temperature = 0.0  -> ideal: Datenauszug, präzise Antworten
temperature = 0.8  -> ideal: kreatives Schreiben, Brainstorming

Hinweis: Bei Aufgaben, die wiederholbare Ergebnisse erfordern (z.B. automatisierte Tests), setze temperature = 0, um Schwankungen zwischen Aufrufen zu minimieren.

10. Attention Mechanism

Attention ist ein Mechanismus, der es dem Modell ermöglicht, wenn es ein Wort verarbeitet, alle anderen Wörter im Satz “anzuschauen” und automatisch zu berechnen, welche am relevantesten sind. Das ist der Grund, warum das Modell entfernten Kontext versteht — z.B. weiß es, worauf ein Pronomen verweist.

Satz: "Die Bestellung wurde storniert, weil der Kunde seine Meinung änderte, es wurde bereits rückerstattet."
Attention hilft dem Modell, "es" -> "Die Bestellung" zu verknüpfen, nicht "Kunde".

Du kodierst nicht direkt Attention, wenn du APIs verwendest, aber das Verständnis dafür hilft zu erklären, warum das Modell manchmal Kontext aus entfernten Sätzen oder sehr langen Texten “vergisst”.

11. Transformer Architecture

Transformer ist die neuronale Netzwerk-Architektur, die hinter fast allen modernen LLMs steckt. Sie nutzt Attention, um den gesamten Satz parallel zu verarbeiten (statt sequenziell wie alte RNNs), sodass das Training auf riesigen Datenmengen schneller ist.

Input-Tokens -> Embedding -> [Attention + Feed-Forward] x N Layer -> Output-Wahrscheinlichkeiten

Die Anzahl der Layer (N) und der Parameter entscheidet über die “Größe” des Modells — GPT-4, Claude, Llama sind alle Variationen von Transformer mit unterschiedlichen Layern und Trainingsmethoden.

12. Fine-tuning

Fine-Tuning ist das Training eines bereits trainierten Modells (pretrained) auf deinen eigenen Daten, um es auf eine spezifische Aufgabe abzustimmen (z.B. korrekte Marken-Tonalität).

{"messages": [
  {"role": "user", "content": "Wann wird Bestellung #203 geliefert?"},
  {"role": "assistant", "content": "Ihre Bestellung #203 ist unterwegs, sollte heute ankommen."}
]}

Diese JSONL-Datei ist eine Trainingszeile für Fine-Tuning — jede Zeile ist ein beispielhaftes Gespräch, du sendest tausende solcher Zeilen an die Fine-Tuning-API eines Providers.

Wann NICHT verwenden: Wenn du nur einige einfache Regeln befolgen musst, sind Prompt Engineering oder RAG viel billiger und schneller als Fine-Tuning.

13. LoRA (Low-Rank Adaptation)

LoRA ist eine sparsame Fine-Tuning-Technik: Statt alle Milliarden Parameter des Basis-Modells zu aktualisieren, trainiert LoRA nur kleine Matrix-“Adapter”, die in die Layer eingefügt werden, während das Basis-Modell gleich bleibt.

Basis-Modell: 7 Mrd. Parameter (eingefroren, unveränderlich)
LoRA-Adapter: ~10-50 Mio. Parameter (trainiert)

Dadurch kannst du große Modelle auf einer normalen GPU fine-tunen und mehrere verschiedene Adapter auf das gleiche Basis-Modell für verschiedene Use-Cases “anschließen”.

14. Quantization

Quantization reduziert die numerische Präzision von Modell-Parametern (z.B. von float32 auf int8/int4), um die Größe zu verringern und das Inference zu beschleunigen, mit einem kleinen Genauigkeitsverlust.

FP32: 7 Mrd. Parameter x 4 Bytes = ~28 GB RAM
INT4: 7 Mrd. Parameter x 0,5 Byte = ~3,5 GB RAM

Quantization ist der Grund, warum du ein 7-Milliarden-Parameter-LLM auf einem normalen Laptop statt auf spezialisierter GPU-Server ausführen kannst — dafür sinkt die Antwortqualität leicht.

15. RAG (Retrieval-Augmented Generation)

RAG kombiniert Suche (Retrieval) nach internen Daten mit einem LLM: Vor der Antwort findet das System die relevantesten Textpassagen (durch Embedding) und fügt sie als “Kontext” in den Prompt ein, sodass das Modell mit deinen eigenen Daten antwortet, ohne Fine-Tuning.

List<Document> relevantDocs = vectorStore.similaritySearch(
        SearchRequest.query("Rückgaberichtlinie").withTopK(3));

String context = relevantDocs.stream()
        .map(Document::getContent)
        .collect(Collectors.joining("\n---\n"));

String answer = chatClient.prompt()
        .system("Antworte nur auf Basis des bereitgestellten Kontexts.")
        .user("Kontext:\n" + context + "\n\nFrage: Innerhalb welcher Tage kann man Artikel zurückgeben?")
        .call()
        .content();

similaritySearch findet die 3 relevantesten Dokumentenabschnitte zur Frage, fügt sie in den Prompt ein und sendet dann an das Modell. So antwortet das Modell nach deinen echten Richtlinien, nicht nach “allgemeinem” Wissen aus dem Pretraining.

16. Vector Database

Eine Vector Database speichert Embeddings mit Metadaten und unterstützt schnelle “k nächste Nachbarn” (k-NN)-Suche über Millionen von Vektoren — essentiell für großflächiges RAG (Pinecone, Milvus, PGVector…).

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(1536)
);

SELECT content FROM documents
ORDER BY embedding <-> '[0.01, -0.02, ...]'
LIMIT 3;

Der <->-Operator (von der pgvector-Erweiterung) berechnet den Abstand zwischen dem Abfrage-Vektor und gespeicherten Vektoren, gibt die nächsten Einträge zurück — genau das ist der similaritySearch-Schritt aus Abschnitt 15.

17. Function Calling / Tool Use

Function Calling ermöglicht es dem LLM, deine Anwendung anzufordern, eine spezifische Funktion aufzurufen (Preise abfragen, Wetter abrufen, Datenbank abfragen), statt Daten zu erfinden.

@Tool(description = "Liefert den Status einer Bestellung anhand der Bestellnummer")
String getOrderStatus(String orderId) {
    return orderRepository.findStatusById(orderId);
}

chatClient.prompt()
        .user("Welchen Status hat Bestellung #1023?")
        .tools(this)
        .call()
        .content();

Wenn die Frage gesendet wird, erkennt das Modell, dass es getOrderStatus aufrufen muss, Spring AI führt die echte Java-Funktion aus, und das Modell formuliert die Endantwort — es muss nicht “raten”, welchen Status die Bestellung hat.

18. AI Agent

Ein Agent ist ein System, das ein LLM als “Gehirn” nutzt, um selbstständig Pläne zu machen, mehrere Tools in Reihenfolge aufzurufen, Ergebnisse zu beobachten und zu wiederholen, bis ein Ziel erreicht ist — anders als ein Chatbot, der nur einmal antwortet.

Benutzer: "Überprüfe Bestellung #1023, wenn sie mehr als 3 Tage verspätet ist, schreibe eine Entschuldigungs-Email."

Agent führt selbstständig aus:
1. Ruft Tool getOrderStatus("1023") auf
2. Berechnet Verzögerungstage
3. Wenn > 3 -> ruft Tool sendEmail(...) auf
4. Gibt Report an Benutzer

Agenten werden normalerweise mit einer “Denken → Handeln → Beobachten”-Schleife (ReAct-Pattern) gebaut und verbinden mehrere aufeinanderfolgende Function-Calls, um mehrstufige Aufgaben zu lösen.

19. Halluzination

Halluzination ist, wenn ein Modell selbstbewusst antwortet, aber die Information falsch oder völlig erfunden ist — z.B. ein nicht vorhandenes Gesetz zitiert oder sich eine nicht existierende API “merkt”.

Benutzer: "Wie funktioniert die `OrderService.cancelAndRefund()`-Methode?"
Modell: "Diese Methode erstattet automatisch innerhalb von 24h zurück..." (aber diese Methode existiert gar nicht im Code)

Der häufigste Weg, Halluzinationen zu reduzieren, ist RAG zu verwenden (Abschnitt 15), damit das Modell sich an echte Dokumente hält, und das Modell zu fordern, “Ich weiß nicht” zu sagen, wenn der Kontext unzureichend ist, statt selbst zu spekulieren.

20. Guardrails

Guardrails sind ein Satz von Kontrollschichten (Filter für Ein-/Ausgabe, Format-Validierung, Blockierung von Inhalten), die um das LLM herum platziert werden, um sicherzustellen, dass das System sicher und konform ist, bevor es das Ergebnis an den Endbenutzer liefert.

String output = chatClient.prompt().user(userInput).call().content();

if (containsPersonalData(output) || !isValidJson(output)) {
    throw new UnsafeModelOutputException("Output erfüllt Guardrail-Anforderungen nicht");
}

Guardrails können bei der Eingabe liegen (Prompt-Injection blockieren, schädliche Inhalte) oder bei der Ausgabe (JSON-Format prüfen, Bankkartenummern verstecken) — überspringe diesen Schritt nicht, wenn du LLMs in ein echtes Produkt bringst, auch wenn das Modell in Demos “richtig” zu antworten scheint.

21. RLHF (Reinforcement Learning from Human Feedback)

RLHF ist eine Trainingstechnik, die auf menschlichem Feedback basiert: Menschen bewerten mehrere Modell-Antworten, dann trainiert das System ein “Reward Model”, das lernt wie Menschen zu “bewerten”, und nutzt das, um das Basis-Modell zu optimieren.

Schritt 1: Modell erzeugt 3-4 Antworten auf die gleiche Frage
Schritt 2: Mensch bewertet: beste -> schlechteste
Schritt 3: Trainiere ein Reward-Modell, um wie Menschen zu bewerten
Schritt 4: Nutze das Reward-Modell, um das LLM durch Reinforcement Learning zu optimieren

RLHF ist der Grund, warum ChatGPT, Claude mit höflicher “Stimme” antworten und gefährliche Anfragen ablehnen — anders als das Basis-Modell, das nur “nächstes Wort vorhersagen” trainiert wurde.

22. Fazit

Die obigen 20 Konzepte sind das minimale Vokabular, um ernsthaft mit LLMs zu arbeiten: von Low-Level (Token, Embedding, Attention) bis Anwendungs-Level (RAG, Function Calling, Agent, Guardrails). Du brauchst die tiefe Mathematik von Transformers nicht zu verstehen, um LLMs in dein Spring-Boot-System zu integrieren, aber das richtige Verständnis dieser Konzepte hilft dir, die passende Lösung auszuwählen — zum Beispiel, wann RAG statt Fine-Tuning einzusetzen ist, oder wann Guardrails notwendig sind, anstatt blind auf die Model-Ausgabe zu vertrauen.