Professionelle KI-Entwicklung für Java-Experten

Nach dieser Schulung können die Teilnehmer eigenständig anspruchsvolle KI-Funktionalitäten mit LLMs in Java-Anwendungen integrieren - inklusive Prompt Engineering, Agentensysteme, Embeddings und RAG-Architekturen -, um professionelle und produktionsfähige Lösungen zu realisieren, die technischen, wirtschaftlichen und rechtlichen Anforderungen gerecht werden.

Ausgestellt am 18 Sept. 2026 von

GFU Cyrus AG

Badge validieren

Aussteller

GFU Cyrus AG

info@gfu.net

GFU Cyrus AG — bildet weiter.

Bereits 1980 als GFU Cyrus + Rölke mbH gegründet, zählt die GFU heute zu den renommiertesten IT-Schulungsunternehmen in Deutschland. Jedes Jahr besuchen mehrere tausend IT-Fachleute aus der gesamten Bundesrepublik unsere Seminare — in über 45 Jahren sind daraus mehr als 38.000 durchgeführte IT-Schulungen geworden.

Unser Programm

Mit über 4.250 Schulungsthemen decken wir das gesamte IT-Spektrum ab: von Administration über Softwareentwicklung, Datenbanken, Data Science und KI bis hin zu Cloud, Security und Betriebssystemen. Rund 50 Dozentinnen und Dozenten aus den verschiedensten IT-Bereichen stehen dafür mit einem außergewöhnlichen Maß an Fachkompetenz bereit — dieses Know-how bieten wir auch für Projektarbeit und Coaching an.

Unser Anspruch

Ob offenes Seminar, Firmenschulung oder Individualschulung: Unsere Teilnehmenden genießen den Rundum-Service der GFU — von der Anreise bis zur Abreise. Kleine Lerngruppen, hochqualifizierte Trainer und Fachbuchautoren, die auf individuelle Fragen eingehen, regelmäßige Pausen, gute Verpflegung und hochwertige 86"-Schulungs-Screens sind für uns selbstverständlich.

Maßgeschneiderte Weiterbildung

Sie wissen nicht, welches Thema zu Ihnen passt? Wie beim Maßschneider stellen wir gemeinsam mit Ihnen Ihr individuelles Schulungspaket zusammen — damit Ihre Weiterbildung auch nach Jahren noch perfekt sitzt.

Unsere Kunden

Zu unseren Kunden zählen Banken, Versicherungen, Handelskonzerne, Industrieunternehmen, Kommunen und öffentliche Einrichtungen aus dem gesamten deutschsprachigen Raum.

Digitale Nachweise mit OpenBadges

Mit der Ausstellung digitaler Badges über die OpenBadgeFactory machen wir erworbene Kompetenzen unserer Teilnehmenden sichtbar, verifizierbar und teilbar — ein weiterer Baustein, mit dem die GFU IT-Professionals auf ihrem Weg weiterbildet.

www.gfu.net

Seminarkatalog: www.gfu.net/seminare.html

Kriterien

1. Einführung: KI, LLMs und Ihre Java-Anwendungen
- Klärung individueller Lernziele und Erwartungen der Teilnehmer.
- Was ist Künstliche Intelligenz (KI) eigentlich? Eine kurze Einordnung.
- Large Language Models (LLMs) entmystifiziert: Was steckt dahinter für Java Entwickler?
- Kernkonzepte von LLMs aus Entwicklersicht (vereinfacht: Transformer, Attention).
- Die Evolution der LLMs und ihr wachsendes Potenzial für die Java-Anwendungsentwicklung.
- Typische Anwendungsfälle: Wann und wo ist der Einsatz von LLMs in Java-Projekten sinnvoll?
- LLMs im Vergleich zu menschlicher Intelligenz: Stärken, Schwächen und Synergien im Softwarekontext.
- Typische Limitierungen und Herausforderungen von LLMs (z.B. Bias, Halluzinationen ein erster Überblick).
- Chancen und neue Möglichkeiten durch LLM-gestützte Anwendungen im Java-Ökosystem.
2. LLMs anbinden: Provider, APIs und lokale Optionen für Java
- Überblick über führende LLM-Provider (z.B. OpenAI, Anthropic, Google) und deren Plattformen.
- Auswahlkriterien für LLM-Provider in Java-Projekten (Modellperformance, Kosten, Datenprivacy, Java-Kompatibilität).
- Verbindungsmethoden zu LLM-Services aus Java-Anwendungen:
```
      * Nutzung populärer Java-SDKs (z.B. LangChain4j, konzeptionell Spring AI - Fokus auf Prinzipien, nicht auf ein spezielles Framework).
      * Direkte API-Nutzung (HTTP-Requests, Authentifizierung, Fehlerbehandlung).
```
- Praktische Nutzung gängiger LLM-APIs mit Java (z.B. Chat Completions).
- Self-Hosting von LLMs für Java-Anwendungen:
```
      * Optionen, Werkzeuge (z.B. OpenLLM, vLLM, Hugging Face Transformers mit Inference Endpoints) und Überlegungen.
      * Vor- und Nachteile des lokalen Betriebs (Hardwareanforderungen, Wartung vs. Kontrolle, Datenschutz).
```
- Verständnis von LLM-Modelleigenschaften und deren Einfluss auf die Auswahl
- (Architekturen, Fähigkeiten, Limitierungen, Parameter wie Größe und Token-Limits).
1. Effektives Prompt Engineering für Java-Entwickler
2. Grundprinzipien des effektiven Prompt Designs: Klarheit, Spezifität, Kontext, Rollenzuweisung (Persona).
3. Das "Setup" eines Prompts: Systemnachrichten, Kontextinjektion und Stilvorgaben.
4. Die "Instruction" präzise formulieren: Aufgabenstellung für das LLM.
5. Iterative Prompt-Entwicklung und Teststrategien im Java-Umfeld.
6. Fortgeschrittene Prompting-Techniken:
```
      * Zero-Shot, One-Shot und Few-Shot Prompting.
      * Chain-of-Thought (CoT) Prompting zur Lösung komplexer Probleme.
      * Step Decomposition: Aufgaben in kleinere, handhabbare Schritte zerlegen.
```
7. Umgang mit Prompt-Beschränkungen (Token Limits) und dynamischer Kontextualisierung.
8. Struktur und Formatierung von Prompts für optimale LLM-Verarbeitung (z.B. Delimiter).
9. Kontextintegration aus Code und Dokumentation für Java-spezifische Aufgaben.
1. Output-Verarbeitung und Function Calling in Java
2. Anfordern strukturierter LLM-Outputs (z.B. JSON, XML) und deren Verarbeitung in Java.
3. Strategien zur Validierung, Bereinigung (Sanitization) und zum Mapping von LLM-Antworten auf Java-Datenstrukturen.
4. LLM Function Calling (Tool Use): Konzept, Anwendungsfälle und Implementierungsmuster in Java.
```
      * Definition von aufrufbaren Java-Funktionen/Tools.
      * Parameterübergabe, Ergebnisverarbeitung und Sicherheitsaspekte bei der
```
5. Integration mit Java Business Logic.
6. Entwurfsmuster für Real-Time LLM-Interaktionen in Java (z.B. Chatbots, virtuelle Assistenten).
```
      * Umgang mit Konversationshistorie und Session-Management.
      * Techniken zur Latenzoptimierung (z.B. Streaming vs. Batching).
```

Fortgeschrittene LLM-Architekturen: RAG und Vektordatenbanken mit Java

Retrieval-Augmented Generation (RAG):

      * Konzept, Architektur und typische Anwendungsfälle (z.B. Q&A über eigene Dokumente, aktuellere Informationen für LLMs).
      * Komponenten einer RAG-Pipeline: Datenaufnahme (Ingestion), Aufbereitung (Chunking), Indexierung, Retrieval und Augmentierung der Prompts.
      * Implementierungsmuster und Best Practices für RAG-Pipelines in Java-Anwendungen (Demonstration mit Spring AI als Beispiel).

Text Embeddings:

      * Grundlagen: Was sind Embeddings und wie repräsentieren sie semantische

Bedeutung?

      * Erzeugung von Text Embeddings mit LLMs über Java.
      * Nutzung von Embeddings in Java für Aufgaben wie semantische Suche, Dokumentenähnlichkeit und Clustering.

Arbeiten mit Vektordatenbanken in Java:

      * Vorstellung des Konzepts von Vektordatenbanken und deren Java-Anbindung (allgemein).
      * Speichern, Indexieren und Abfragen von Embedding-Sammlungen mit SQL-ähnlichen Konzepten.

Orchestrierung komplexer LLM-Workflows in Java, die Retrieval, Generierung und Post-Processing kombinieren.

6. Multimodale LLM-Anwendungen mit Java entwickeln
- Einführung in Multimodale KI: Verarbeitung von Text, Audio, Bild und Video durch LLMs.
- Potenziale und Herausforderungen multimodaler Anwendungen im Java-Kontext.
- Verarbeitung von Bild- und Video-Input in Java:
```
      * Grundlegende Techniken zur Vorverarbeitung (z.B. Resizing, Encoding).
      * Integration mit Java-Bibliotheken für Bild-/Videoverarbeitung (z.B. konzeptionell
```
- OpenCV, JavaCV).
- Sprachverarbeitung in Java-Anwendungen:
```
      * Integration von Speech-to-Text (STT) Pipelines (Audioaufnahme, Transkription).
      * Integration von Text-to-Speech (TTS) Lösungen (Sprachsynthese, Stimmanpassung).
```
- Nutzung integrierter multimodaler LLMs aus Java-Anwendungen heraus (allgemeine Konzepte).
- Vergleich: Standalone STT/TTS-Lösungen vs. direkt integrierte multimodale LLMs.
- Best Practices für die Entwicklung multimodaler Anwendungen in Java
- (I/O-Management, Concurrency, UX-Design, Barrierefreiheit).

7. Entwicklung intelligenter Agenten mit Java und LLMs

Konzepte und Architekturen intelligenter Agenten (autonom, reaktiv, proaktiv, sozial; Typen: reaktiv, deliberativ, kollaborativ, lernend).
Vorstellung von Frameworks und Bibliotheken für die Agenten-Entwicklung mit Java-Unterstützung (Überblick und Auswahlkriterien).

Design und Implementierung LLM-basierter Agenten in Java:

      * State Management und Gedächtnis (Kurzzeit, Langzeit).
      * Prompt Engineering für Agenten-Aufgaben und Multi-Step Reasoning.
      * Nutzung von Function Calling für Tool-Interaktion.
      * Antwortvalidierung und Ergebnisverarbeitung.

Model Context Protocol (MCP):

      * Einführung in das MCP als Standard für Tool- und Datenintegration.
      * Entwicklung eines eigenen MCP-Servers in Java (Beispiel).
      * Clientseitige MCP-Integration in Java-Agenten zum Einbinden des eigenen Servers (Beispiel).

Grundlagen der Agent-to-Agent Kommunikation und Multi-Agenten-Systeme (MAS):

      * Kommunikationsparadigmen (z.B. Peer-to-Peer, Publish/Subscribe).
      * Überblick über Standardprotokoll-Konzepte.
      * Koordinationsstrategien in MAS.

Skalierbarkeits- und Managementaspekte für Java-Agenten (Threading, Ressourcen).

Betrieb und Optimierung von LLM-Anwendungen in Java

Performance Tuning für LLM-basierte Java-Anwendungen:

      * Techniken zur Reduktion von Inferenzlatenz (konzeptionell).
      * Strategien zur Optimierung von Durchsatz und Speichernutzung (konzeptionell).

Kostenmanagement und -optimierung:

      * Strategien zur Kostenreduktion bei LLM-Nutzung (Modellauswahl, Prompt-Optimierung, Caching).
      * Framework zur Berechnung und Schätzung von Kosten für LLM-Inferenz und -Deployment.

Modell Fine-Tuning für spezifische Java-Anwendungsfälle:

      * Grundlagen: Wann ist Fine-Tuning sinnvoll?
      * Überblick über den Fine-Tuning-Prozess (Datenvorbereitung, Training, Evaluation - ohne tiefgehende ML-Kenntnisse).
      * Parameter-effiziente Fine-Tuning Methoden (z.B. LoRA - konzeptionell).

Umgang mit API Rate Limits und Quotas von LLM-Providern.
Strategien zur Orchestrierung von LLM-Aufrufen und komplexen Workflows.
Konzepte zur Multi-Provider-Nutzung (z.B. für Failover, Kostenoptimierung).
Logging und Monitoring von LLM-Interaktionen und Performance in Java-Anwendungen.

Herausforderungen, Sicherheit und Integration in bestehende
Java-Systeme

Umgang mit typischen LLM-Herausforderungen:

      * Erkennen und Mitigieren von Halluzinationen und Bias.
      * Strategien zum Umgang mit veraltetem Wissen der Modelle.

Robuste Fehlerbehandlung in LLM-basierten Java-Anwendungen:

      * Identifizierung und Kategorisierung gängiger LLM-Fehlermodi.
      * Implementierung von Retry-Mechanismen und Fallback-Strategien.

LLM-spezifische Sicherheitsrisiken und Gegenmaßnahmen in Java:

      * Prompt Injection: Angriffsvektoren und Verteidigungsstrategien.
      * Schutz vor Data Poisoning und Model Theft (konzeptionell).
      * Input-Validierung und Sanitization zur Absicherung von LLM-Interaktionen.
      * Content Moderation und Output-Filterung zur Einhaltung von Richtlinien.

Architekturmuster und Best Practices für die Integration von LLM-Funktionen in bestehende Java-Enterprise-Systeme.

1. Recht, Compliance, Testing und Ausblick für LLM-Anwendungen in Java
2. Rechtliche Rahmenbedingungen:
```
      * Der EU AI Act: Relevanz, Risikoklassen und Anforderungen für die Entwicklung von LLM-Anwendungen in Java.
      * DSGVO-Compliance: Datenschutzaspekte bei der Verarbeitung von (potenziell) personenbezogenen Daten mit LLMs in Java-Anwendungen.
```
3. Testing und Evaluierung von LLM-basierten Java-Systemen:
```
      * Methoden und Strategien zur Überprüfung von Genauigkeit, Kohärenz, Bias und Sicherheit der LLM-Outputs.
      * Ansätze für Regressionstests und Integrationstests im Java-Kontext.
```
4. Abgrenzung der Schulung (Zusammenfassung der Alleinstellungsmerkmale und des Fokus).
5. Zukünftige Entwicklungen und Trends im Bereich LLMs und Java-Anwendungsentwicklung.
6. Ethische Überlegungen und verantwortungsvoller Umgang mit LLM-Technologie.
7. Raum für praktische Übungen und Projekte (z.B. Entwicklung eines RAG-basierten Chatbots, Implementierung eines Agenten, Testen einer LLM-Integration - je nach Zeit und Teilnehmerinteresse).
8. Abschlussdiskussion, Feedback und nächste Schritte für die Teilnehmer.