# Changelog (/docs/changelog) import { ChangelogTimeline } from "@/changelog/changelog-timeline"
# Willkommen bei LIVOI (/docs)

Willkommen bei LIVOI

Die offizielle Dokumentation zu einer Plattform, die Kommunikation neu definiert. LIVOI vereint KI, Automatisierung und Wissen - für Organisationen, die verstehen, statt nur zu reagieren.

Hier findest du alles, was du brauchst, um mit LIVOI zu starten, Integrationen zu aktivieren und die volle Kraft kontextbasierter Kommunikation zu nutzen.

Unser Ziel mit LIVOI

Kommunikation ist der Herzschlag jedes Unternehmens - aber oft laut, chaotisch und voller Reibung. LIVOI bringt Struktur in dieses Chaos, indem es Sprache versteht, Wissen verfügbar macht und Teams befähigt, aus jedem Gespräch Mehrwert zu schaffen.

Wissen sichtbar machen

LIVOI verbindet Menschen mit Wissen - in Echtzeit, kontextbezogen und verständlich. Entscheidungen werden klarer, Antworten präziser, Kommunikation messbar.

Kommunikation neu denken

Wir machen aus Gesprächen Ergebnisse. LIVOI erkennt Zusammenhänge, strukturiert Inhalte und liefert Erkenntnisse, die zählen.

Automatisierung mit Verständnis

KI, die Sprache versteht. Prozesse, die sich selbst optimieren. Mit LIVOI wird Automatisierung zu einem Erlebnis - nicht zu einer Regelkette.

„Unser Ziel ist nicht, Kommunikation zu ersetzen - sondern sie zu verstärken. LIVOI schafft Verbindungen, wo früher nur Schnittstellen waren.“
# ... wenn aus jeder Anfrage ein Abschluss wird? (/docs/use-cases/distribution) ## Sofort schneller zum Abschluss LIVOI qualifiziert Anfragen in Echtzeit, erklärt Produkte verständlich und übergibt heiß laufende Leads direkt an den Vertrieb. Ergebnis: weniger Wartezeit, weniger Reibung, mehr Umsatz.
-80%
kürzere Reaktionszeit im Erstkontakt
+30%
mehr qualifizierte Leads in 4 Wochen
\~3 Min.
durchschnittliche Antwortzeit auf Produktfragen
## User Story: Vertrieb im Einsatz Montagmorgen bei TechTrade Solutions - einem mittelständischen B2B-Unternehmen im Bereich Industrietechnik. Im Posteingang: Dutzende Kundenanfragen, Preisvergleiche, Terminwünsche. Früher bedeutete das: manuelles Nachschlagen in Produktdatenblättern, Mails zwischen Vertrieb und Technik und Wartezeiten für Kunden. Das Vertriebsteam wollte schneller reagieren - ohne den persönlichen Kontakt zu verlieren. Gerade im Erstkontakt entscheidet die Reaktionszeit häufig über den Auftrag. Mit wachsendem Anfragevolumen kam das Team an Grenzen. ## 15-Sekunden-Demo: So fühlt sich der Unterschied an Echtzeit-Antworten, klare Entscheidungshilfen, nahtlose Übergabe an den Vertrieb. Die folgenden Chatnachrichten dienen ausschließlich als vereinfachte Beispiel-Darstellung.\ Sie zeigen typische Abläufe zwischen mehreren LIVOI-Agenten, nicht die tatsächlichen Systemausgaben. Hallo, ich interessiere mich für eure Industrieluftfilter - was unterscheidet die Modelle XF200 und XF300? Die XF200 ist für kleinere Produktionsräume gedacht (bis 500 m³/h).
Die XF300 schafft 1.200 m³/h, hat ein digitales Kontrollsystem und ist besonders wartungsarm.
Möchtest du weitere Vergleichsdaten oder direkt den Kontakt zu einem Experten?
Ja, bitte den Kontakt, ich interessiere mich für den XF300. Gerne! Dein Ansprechpartner für die XF-Serie ist:
Max Schneider - Vertriebsingenieur
E-Mail: [max.schneider@techtrade.de](mailto:max.schneider@techtrade.de)
Telefon: +49 2933 78 459 - 99
## Was sich im Alltag wirklich ändert
Vorher
  • Lange Reaktionszeiten auf Kundenanfragen
  • Zerstreute Kommunikation über viele Kanäle
  • Kunden warten auf Rückmeldung oder Ansprechpartner
  • Wichtige Infos gehen im Alltag verloren
Nachher mit LIVOI
  • Sofortige Antworten aus dem zentralen Wissensfundus
  • Klare Kommunikation über Web, Teams und WhatsApp
  • Automatische Weiterleitung an den richtigen Ansprechpartner
  • Jede Anfrage dokumentiert und nachvollziehbar
## So läuft eine Anfrage durch Von der ersten Frage bis zur qualifizierten Übergabe an den Vertrieb. B[Verstehen & Einordnen] B --> C[Antwort aus Wissensbasis] C --> D{Bedarf erkannt?} D -- Nein --> E[Abschluss mit Info/Follow-up] D -- Ja --> F[Vorqualifizierung
Fragen & Vergleich] F --> G[Lead mit Kontext an Vertrieb] `} /> ## Häufige Einwände - kurz beantwortet
Ja. LIVOI übernimmt die Vorqualifizierung und liefert klare Infos. Sobald echtes Kaufinteresse erkennbar ist, wird ein Experte eingebunden - inklusive Gesprächsprotokoll und Bedarf. Nein. LIVOI arbeitet mit bestehenden Systemen. Produktdaten kommen aus eurer Wissensbasis.
# ... wenn wir der KI beim Denken zusehen könnten? (/docs/use-cases/qa-and-monitoring-dashboard) ## Wenn KI-Ergebnisse nachvollziehbar werden Je stärker KI-Systeme in Prozesse eingebunden sind, desto wichtiger wird Transparenz.\ Wie gut sind die Ergebnisse wirklich? Welche Agenten liefern stabile Trefferquoten? Wo entstehen Fehler, Verzögerungen oder manuelle Eingriffe? Das **LIVOI QA- & Monitoring-Dashboard** beantwortet genau diese Fragen.\ Es visualisiert Leistung, Nutzung und Qualität in Echtzeit – klar, überprüfbar und für den Verantwortlichen jederzeit nachvollziehbar. ## Grundprinzip: Kontrolle schafft Vertrauen Das Dashboard sammelt alle Metriken aus der LIVOI-Plattform:\ Antwortzeiten, Fehlerraten, Trefferquoten, Nutzungsfrequenz und Audit-Logs.\ Über eine zentrale Oberfläche lassen sich Trends erkennen, Abweichungen frühzeitig entdecken und Optimierungen gezielt steuern. Datenbasis ist das **JSON-Logging** aus allen Agenten – verdichtet, ausgewertet und visuell aufbereitet im Monitoring-Modul.\ So entsteht ein vollständiges Bild der Systemqualität, ohne zusätzlichen Aufwand im Tagesgeschäft.
Trefferquoten & Fehlerraten

Erfasst, wie oft Agentenantworten korrekt oder unvollständig waren – aufgeschlüsselt nach Typ und Quelle.

Antwortzeiten & Performance

Überwacht Reaktionszeiten der Agenten, erkennt Engpässe und zeigt Optimierungspotenziale auf.

Nutzungs- und Aktivitätsanalyse

Zeigt, welche Agenten wie häufig genutzt werden und in welchen Kontexten der größte Mehrwert entsteht.

Audit-Trail & Nachvollziehbarkeit

Jeder Schritt wird automatisch dokumentiert – wer hat was freigegeben, verändert oder ausgelöst.

## 15-Sekunden-Demo: So sieht Transparenz in Echtzeit aus Die folgenden Nachrichten zeigen ein vereinfachtes Beispiel, wie das LIVOI QA-Dashboard Daten auswertet und aufbereitet. Zeig mir bitte die aktuelle Trefferquote der Kommunikations-Agenten. Die durchschnittliche Trefferquote im letzten Zeitraum beträgt **92,4 %**.
  • Kommunikations-Agent: 94,1 %
  • Vertriebsagent-Agent: 89,7 %
  • Produktberater-Agent: 93,3 %

Quelle: Auswertung der Logs der letzten 7 Tage.
Und wie sieht es mit den Fehlern im letzten Lauf aus? Letzte 24 Stunden: * 3 Validierungsfehler (fehlende Pflichtfelder) * 1 Kommunikationsfehler (Timeout bei API-Aufruf) * 0 kritische Abbrüche

Gesamte Systemverfügbarkeit: **99,2 %**
## Was sich im Alltag ändert
Vorher
    * Keine zentrale Übersicht über KI-Leistung * Fehler wurden erst spät erkannt * Optimierung nur reaktiv möglich
Nachher mit LIVOI
    * Echtzeit-Einblicke in Qualität und Nutzung * Vollständige Audit-Trails und Nachvollziehbarkeit * Klare Entscheidungsbasis für Optimierungen
## Vorteile auf einen Blick * Zentrale Qualitätsüberwachung aller LIVOI-Agenten * Live-Metriken für Leistung, Trefferquote und Laufzeit * Audit- und Freigabeverfolgung für vollständige Transparenz # ... wenn Wissen sich selbst organisiert? (/docs/use-cases/central-knowledge-base-integration) ## Wenn Informationen nicht mehr gesucht, sondern gefunden werden Wissen steckt in jedem Unternehmen - verteilt über ERP, Dateiablagen, E-Mails oder Projektdokumente.\ Das Problem: Niemand hat alles im Blick, vieles muss doppelt erklärt oder nachgefragt werden. **LIVOI** bündelt all diese Informationen an einem Ort, macht sie semantisch durchsuchbar\ und stellt sie jedem Agenten im System kontextbasiert zur Verfügung. Das Ergebnis: Antworten in Sekunden, nachvollziehbar, aktuell und aus verlässlicher Quelle. ## Grundprinzip: Vernetztes Wissen durch offene Schnittstellen Die LIVOI arbeitet mit bestehenden IT-Systemen, nicht gegen sie.\ Sie integriert sich über Schnittstellen - also über **APIs, Exporte oder Datenbankzugriffe**, die von den angebundenen Systemen bereitgestellt werden. Dabei gilt:\ Die Quellsysteme liefern die Daten.\ **P-CATION** entwickelt die passenden **Connectoren und API-Adapter**, die diese Daten automatisch einlesen, interpretieren und für LIVOI nutzbar machen -\ sicher, strukturiert und selbstverständlich DSGVO-konform. So entsteht eine zentrale Wissensbasis, die mit dem Unternehmen wächst - ganz ohne Systembruch oder Medienwechsel.
Daten aus verschiedenen Quellen

ERP-Daten, Dokumente, Mails oder Anleitungen werden über API oder Export-Schnittstellen regelmäßig abgerufen.

Strukturierung & Embedding

Inhalte werden automatisch in sinnvolle Abschnitte zerlegt („Chunking“) und vektorisiert, um sie semantisch durchsuchbar zu machen.

Zentrale Wissensbasis

Alle Informationen fließen in einen zentralen Wissensspeicher, auf den jeder LIVOI-Agent zugreifen kann.

Kontrollierte Aktualisierung

Änderungen werden regelmäßig synchronisiert - z. B. über Zeitstempel, Hash-Vergleiche oder Änderungsereignisse der Quellsysteme.

## 15-Sekunden-Demo: So funktioniert zentralisiertes Wissen Die folgenden Chatnachrichten zeigen beispielhaft, wie Daten aus angebundenen Systemen in der Knowledge Base zusammengeführt und genutzt werden können. Zeig mir bitte die letzten fünf Serviceberichte zu Produkt X. Ich habe die fünf neuesten gefunden:

1. 15.10.2025 - Austausch Sensorik 2. 22.10.2025 - Kalibrierung erfolgreich 3. 02.11.2025 - Hinweis auf Wartungsintervall 4. 03.11.2025 - Softwareupdate Version 4.1 5. 04.11.2025 - Ersatzteilmeldung abgeschlossen
Daten-Connector-Agent → Wissensdatenbank-Agent Fasse bitte die häufigsten Wartungsthemen zusammen. In den letzten fünf Serviceberichten treten folgende Themen wiederholt auf: * Sensor- und Kalibrierungsprüfungen (3x) * Softwareupdates (1x) * Ersatzteilanforderungen (1x)
## Was sich im Alltag ändert
Vorher
    * Wissen verteilt auf viele Systeme und Ordner * Kein einheitlicher Zugriff oder Überblick * Informationslücken zwischen Abteilungen
Nachher mit LIVOI
    * Zentrale, kontextfähige Wissensbasis * Zugriff über alle LIVOI-Agenten und Kommunikationskanäle * API-gestützte Integration ohne bestehende Systeme zu verändern
## Vorteile auf einen Blick * Einheitliche Wissensquelle für alle Mitarbeitenden und Agenten * Nutzung bestehender ERP-, CRM- oder Dateisysteme über standardisierte APIs ## Hinweis zur Integration Damit dieses Szenario funktioniert, müssen die angebundenen Systeme **geeignete Schnittstellen (APIs, Exporte oder Datenbankzugriffe)** bereitstellen.\ **P-CATION** kann die dafür erforderlichen **Connectoren und Adapter** anhand der Schnittstellen, für LIVOI entwickeln, die diese Daten sicher und strukturiert in die **LIVOI** einfließen lassen.\ So entsteht eine Wissenslandschaft, die alle Systeme verbindet - ohne sie verändern zu müssen. Die Qualität der Antworten hängt maßgeblich von der Datenqualität in den angebundenen Systemen ab.\ Regelmäßige Pflege und Aktualisierung der Quellsysteme sind entscheidend für den Erfolg der Wissensdatenbank. # ... wenn jeder Agent weiß, was der andere schon getan hat? (/docs/use-cases/agent-switch) ## Mehrere Agenten - ein gemeinsames Gespräch In LIVOI arbeiten spezialisierte Agenten in einem gemeinsamen Chat-Kontext. Jeder Agent besitzt eine eigene Kompetenz - etwa Recherche, Analyse oder Kommunikation - und kann nahtlos auf die Ergebnisse anderer Agenten zugreifen. So entstehen fließende Abläufe ohne Informationsverlust oder Wiederholungen. ## Grundprinzip: Gemeinsames Gespräch, klare Zuständigkeiten Stellen Sie sich vor, Sie sitzen in einem Meeting mit mehreren hochspezialisierten Experten. Ein Datenanalyst, ein Kommunikationsprofi, ein Technik-Spezialist - alle an einem Tisch, alle hören aufmerksam zu. Sie erklären Ihr Anliegen einmal - und das Team versteht sofort, worum es geht. Jeder Spezialist greift automatisch den Faden des anderen auf, ergänzt mit seiner Expertise, sobald Sie ihn ansprechen, und führt die Aufgabe gemeinsam zum Ergebnis. Niemand fragt doppelt, niemand verliert den Überblick - alles läuft reibungslos und zielgerichtet. Genau dieses Prinzip nutzt LIVOI: Mehrere spezialisierte Agenten, ein gemeinsamer Kontext. Ein intelligentes -tem, das wie ein perfekt eingespieltes Team denkt, reagiert und zusammenarbeitet - schnell, präzise und ohne Informationsverlust. ### So funktioniert's:
Gemeinsamer Wissensspeicher

Alle Agenten greifen auf denselben Chat-Kontext und Wissensspeicher zu.

Spezialisierte Kompetenzen

Jeder Agent verarbeitet Anfragen entsprechend seiner Spezialisierung (z. B. Recherche, Analyse, Kommunikation, Vertrieb).

Agentenauswahl durch Nutzer

Der aktive Agent wird direkt durch den User ausgewählt.

Zentrale Ergebnisse

Ergebnisse bleiben im Chat gespeichert und stehen sofort allen anderen Agenten zur Weiterverarbeitung zur Verfügung.

Ablaufbeispiel: Vom Datensatz zur fertigen E-Mail

Der User startet mit einer Anfrage an den Informations-Agent:\ „Welche Kundenanfragen liegen diese Woche vor?“\ Der Agent liefert strukturierte Daten aus dem -tem.

Anschließend wechselt der User zum Kommunikations-Agent.\ Dieser kennt bereits das Ergebnis des Informations-Agent und erstellt daraus automatisch eine professionell formulierte E-Mail an den Kunden - ohne manuelles Kopieren oder Wiederholen.

## 15-Sekunden-Demo: So fühlt sich der Unterschied an Vom ersten Satz bis zur Einladung - LIVOI übernimmt alles. Die folgenden Chatnachrichten dienen ausschließlich als vereinfachte Beispiel-Darstellung.\ Sie zeigen typische Abläufe zwischen mehreren LIVOI-Agenten, nicht die tatsächlichen Systemausgaben. Suche bitte alle hinterlegten Produktdaten und Preise für das Produkt PC-XF300. Das Modell PC-XF300 ist in drei Varianten verfügbar: * Standard: 1.890 € * Pro: 2.350 € * Pro XL: 2.790 €\ Lieferzeit: 5-7 Werktage, Express möglich. Wissensdatenbank-Agent → Vertriebsagent-Agent Berechne basierend auf diesen Daten ein Kundenangebot mit Standardrabatt und Expresslieferung. Standardpreis: 1.890 €\ Rabatt (5 %): -94,50 €\ Expresszuschlag: +45,00 €\ Endpreis: 1.840,50 € Vertriebsagent-Agent → Produktberater-Agent Fasse die wichtigsten technischen Vorteile des Modells zusammen - kurz und verständlich. Das Modell PC-XF300 überzeugt durch: * Hohe Energieeffizienz (A+++) * Modulares Design für einfache Wartung * Intuitive Steuerung per Touchpanel * Kompatibilität mit gängigen Schnittstellen Produktberater-Agent → Kommunikations-Agent Formuliere daraus bitte eine Angebotsmail im Stil unserer Vertriebsabteilung. Für Herr Müller. Hier ein Vorschlag:
Betreff: Ihr persönliches Angebot zum Modell PC-XF300
Guten Tag Herr Müller,
vielen Dank für Ihr Interesse am Modell PC-XF300.\ Mit diesem Gerät entscheiden Sie sich für maximale Effizienz, modernste Steuerungstechnik und ein wartungsfreundliches Design - ideal für den professionellen Einsatz mit langfristigem Mehrwert.
Ihr persönliches Angebot umfasst die Variante PC-XF300 Standard inklusive Expresslieferung, damit Sie sofort starten können.
Ihr Vorteilspreis: 1.840,50 €

Freundliche Grüße
Ihr Vertriebsteam

Was sich im Alltag ändert

Vorher
    * Jeder Mitarbeiter arbeitet in getrennten Tools * Informationen müssen mehrfach eingegeben werden * Kontext geht beim Wechsel verloren
Nachher mit LIVOI
    * Gemeinsamer Chat-Kontext für alle Agenten * Nahtlose Weitergabe von Ergebnissen * Automatisierte Workflows zwischen Spezialisierungen
## Die Vorteile im Überblick * Klare Trennung von Zuständigkeiten * Wiederverwendung desselben Kontexts ohne Datenverlust * Skalierbarkeit durch Hinzufügen weiterer spezialisierter Agenten * Konsistente Informationsbasis über den gesamten Workflow # ... wenn Dokumente sich selbst erklären? (/docs/use-cases/semantic-search-in-orderbook-and-manuals) ## Wenn Informationen gefunden werden, bevor man sie sucht Komplexe Unterlagen, technische Handbücher oder Projektanweisungen sind oft umfangreich und schwer zu durchsuchen.\ LIVOI versteht nicht nur Stichwörter - sondern auch Bedeutung, Zusammenhang und Kontext. Das Ergebnis: Die richtige Stelle, die richtige Passage, die richtige Antwort - sofort und mit Quellenangabe. *** ## Grundprinzip: Verstehen statt Suchen Stellen Sie sich vor, Sie öffnen ein Handbuch mit 300 Seiten.\ Statt mühsam nach Schlagwörtern zu filtern, fragen Sie einfach:\ „Wie kalibriere ich das System nach einer Wartung?“ LIVOI durchsucht alle relevanten Abschnitte, erkennt Synonyme, technische Begriffe und verwandte Themen -\ und liefert eine präzise Antwort inklusive Verweis auf Seite, Kapitel oder Abschnitt. So funktioniert effizientes Wissensmanagement:\ Schnell, nachvollziehbar und mit menschlich verständlichen Antworten. ***
Semantische Erkennung

LIVOI versteht die Bedeutung einer Frage - nicht nur ihre Schlüsselwörter.

RAG-gestützte Suche

Durch Retrieval-Augmented Generation werden Textpassagen aus Dokumenten kontextbasiert gefunden und ergänzt.

Nachvollziehbare Quellen

Jede Antwort enthält den Verweis auf das Originaldokument, Kapitel oder die Seite der Quelle.

Kontinuierliche Aktualisierung

Neue Dokumente werden automatisch in den Wissensspeicher integriert, ohne Neu-Training.

*** ## 15-Sekunden-Demo: So fühlt sich der Unterschied an Die folgenden Chatnachrichten dienen als vereinfachte Darstellung typischer Abläufe.\ Sie zeigen, wie LIVOI kontextbezogene Antworten aus umfangreichen Dokumenten generiert. Wie kalibriere ich das System nach einem Wartungsdurchlauf? In der Anleitung Systemhandbuch V3.2 wird die Kalibrierung im Abschnitt 5.4 "Wartung & Justierung" beschrieben:

> „Nach Abschluss der Wartung führen Sie die automatische Kalibrierung über das Menü 'Service > Kalibrierung starten' durch.\ > Prüfen Sie anschließend die Nullstellung der Sensoren gemäß Tabelle 5.2.“

Quelle: Systemhandbuch\_V3.2.pdf - Seite 134
Wissensdatenbank-Agent → Kommunikations-Agent Fasse die Schritte bitte kurz zusammen und formuliere sie verständlich für das Serviceteam. Zusammenfassung für die Servicetechniker: * Menü öffnen: Service → Kalibrierung starten * Nach Abschluss Nullstellung der Sensoren prüfen (Tabelle 5.2) * Dokumentation im Wartungsprotokoll ergänzen

Quelle: Systemhandbuch\_V3.2.pdf, Abschnitt 5.4
*** ## Was sich im Alltag ändert
Vorher
    * Lange Suchzeiten in Handbüchern und PDF-Dateien * Wiederholte Fragen an Fachabteilungen * Unklare Quellen und doppelte Arbeitsschritte
Nachher mit LIVOI
    * Antworten mit nachvollziehbarer Quelle in Sekunden * Einheitliche Informationsbasis für alle Mitarbeitenden * Automatische Einbindung neuer Dokumente in die Suche
*** ## Vorteile auf einen Blick * Präzise Ergebnisse aus langen Dokumenten * Quellennachweis für Vertrauen und Nachvollziehbarkeit * Nutzung vorhandener PDFs, Handbücher oder Anleitungen ohne Neuformatierung * Skalierbar für alle Unternehmensbereiche # Kennen Sie das ... (/docs/use-cases/use-cases)
Jeden Tag wiederkehrende Abläufe, Mails, Chats, Rückfragen - und doch zieht sich jede Antwort. Informationen liegen irgendwo, Zuständigkeiten sind unklar, und aus Routine wird Reibung. Genau hier beginnt LIVOI.\ Nicht mit mehr Tools oder neuen Formularen - sondern mit intelligenter Kommunikation, die versteht, was Menschen wirklich wissen oder entscheiden wollen.
„Routine bleibt - aber sie fühlt sich anders an.\ Schneller. Klarer. Verbundener.“

Vom Aha-Moment zur Anwendung

Unsere Use Cases zeigen, wie aus alltäglichen Abläufen echte Wirkung entsteht.\ Sie sind keine Checkliste - sondern Denkanstöße, wie LIVOI Kommunikation neu ordnet:

Im Vertrieb

Schneller auf Anfragen reagieren, Produkte verständlich erklären, Leads automatisch an den richtigen Ansprechpartner übergeben.

Im Kundenservice

Wiederkehrende Fragen automatisiert beantworten und dennoch den persönlichen Kontakt bewahren.

In internen Teams

Wissen, Richtlinien und Zuständigkeiten dort abrufen, wo kommuniziert wird - im Chat, nicht im Wiki.

Jeder dieser Momente steht für eine Idee:\ Wie kann Kommunikation fließen, statt blockieren?

Warum Use Cases wichtig sind

Weil sie zeigen, dass es nicht um Technik geht - sondern um das Erleben von Einfachheit.\ LIVOI schafft Verbindung zwischen Mensch, Wissen und Prozess.\ Nicht theoretisch, sondern im täglichen Doing.

„Use Cases sind keine Beispiele - sie sind Einladungen, das Gewohnte neu zu denken.“

Erleben Sie, wie LIVOI wirkt

Jede Geschichte in der linken Übersicht zeigt einen anderen Blick auf dasselbe Prinzip:\ Wie Kommunikation intelligenter, schneller und wirkungsvoller werden kann.

Entdecken Sie dort praxisnahe Szenarien - vom Vertrieb über Kundenservice bis zum internen Wissenstransfer.\ Jede Seite erzählt, wie Routine zum Aha-Moment wird und wie LIVOI alltägliche Kommunikation in messbare Wirkung verwandelt.

„Nicht jedes Beispiel ist gleich -\ aber in jedem steckt derselbe Gedanke: Kommunikation, die sich weiterentwickelt.“
# ... wenn Gäste den Mittagstisch direkt im Chat sehen? (/docs/use-cases/smart-menu-assistant)

Aus Datei wird Dialog

Restaurantteams laden ihren Wochenspeiseplan im LIVOI-Frontend hoch - inklusive Datum, Gericht und Preis.\ Gäste fragen einfach im Chat nach dem heutigen Mittag oder der ganzen Woche.
-80%
weniger Rückfragen zum Mittagstisch
+100%
aktuelle Tagesinfos ohne Mehraufwand
\~10 Sek.
bis zur Antwort im Chat
## User Story: Wochenspeiseplan mit System Sonntag Abend: Das Restaurant aktualisiert seinen Mittagstisch für die kommende Woche.\ Dazu wird eine Datei zentral im LIVOI-Frontend hinterlegt.\ Gäste fragen im Chat nach dem heutigen oder morgigen Menü - und bekommen sofort eine klare, aufbereitete Antwort. ## 15-Sekunden-Demo: So klingt das im Chat Schnell, freundlich, informativ - ohne Rückfragen oder Sucherei. Die folgenden Chatnachrichten dienen ausschließlich als vereinfachte Beispiel-Darstellung.\ Sie zeigen typische Abläufe zwischen mehreren LIVOI-Agenten, nicht die tatsächlichen Systemausgaben. Hey LIVOI, was gibt’s heute zum Mittag? Heute gibt es:\ 🍝 Spaghetti Bolognese - mit frischem Parmesan und Beilagensalat — 8,20 € Und was gibt’s morgen? Morgen auf dem Mittagstisch:\ 🍛 Hähnchen-Curry mit Reis - mild gewürzt, mit Kokosmilch — 8,90 € Kann ich den Plan für die ganze Woche sehen? Klar, hier ist der aktuelle Wochenplan: 🍝 **Montag:** Spaghetti Bolognese - mit frischem Parmesan und Beilagensalat — 8,20 €\ 🍛 **Dienstag:** Hähnchen-Curry mit Reis - mild gewürzt, mit Kokosmilch — 8,90 €\ 🌶️ **Mittwoch:** Chili con Carne - herzhaft mit Rindfleisch und Mais — 8,40 €\ 🍖 **Donnerstag:** Schnitzel mit Pommes - klassisch mit Zitrone — 9,50 €\ 🐟 **Freitag:** Lachsfilet mit Reis - Zitronenbutter und Gemüsebeilage — 9,20 € ## Was sich im Alltag wirklich ändert
Vorher
    * Speisepläne als PDF oder Aushang verteilt * Gäste müssen selbst nachschauen oder anrufen
Nachher mit LIVOI
    * Upload zentral im LIVOI-Frontend * Automatisch aktuelle Antworten im Chat
## Häufige Fragen - kurz beantwortet
Im LIVOI-Frontend. Mitarbeitende laden die Datei dort hoch - z. B. als Excel-Tabelle mit Datum, Gericht und Preis. Änderungen werden durch erneuten Upload sofort im Chat sichtbar.
# ... wenn Beratungstermine sich von selbst organisieren? (/docs/use-cases/appointment-router) ## Beratungstermine - automatisch, persönlich, konversionsstark LIVOI erkennt den Beratungswunsch automatisch, leitet Interessenten an den passenden Kalender weiter und sorgt dafür, dass Erstgespräche ohne Reibung gebucht werden. Ergebnis: weniger Absprünge, schnellere Gespräche, mehr qualifizierte Leads. ## User Story: Vom Impuls zur Beratung - ohne Umwege Eine externe Person stößt auf das Produkt einer IT-Firma - über die Website, ein Webinar oder eine Empfehlung. **Früher** führte dieser Impuls über Formulare, Rückrufe und verlorene Zeit. **Heute** genügt eine Nachricht im Chat: „Ich würde mich gerne beraten lassen.“\ LIVOI erkennt die Absicht, wählt automatisch den passenden Kalender (z. B. Demo, Beratung, Workshop) und führt nahtlos zur Terminbuchung - persönlich, schnell und konversionsstark. * Intent-Erkennung in natürlicher Sprache („Beratung“, „Demo“, „Workshop“) * Automatische Zuordnung zu passenden Kalendern und Ansprechpartnern ## 15-Sekunden-Demo: So fühlt sich der Unterschied an Vom ersten Satz bis zur Einladung - LIVOI übernimmt alles. Die folgenden Chatnachrichten dienen ausschließlich als vereinfachte Beispiel-Darstellung.\ Sie zeigen typische Abläufe zwischen mehreren LIVOI-Agenten, nicht die tatsächlichen Systemausgaben. Hallo, ich habe euer Produkt gesehen und würde mich gerne genauer dazu beraten lassen. Wie läuft das ab? Hallo! Schön, dass du dich für unsere Lösung interessierst.\ Darf ich kurz fragen, worum es dir in der Beratung geht - eher um den Einsatz im Unternehmen oder um technische Details? Eher um den Einsatz - ich möchte verstehen, was LIVOI konkret für unser Marketing tun kann. Super, das ist genau das richtige Thema für ein Erstgespräch.\ Dabei geht es um Potenziale, Anwendungsbeispiele und mögliche Integrationen in eure Systeme. Klingt gut, wie kann ich so ein Gespräch vereinbaren? Dafür gibt es unseren Kalender „KI-Erstgespräch“ - dort kannst du direkt einen Termin mit einem unserer Experten auswählen.

KI-Erstgespräch öffnen
## Was sich im Alltag wirklich ändert
Vorher
    * Lange Rückruf- und Formularprozesse * Manuelle Kalenderzuordnung durch Mitarbeiter * Hoher Drop-off zwischen Interesse und Buchung
Nachher mit LIVOI
    * Automatische Intent-Erkennung („Erstgespräch/Strategie-Call“) * Direkte Terminbuchung aus dem Chat
## Häufige Fragen - klar beantwortet
Durch semantische Intent-Erkennung und konfigurierbare Regeln. Bei unklaren Fällen fragt LIVOI kurz nach, bevor automatisch der passende Kalender gewählt wird.
# Kennen Sie das ... (/docs/use-cases) ## Use Cases Entdecke, wie LIVOI in der Praxis eingesetzt werden kann. Von der Automatisierung im Vertrieb bis hin zur intelligenten Wissensverwaltung.
Wie spezialisierte Agenten in einem gemeinsamen Chat-Kontext zusammenarbeiten Automatische Zuordnung und Steuerung von Terminanfragen Wie die LIVOI Informationen aus verschiedenen Systemen bündelt Verwaltung und Automatisierung von Vertriebs- und Versandprozessen LIVOI macht komplexe Dokumente durch semantische Suche verständlich KI-gestützter Menü-Assistent zur intelligenten Benutzerführung Transparente Überwachung von KI-Qualität, Nutzung und Ergebnissen
# Error Handling (/docs/livoi-api/error_handling) import { Tabs, Tab } from "fumadocs-ui/components/tabs"; import { CodeBlock, Pre } from "fumadocs-ui/components/codeblock"; ## Fehlerstruktur Das standardisierte Schema der LIVOI-API wurde für eine klare, konsistente und effiziente Fehlerbehandlung in Integrationen entwickelt. Es ermöglicht eine präzise Fehlererkennung, eine gezielte Weiterverarbeitung und eine stabile Automatisierung von Fehlerfällen. Das Ergebnis sind geringere Wartungskosten, eine schnellere Fehlersuche und eine höhere Zuverlässigkeit in der Systemkommunikation. Die Fehlerrückgabe umfasst: * `status_code` - numerischer HTTP-Statuscode der Antwort * `status_message` - textuelle Beschreibung des Statuscodes * `errors` - Liste mit detaillierten Informationen zu Ursache und Typ des Fehlers
    {`{
        "status_code": 403,
        "status_message": "Forbidden",
        "errors": [
          {
            "info": "Access denied. You do not have permission to perform this action.",
            "type": "Exception",
            "cause": {
              "details": "Access denied. You do not have permission to perform this action."
            }
          }
        ]
      }`}
  
Alle API-Fehler folgen einem standardisierten JSON-Format für konsistente Fehlerbehandlung: ## HTTP-Statuscodes | Code | Status | Beschreibung | | :--- | :--------- | :------------------------------------------------------------------------------------------------------------------- | | 200 | OK | Standardantwort für erfolgreiche HTTP-Anfragen. Die Ressource wurde erfolgreich abgerufen oder verarbeitet. | | 201 | Created | Die Anfrage war erfolgreich und eine neue Ressource wurde erstellt. Wird typischerweise bei POST-Anfragen verwendet. | | 204 | No Content | Die Anfrage war erfolgreich, aber es gibt keinen Inhalt zurückzugeben. Häufig bei DELETE-Operationen. | | Code | Status | Beschreibung | | :--- | :------------------- | :----------------------------------------------------------------------------------------------------------------------- | | 400 | Bad Request | Die Anfrage war fehlerhaft oder unvollständig. Überprüfen Sie die übermittelten Parameter oder das JSON-Format. | | 401 | Unauthorized | Authentifizierung ist erforderlich und fehlgeschlagen oder wurde nicht bereitgestellt. Überprüfen Sie Ihre Zugangsdaten. | | 403 | Forbidden | Der Zugriff auf die angeforderte Ressource wurde verweigert. Fehlende Berechtigungen oder verbotene Aktion. | | 404 | Not Found | Die angeforderte Ressource konnte nicht gefunden werden. Überprüfen Sie die URL oder ID. | | 409 | Conflict | Die Anfrage steht im Konflikt mit dem aktuellen Zustand der Ressource. Beispielsweise existiert ein Eintrag bereits. | | 422 | Unprocessable Entity | Die Anfrage konnte syntaktisch verarbeitet werden, enthält jedoch semantische Fehler. Validierung fehlgeschlagen. | | 429 | Too Many Requests | Der Client hat zu viele Anfragen in kurzer Zeit gesendet. Rate Limit wurde erreicht. | | Code | Status | Beschreibung | | :--- | :-------------------- | :------------------------------------------------------------------------------------------------------------------------- | | 500 | Internal Server Error | Ein unerwarteter Fehler ist auf dem Server aufgetreten. Der Vorgang konnte nicht abgeschlossen werden. | | 503 | Service Unavailable | Der Server ist vorübergehend nicht verfügbar, z. B. aufgrund von Wartung oder Überlastung. Versuchen Sie es später erneut. | # Pagination (/docs/livoi-api/pagination) import { Tabs, Tab } from "fumadocs-ui/components/tabs"; ## Übersicht Die LIVOI-API verwendet ein konsistentes Seitenmodell, um große Datenmengen kontrolliert abzurufen. Das `page`-Objekt steuert dabei eindeutig, welche Ausschnitte einer Datenliste übertragen werden. * `page` gibt die Zielseite an (beginnend bei **1**) * `size` begrenzt die Elemente pro Seite * Das Offset wird automatisch berechnet * Die Response liefert Paging-Metadaten wie `total` und `has_next` ## Anfragebeispiel ```bash curl https://api.livoi.de/api/v1/dynamic/query \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_SECRET_TOKEN' \ --data '{ "query_model": "user", "query_attributes": ["id", "email", "created_at"], "page": { "page": 1, "size": 10 } }' ``` ## Responseformat ```json { "result": [], "page": { "page": "1", "size": "10", "total": "42", "has_next": true } } ``` ## Bedeutung der Paging-Parameter **`page`**\ Die aktuelle Seite der Ergebnismenge. **`size`**\ Maximale Anzahl von Einträgen pro Seite. **`total`** ```json { "formula": "total_pages = ceil(total / size)" } ``` **`has_next`** ```json { "formula": "page * size < total" } ``` ## Offset-Berechnung ```txt Offset = (page - 1) * size ``` Beispiel: `page = 3`, `size = 10` → Offset = 20\ Damit werden die Elemente **21–30** zurückgegeben. ## Beispielseiten ```json { "page": "1", "size": "10", "total": "42", "has_next": true } ``` ```json { "page": "2", "size": "10", "total": "42", "has_next": true } ``` ```json { "page": "5", "size": "10", "total": "42", "has_next": false } ``` # Authentifizierung (/docs/livoi-api/authentication) # Authentifizierung Die LIVOI API nutzt ein sicheres Token-basiertes Verfahren.\ Jede Anfrage muss einen gültigen Bearer-Token im Header enthalten: ```http Authorization: Bearer ``` Fehlt dieser Header oder ist das Format ungültig, wird die Anfrage aus Sicherheitsgründen abgelehnt. ## API-Schlüsselverwaltung API-Schlüssel können bequem über das [LIVOI Dashboard](https://app.livoi.de/settings) erstellt oder verwaltet werden: * EinstellungenSchlüssel verwalten - neue Schlüssel erzeugen oder löschen * Organisationsmitglieder - bestehende Schlüssel und Berechtigungen verwalten Nur Benutzer mit **Administratorrechten** können neue Schlüssel erstellen oder bestehende widerrufen. ## Rollen & Berechtigungen Tokens sind rollenbasiert und definieren den jeweiligen Zugriffsumfang. So behalten Administratoren die volle Kontrolle über Daten, Integrationen und Benutzerrechte. ## Sicherheit API-Schlüssel sind vertrauliche Zugangsdaten. Teile sie niemals öffentlich und speichere sie nicht in öffentlichen Repositories. 1. Den betroffenen Schlüssel im Dashboard löschen 2. Einen neuen Schlüssel erzeugen 3. Alte Referenzen ersetzen # Dynamic Query (/docs/livoi-api/dynamic_query) import { Tabs, Tab } from "fumadocs-ui/components/tabs"; import { Steps } from "fumadocs-ui/components/steps"; import { Callout } from "fumadocs-ui/components/callout"; ## Übersicht Der Endpunkt `/api/v1/dynamic/query` ermöglicht es, flexible und komplexe Datenbankabfragen direkt über ein JSON-Objekt zu definieren. Die Logik abstrahiert SQL-Befehle wie `SELECT`, `WHERE`, `JOIN`, `GROUP BY` und **Subqueries**, um Daten dynamisch, aber typsicher abzurufen. Die Dynamic-Query-Engine arbeitet auf den SQLAlchemy-Modellen u. a.: * `Tenant` (`tenants`) * `Scopes` (`scopes`) * `Agent`, `AgentTool`, `AgentPhoneNumber`, `WhatsAppTemplate` * `User`, `APIKey`, `Instruction`, `Chat`, `History`, `ToolLogs` * `File`, `FileStore` * `Calendar` * `FileAgent`, `CalendarAgent` * `AgentWhitelistEntry`, `AgentParentChild` * `AllowedExtensions` Die Modellnamen im JSON sind in der Regel die **kleinen, singularen** Varianten, z. B.: * `tenant` → `Tenant` / Tabelle `tenants` * `user` → `User` / Tabelle `users` * `file` → `File` / Tabelle `files` * `fileagent` → `FileAgent` / Tabelle `file_agents` * `history` → `History` / Tabelle `history` ## Grundstruktur der Anfrage Ein minimaler Request benötigt das Zielmodell (`query_model`) und die gewünschten Felder (`query_attributes`). ```bash curl https://api.livoi.de/api/v1/dynamic/query \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_TOKEN' \ --data '{ "query_model": "user", "query_attributes": ["id", "email"], "page": { "page": 1, "size": 10 } }' ``` ## Schema & Metadaten Um valide Abfragen zu konstruieren, bietet die API Endpunkte zur Introspektion (Discovery) an. Hiermit können verfügbare Tabellen und deren Attribute ermittelt werden. ### Verfügbare Tabellen auflisten Gibt eine Liste aller für dynamische Abfragen freigegebenen Modelle / Tabellen zurück. Optional können direkt alle Attribute mitgeliefert werden. ```bash curl 'https://api.livoi.de/api/v1/dynamic/query/tables?include_attributes=true' \ --header 'Authorization: Bearer YOUR_SECRET_TOKEN' ``` **Beispiel-Antwort:** ```json { "tables": { "tenant": [ "id", "name", "domain", "created_at", "..." ], "user": [ "id", "tenant_id", "scope_id", "email", "phone_number", "permission_level", "created_at", "last_login", "..." ], "agent": [ "id", "tenant_id", "scope_id", "name", "description", "llm_model_name", "..." ], "file": [ "id", "scope_id", "file_name", "uri", "size", "created_at", "updated_at", "..." ], "fileagent": [ "id", "agent_id", "file_id", "scope_id", "created_at", "..." ], "history": [ "id", "chat_id", "agent_id", "scope_id", "model_name", "input_timestamp", "output_timestamp", "usage_output_tokens", "..." ] } } ``` ### Attribute eines Modells abrufen Ermittelt spezifische Attribute für ein einzelnes Modell, die in `query_attributes` oder `query_filter` verwendet werden können. Beispiel für das Modell `file`: ```bash curl 'https://api.livoi.de/api/v1/dynamic/query/attributes?query_model=file' \ --header 'Authorization: Bearer YOUR_SECRET_TOKEN' ``` **Beispiel-Antwort:** ```json { "attributes": [ "id", "scope_id", "file_name", "uri", "content_type", "size", "title", "tags", "created_at", "updated_at", "..." ] } ``` ## SQL-Operationen im Detail Die API unterstützt die wichtigsten SQL-Klauseln. Hier wird erklärt, wie diese im JSON-Format abgebildet werden. Die Query-Engine unterstützt **Subqueries in `WHERE`-Bedingungen**. Subqueries können bei folgenden Operatoren verwendet werden: * `__in` * `__not_in` * `__eq` * `__ne` * `__lt` * `__lte` * `__gt` * `__gte` **Verhalten:** * Für `__in` / `__not_in` wird die Subquery direkt als Menge verwendet\ → `col IN (SELECT ...)` bzw. `col NOT IN (SELECT ...)`. * Für Vergleichsoperatoren (`__eq`, `__ne`, `__lt`, `__lte`, `__gt`, `__gte`) wird die Subquery intern auf **eine Zeile begrenzt**\ → es wird immer nur der **erste Wert** verwendet (SQL-Äquivalent: `SELECT ... LIMIT 1` als Skalarwert). Dadurch gilt: > Wenn ein Feld mit einer Subquery verglichen wird (z. B. `__eq`, `__lt`, …),\ > verwendet die Engine immer den **ersten Datensatz** der Subquery. **Beispiele:** * `id__in` mit Subquery → `id IN (SELECT file_id FROM file_agents WHERE ...)` * `created_at__gt` mit Subquery → `created_at > (SELECT created_at FROM ... ORDER BY created_at LIMIT 1)` ### 1. SELECT (Attribute & Aggregationen) Das Feld `query_attributes` bestimmt, welche Spalten zurückgegeben werden. Es entspricht dem `SELECT`-Teil einer SQL-Query. Wähle Spalten des Hauptmodells oder verknüpfter Modelle (via Punkt-Notation). Beispiel: einfache User-Liste inkl. Tenant-Domain. ```json { "query_model": "user", "joins": [ { "target_model": "tenant", "on": "tenant_id=id" } ], "query_attributes": [ "id", "email", "tenant.domain" // Zugriff auf Tenant-Tabelle ] } ``` Um Spalten umzubenennen (analog zu `SELECT col AS alias`), kann eine Liste aus Tupeln `[Ausdruck, Alias]` übergeben werden. Beispiel: Agenten mit sprechenden Aliasen: ```json { "query_model": "agent", "query_attributes": [ ["name", "agent_name"], ["tenant.domain", "tenant_domain"], ["llm_model_name", "llm_model"] ], "joins": [ { "target_model": "tenant", "on": "tenant_id=id" } ] } ``` Die API akzeptiert eine gemischte Liste aus Strings und Tupeln. Tupel folgen dem Format `['Attribut', 'Alias']`. Das Attribut kann dabei entweder ein direkter Spaltenname oder eine SQL-Aggregatfunktion sein. Verfügbare Funktionen u. a.:\ `MAX`, `MIN`, `COUNT`, `SUM`, `AVG`, `ARRAY_AGG`, `JSON_AGG`, `JSONB_AGG`, `STRING_AGG`, `VAR_POP`, `VAR_SAMP`, `STDDEV_POP`, `STDDEV_SAMP`, `BOOL_AND`, `BOOL_OR`. Beispiel: Token-Nutzung pro Modell in `history`: ```json { "query_model": "history", "query_attributes": [ "model_name", ["COUNT(id)", "message_count"], ["SUM(usage_output_tokens)", "total_generated_tokens"] ], "group_by": [ "model_name" ], "order_by": [ "-total_generated_tokens" ] } ``` ### 2. WHERE (Filterung) Das `query_filter`-Objekt übersetzt Schlüssel-Wert-Paare in SQL-`WHERE`-Klauseln. Format: `Feld__Operator`. Filter können sich auf das Hauptmodell beziehen (`email`) oder auf gejointe Tabellen (`tenant.domain`, `fileagent.agent_id`, etc.). **Verfügbare Operatoren (ohne Subquery):** | Suffix | SQL Äquivalent | Beispiel JSON | | :--------------------- | :------------------------- | :------------------------------------------- | | (kein Suffix) / `__eq` | `=` | `"status": "active"` | | `__ne` | `!=` | `"status__ne": "deleted"` | | `__lt` | `<` | `"usage_output_tokens__lt": 1000` | | `__lte` | `<=` | `"size__lte": 1048576` | | `__gt` | `>` | `"usage_output_tokens__gt": 0` | | `__gte` | `>=` | `"created_at__gte": "2024-01-01"` | | `__like` | `LIKE` (Case-sensitive) | `"file_name__like": "report_%"` | | `__ilike` | `ILIKE` (Case-insensitive) | `"email__ilike": "%@gmail.com"` | | `__in` | `IN (...)` | `"permission_level__in": ["ADMIN", "OWNER"]` | | `__not_in` | `NOT IN (...)` | `"permission_level__not_in": ["READONLY"]` | | `__isnull` | `IS NULL` / `IS NOT NULL` | `"deleted_at__isnull": true` | **Beispiel (User mit bestimmter Rolle und Login-Bedingung):** ```json { "query_model": "user", "query_filter": { "permission_level__in": ["ADMIN", "OWNER"], "last_login__gte": "2024-01-01T00:00:00Z" } } ``` *** #### Subqueries in WHERE-Bedingungen Neben einfachen Werten (`string`, `number`, `boolean`, Arrays) kann ein Filterwert auch eine **Subquery** sein. Subqueries werden als verschachteltes Objekt unter dem Schlüssel `subquery` übergeben und haben wieder die Felder: * `query_model` * `query_attributes` * optional `query_filter`, `joins`, `group_by`, `order_by`, `page` (wobei `page` in Subqueries meist keinen Sinn macht) ##### Beispiel 1: `IN (Subquery)` für Files eines bestimmten Agents Szenario: Finde alle `file`-Einträge, die einem bestimmten Agenten zugeordnet sind.\ Die Relation läuft über die N:M-Tabelle `fileagent` (`FileAgent`): * `file.id` ↔ `fileagent.file_id` * `fileagent.agent_id` ist der Agent ```json { "query_model": "file", "query_attributes": [ "id", "updated_at", "file_name", "size", ["ARRAY_AGG(fileagent.agent_id)", "agent_ids"] ], "joins": [ { "target_model": "fileagent", "isouter": true, "on": "id=file_id" } ], "query_filter": { "id__in": { "subquery": { "query_model": "fileagent", "query_attributes": ["file_id"], "query_filter": { "agent_id": [7387494553877897217] } } } }, "group_by": ["id", "updated_at", "file_name", "size"], "order_by": ["-id"], "page": { "page": 1, "size": 50 } } ``` Logisch entspricht das: > `WHERE file.id IN (SELECT file_id FROM file_agents WHERE agent_id = 7387494553877897217)` und zusätzlich wird über `fileagent` gejoint, um `ARRAY_AGG(fileagent.agent_id)` als `agent_ids` zu erhalten. ##### Beispiel 2: `NOT IN (Subquery)` Alle Files, die **keinem** Agenten zugeordnet sind: ```json { "query_model": "file", "query_attributes": [ "id", "file_name", "size" ], "query_filter": { "id__not_in": { "subquery": { "query_model": "fileagent", "query_attributes": ["file_id"] } } }, "order_by": ["-created_at"] } ``` ##### Beispiel 3: Vergleich mit dem ersten Subquery-Ergebnis Szenario: Zeige `history`-Einträge, deren `output_timestamp` **nach** dem frühesten `output_timestamp` im System liegt. ```json { "query_model": "history", "query_attributes": [ "id", "model_name", "output_timestamp", "usage_output_tokens" ], "query_filter": { "output_timestamp__gt": { "subquery": { "query_model": "history", "query_attributes": ["output_timestamp"], "order_by": ["output_timestamp"] } } }, "order_by": ["output_timestamp"] } ``` Intern entsteht so etwas wie: > `output_timestamp > (SELECT output_timestamp FROM history ORDER BY output_timestamp LIMIT 1)` Wichtig: > Wenn irgendetwas mit einer Subquery verglichen wird (`__eq`, `__lt`, etc.),\ > **nimmt die Engine immer das erste Ergebnis** der Subquery (`LIMIT 1`). ##### Unterstützte Operatoren mit Subqueries * `__in` → `col IN (subquery)` * `__not_in` → `col NOT IN (subquery)` * `__eq` → `col = (SELECT … LIMIT 1)` * `__ne` → `col != (SELECT … LIMIT 1)` * `__lt` → `col < (SELECT … LIMIT 1)` * `__lte` → `col <= (SELECT … LIMIT 1)` * `__gt` → `col > (SELECT … LIMIT 1)` * `__gte` → `col >= (SELECT … LIMIT 1)` *** ### Erweiterte Filterlogik (AND / OR, verschachtelte Bedingungen) Neben einfachen Key-Value-Filtern unterstützt die Query-Engine komplexe logische Ausdrücke.\ Damit lassen sich Bedingungen beliebig tief verschachteln und kombinieren. Es gibt zwei Grundformen: 1. **Flache Filterobjekte** (ohne `and`/`or`) 2. **Explizite Logikblöcke** mit `and` oder `or` Beide Varianten können kombiniert werden. #### Standardverhalten (implizites AND) Wenn du **nur einfache Filter** ohne `and` oder `or` angibst, werden sie automatisch mit **AND** verknüpft. Beispiel: Alle User mit `ADMIN`-Rechten, die ab 2024 erstellt wurden: ```json { "query_model": "user", "query_filter": { "permission_level": "ADMIN", "created_at__gte": "2024-01-01T00:00:00Z" } } ``` Das entspricht logisch: ```json { "query_model": "user", "query_filter": { "and": [ { "permission_level": "ADMIN" }, { "created_at__gte": "2024-01-01T00:00:00Z" } ] } } ``` #### Logische Blöcke (`and` / `or`) Beispiel: User, die entweder eine bestimmte Domain haben **oder** bestimmten Tenant-Regeln unterliegen. ```json { "query_model": "user", "joins": [ { "target_model": "tenant", "on": "tenant_id=id" } ], "query_filter": { "or": [ { "email__ilike": "%@example.com" }, { "tenant.domain__ilike": "%.acme.com" } ] } } ``` #### Kombination: flache Filter + `and`/`or` Flache Filter + Logikblock kombinieren sich zu: > (alle flachen Filter) **AND** (Logikblock) Beispiel: * Tenant-Domain `*.acme.com` * UND User muss Admin/Owner sein * UND zusätzlich (nie eingeloggt ODER sehr alter Login) ```json { "query_model": "user", "joins": [ { "target_model": "tenant", "on": "tenant_id=id" } ], "query_filter": { "tenant.domain__ilike": "%.acme.com", "and": [ { "permission_level__in": ["ADMIN", "OWNER"] }, { "or": [ { "last_login__isnull": true }, { "last_login__lt": "2024-01-01T00:00:00Z" } ] } ] } } ``` #### Multi-Depth (Joins + verschachtelte Logik) Im folgenden Beispiel: * Startmodell: `agent` * Join auf `tenant` (Mandant) * Join auf `agent_phone_numbers` (WhatsApp-Nummer) * Filter: * Entweder Tenant-Domain + LLM-Modell * oder Agent hat eine WhatsApp-Nummer mit bestimmtem Verified-Namen ```json { "query_model": "agent", "joins": [ { "target_model": "tenant", "on": "tenant_id=id" }, { "target_model": "agentphonenumber", "on": "agent_phone_number_id=id", "isouter": true } ], "query_attributes": [ "id", "name", "tenant.domain", "llm_model_name", "agentphonenumber.business_phone_verified_name" ], "query_filter": { "or": [ { "and": [ { "tenant.domain__ilike": "%.acme.com" }, { "llm_model_name": "gpt-5.1" } ] }, { "agentphonenumber.business_phone_verified_name__ilike": "%Support%" } ] } } ``` > In solchen Strukturen können ebenfalls Subqueries als Werte in den inneren Objekten verwendet werden. ### 3. JOIN (Verknüpfungen) Es findet keine implizite Auflösung von Relationen statt. Der Zugriff auf Felder anderer Tabellen (z. B. via `tenant.domain` oder `fileagent.agent_id`) erfordert, dass das Zielmodell explizit in `joins` registriert wurde. ### Target Model Das Zielmodell / Zieltabelle, das verknüpft werden soll (`target_model`), z. B. `tenant`, `fileagent`, `calendaragent`. ### ON Clause (Optional) Die ON-Bedingung legt fest, wie verknüpft wird (`on`). * **Automatisch:**\ Wird `on` weggelassen, führt das System den Join automatisch anhand von Foreign Keys zwischen Parent-Modell und Zielmodell aus. * **Explizit:**\ Format `linkes_feld=rechtes_feld`.\ Ohne Tabellenpräfix bezieht sich die linke Seite auf das Parent-Modell. Beispiel `file` → `fileagent`: * Parent: `file` * Join: `"on": "id=file_id"`\ → `files.id = file_agents.file_id` ### Join Type Mit `"isouter": true` wird ein `LEFT OUTER JOIN` erzeugt.\ Standard (`false` oder weggelassen) ist `INNER JOIN`. **Beispiel: Files inkl. zugeordneter Agenten** ```json { "query_model": "file", "joins": [ { "target_model": "fileagent", "on": "id=file_id", "isouter": true } ], "query_attributes": [ "id", "file_name", ["ARRAY_AGG(fileagent.agent_id)", "agent_ids"] ], "group_by": ["id", "file_name"] } ``` ### 4. ORDER BY (Sortierung) Sortiert die Ergebnismenge. Die Reihenfolge im Array bestimmt die Priorität. * `Feldname`: Aufsteigend (`ASC`) * `-Feldname`: Absteigend (`DESC`) Beispiel: User nach Rolle und letztem Login: ```json { "query_model": "user", "order_by": [ "permission_level", "-last_login" ] } ``` ### 5. GROUP BY (Gruppierung) Beispiel: Token-Nutzung pro Modell (siehe oben in Aggregationen) verwendet `group_by` auf `model_name`. Weiteres Beispiel: Anzahl Chats pro User: ```json { "query_model": "chat", "query_attributes": [ "user_id", ["COUNT(id)", "chat_count"] ], "group_by": [ "user_id" ], "order_by": [ "-chat_count" ] } ``` ## Vollständige Beispiele ### Beispiel 1: Klassische Abfrage ohne Subquery **Szenario:**\ Zeige alle User (`user`), die seit 01.01.2024 existieren. Hole `id`, `email`, Tenant-Domain, sortiert nach Erstellungsdatum (neueste zuerst). ```bash curl https://api.livoi.de/api/v1/dynamic/query \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_SECRET_TOKEN' \ --data '{ "query_model": "user", "query_attributes": [ "id", "email", "tenant.domain" ], "joins": [ { "target_model": "tenant", "on": "tenant_id=id", "isouter": true } ], "query_filter": { "created_at__gte": "2024-01-01" }, "order_by": [ "-created_at" ], "page": { "page": 1, "size": 25 } }' ``` ### Beispiel 2: File-Liste mit Subquery-Filter (Agent-Files) **Szenario:**\ Liste alle Files, die einem bestimmten Agenten zugeordnet sind.\ Nutze eine Subquery auf `fileagent`, um die `file.id`-Menge zu bestimmen. ```bash curl https://api.livoi.de/api/v1/dynamic/query \ --request POST \ --header 'Content-Type: application/json' \ --header 'Authorization: Bearer YOUR_SECRET_TOKEN' \ --data '{ "query_model": "file", "query_attributes": [ "id", "updated_at", "file_name", "size", ["ARRAY_AGG(fileagent.agent_id)", "agent_ids"] ], "joins": [ { "target_model": "fileagent", "isouter": true, "on": "id=file_id" } ], "query_filter": { "id__in": { "subquery": { "query_model": "fileagent", "query_attributes": ["file_id"], "query_filter": { "agent_id": [7387494553877897217] } } } }, "group_by": ["id", "updated_at", "file_name", "size"], "order_by": ["-id"], "page": { "page": 1, "size": 50 } }' ``` > Hier greift genau die Subquery-Logik: > `id__in` → `files.id IN (SELECT file_id FROM file_agents WHERE agent_id = …)`\ > Joins und Aggregationen darüber laufen wie gewohnt. ## Fehlerbehandlung Die API validiert Felder gegen die `MODEL_REGISTRY` sowie die Syntax der Anfrage. Fehler werden in einem standardisierten JSON-Format zurückgegeben. Tritt auf, wenn dem Benutzer die notwendigen Berechtigungen für die angefragte Ressource oder Aktion fehlen. ```json { "status_code": "403", "status_message": "Forbidden", "errors": [ { "info": "Access denied. You do not have permission to perform this action.", "type": "Exception", "cause": { "details": "Access denied. You do not have permission to perform this action." } } ] } ``` Tritt auf, wenn das angefragte `query_model`, ein Join-Ziel oder eine spezifische Ressource nicht in der Registry gefunden wurde. ```json { "status_code": "404", "status_message": "Not Found", "errors": [ { "info": "Requested resource could not be found.", "type": "Exception", "cause": { "details": "Requested resource could not be found." } } ] } ``` Tritt bei Validierungsfehlern auf (z. B. ungültige Attribute, falsche Datentypen oder unauflösbare `on`-Klauseln). ```json { "status_code": "422", "status_message": "Unprocessable Content", "errors": [ { "info": "Validation failed. One or more fields are invalid.", "type": "ValueError", "cause": { "details": "Validation failed. One or more fields are invalid." } } ] } ``` Ein unerwarteter Fehler auf Serverseite. ```json { "status_code": "500", "status_message": "Internal Server Error", "errors": [ { "info": "Unexpected internal server error occurred.", "type": "Exception", "cause": { "details": "Unexpected internal server error occurred." } } ] } ``` # LIVOI API (/docs/livoi-api) ## LIVOI API Nutze die LIVOI API, um deine eigenen Anwendungen zu entwickeln und LIVOI in deine bestehende Infrastruktur zu integrieren.
Offizielle API Dokumentation Informationen zur Authentifizierung bei der Livoi API Einheitliche Fehlerstruktur und Codes Erklärung der Paginierungslogik Erklärung der LIVOI API Dynamic Query
# LIVOI vs. n8n (/docs/about/livoi-vs-n8n)

Vom Workflow zur Wirkung

n8n ist ein bewährtes Werkzeug für klassische Prozess-Automatisierung - stabil, vielseitig, aber technisch gedacht. Es verbindet Systeme und Datenströme. Punkt.

LIVOI geht weiter: Es verbindet Menschen, Sprache und Wissen. Wo n8n Workflows abarbeitet, versteht LIVOI den Kontext - und reagiert intelligent. Nicht bloß „wenn X, dann Y“ - sondern „weil X, antworte so“.

„n8n automatisiert Abläufe. LIVOI automatisiert Gespräche - mit Bedeutung.“

Kernunterschiede

n8n
* Universelles Automatisierungstool mit breitem Node-Katalog * Ideal für technische Flows und Datenintegration * Visual Builder erfordert manuelle Pflege und Logikdenken * Multi-User, aber keine echte Mandanten-Isolation
LIVOI
* Kommunikationsplattform mit Fokus auf Sprache, Kontext & Automatisierung * Intelligente Agenten ersetzen manuelles Flow-Wiring * Tiefe Messenger-Integrationen mit Auth, Routing & Rückkanälen * Strikte Mandantentrennung mit Auth, RLS & Audit-Logging
Anders gesagt:\ n8n verbindet Systeme. LIVOI verbindet Kommunikation - sicher, kontextbewusst und messbar.

Wie sich LIVOI anfühlt

Keine verknoteten Flows, keine endlosen Node-Chains. Stattdessen: strukturierte Agenten, klare Ziele, messbare Wirkung. Teams steuern Kommunikation - nicht technische Abläufe.

„LIVOI ist der Schritt von Workflow zu Verständnis -\ von Technik zu echter Interaktion.“

Technischer Überblick

Kategorie n8n LIVOI
Fokus Prozess-Automatisierung Kommunikation & Kontext-Intelligenz
Design Node-basierter Flow-Builder Wizard-basierte Agentenstruktur
Integrationen Breite API-Bibliothek Tiefe Messenger-Integrationen mit Status & Rückkanälen
Skalierung Queue-Mode (Redis) Mehrstufige Worker-Cluster (Tasks · RAG · Observability)
Wissen & KI Optional über externe Nodes Integriertes RAG-System mit Echtzeit-Indexierung
Sicherheit User & Roles Mandanten-Isolation mit Auth, RLS & Audits

Das Ergebnis

n8n organisiert Prozesse. LIVOI organisiert Wirkung. Es versteht Anliegen, führt Dialoge und automatisiert Entscheidungen.

„Wenn Workflows erledigt sind, beginnt Kommunikation.\ LIVOI ist nicht die Alternative zu n8n- es ist die nächste Evolutionsstufe für KI-gestützte Kommunikation.“
# Datenfluss & Datenstandorte (/docs/about/data-flow-and-data-location)

Übersicht: Wo liegen welche Daten?

Diese Seite zeigt, wie der Datenfluss in LIVOI aufgebaut ist – von den Rohdaten bis zu den Embeddings. Der wichtigste Punkt vorweg:

Alle Rohdaten bleiben dauerhaft in deutschen Rechenzentren.
Für externe KI-Dienste (z. B. OpenAI / Azure OpenAI) werden ausschließlich vorbereitete Chunks versendet – niemals die vollständigen Rohdaten.

LIVOI unterstützt verschiedene Betriebsmodelle – von reinem SaaS bis zu kundeneigenen Azure-Umgebungen. Die folgenden Visualisierungen zeigen die Unterschiede und Datenwege.

Grundprinzip des Datenflusses

Unabhängig vom konkreten Deployment folgt LIVOI immer demselben Grundmuster:

  • Rohdatenaufnahme: Dokumente, Nachrichten oder Wissensquellen werden in deutschen Rechenzentren gespeichert.
  • Chunking: Inhalte werden in kleinere Einheiten („Chunks“) zerlegt, die nur die relevanten Textausschnitte enthalten.
  • Embedding: Diese Chunks werden an einen konfigurierten KI-Dienst (z. B. OpenAI oder Azure OpenAI) gesendet, um Embeddings zu erzeugen – mathematische Repräsentationen der Inhalte.
  • Rückführung: Die erzeugten Embeddings werden zurück in die deutsche Infrastruktur geschrieben und dort für Suche, RAG (Retrieval-Augmented Generation) und Konversationskontext genutzt.
Embeddings sind abstrahierte Vektoren und enthalten nicht mehr die Originaltexte. Eine direkte Rückrechnung zum exakten Rohtext ist nicht vorgesehen.

Enterprise Standard SaaS

Im Standard-SaaS-Modell läuft LIVOI in einer von uns betriebenen Umgebung. Die Rohdaten liegen dabei in deutschen Rechenzentren, während Embeddings optional über externe KI-Dienste erzeugt werden.

Datenfluss – Enterprise Standard SaaS

Enterprise SaaS mit Azure (Embedding-Modell in Azure)

In diesem Modell läuft LIVOI weiterhin vollständig in der von P-CATION betriebenen SaaS-Umgebung in deutschen Rechenzentren. Die Anwendung selbst befindet sich nicht in Azure. Für das Erzeugen der Embeddings wird jedoch ein Azure-OpenAI-Modell im Tenant von P-CATION genutzt. Rohdaten bleiben ausschließlich in deutschen Rechenzentren; verarbeitet werden nur vorbereitete Chunks.

Datenfluss – Enterprise SaaS Azure

Enterprise SaaS in kundeneigener Azure-Umgebung

Auch in dieser Variante wird LIVOI vollständig in deutschen Rechenzentren betrieben. Der Unterschied liegt ausschließlich in der Embedding-Strecke: Das Embedding-Modell läuft innerhalb der Azure-Subscription des Kunden. Rohdaten verbleiben dennoch vollständig in der deutschen Hosting-Zone; nur Chunks werden an das kundenseitig betriebene Modell gesendet.

Datenfluss – Enterprise SaaS Customer Azure

Enterprise Plus – SaaS Cloud Extended

In der Enterprise-Plus-Variante wird die Standard-SaaS-Architektur erweitert. Das zentrale Merkmal ist, dass das Embedding-Modell direkt im deutschen Rechenzentrum betrieben wird, beispielsweise über VLLM-basierte Self-Hosted-Modelle. Dies bietet maximale Datensouveränität und Isolation, ist jedoch mit hohem Ressourcenbedarf verbunden. Rohdaten verlassen dabei zu keinem Zeitpunkt das deutsche Rechenzentrum.

Datenfluss – Enterprise Plus SaaS Cloud Extended

Flexibilität bei der Wahl des KI-Dienstes

LIVOI ist so konzipiert, dass die Embedding-Strecke flexibel konfiguriert werden kann:

  • OpenAI (Public Cloud) – sofern erlaubt.
  • Azure OpenAI – entweder im Tenant von P-CATION oder im Tenant des Kunden.
  • Self-Hosted-Modelle – z. B. über VLLM im deutschen Rechenzentrum.
Wichtig: Die Wahl des KI-Dienstes betrifft ausschließlich die Chunks und Embeddings. Der Speicherort der Rohdaten bleibt unverändert und ausschließlich in Deutschland.

Zusammenfassung

Egal, welches Betriebsmodell gewählt wird – der Kern bleibt unverändert:

Rohdaten bleiben in Deutschland.
Nur minimierte Chunks verlassen diese Zone für das Erzeugen von Embeddings.
Die Wahl des KI-Dienstes ist flexibel – der Datenstandort der Rohdaten nicht.
# Prompting: KI gezielt steuern (/docs/about/prompting-basics) import { Tabs, Tab } from "fumadocs-ui/components/tabs"; import { Steps } from "fumadocs-ui/components/steps"; ## Was ist ein Prompt? Ein **Prompt** ist eine Eingabe, die einer KI vorgibt, **was** sie tun oder verstehen soll.\ Je klarer und strukturierter diese Eingabe formuliert ist, desto präziser wird das Ergebnis. Eine KI lässt sich gut mit einem neuen Mitarbeiter vergleichen, der zum ersten Mal eine Aufgabe erhält. Es ist ein gewisses allgemeines Vorwissen vorhanden, jedoch ohne klare Einweisung weiß auch dieser nicht, was genau erwartet wird, wie das Ergebnis aussehen soll oder welche Prioritäten gelten. Erst durch eine präzise Beschreibung von Ziel, Kontext und Vorgehensweise entsteht Verständnis - und damit die Grundlage für ein gutes Ergebnis. Beim Prompting funktioniert es genauso: Je besser eine Aufgabe angewiesen wird, desto gezielter und zuverlässiger arbeitet die KI. ### Es gibt zwei Grundarten die sich oft in Prompts wiederfinden: * **Erklärung (Kontext):** Liefert Hintergrundwissen oder Rahmenbedingungen. Beispiel: "Ein erfahrener Texter für technische Dokumentationen." * **Anweisung (Handlung):** Beschreibt konkret, was zu tun ist. Beispiel: "Eine kurze Einführung zu API-Sicherheit schreiben." #### Die Erklärung Dieser Teil liefert Hintergrund und Rahmen, dabei werden Rolle, Zielgruppe und Stil "festgelegt", aber noch konkrete Aufgabe gestellt. Definiert, aus welcher Sicht die KI antworten soll.

Beispiel:

> Du bist ein erfahrener Vertriebsprofi mit tiefem Verständnis für Kundenkommunikation, Bedarfsermittlung und lösungsorientiertes Verkaufen.

Zweck:
Steuert Perspektive, Argumentationsweise und Kommunikationsschwerpunkt.

Beschreibt, welches konkrete Ergebnis oder welche Aufgabe erreicht werden soll.

Beispiel:

> Ziel ist es, ein überzeugendes Angebot zu formulieren, das den Mehrwert des Produkts klar vermittelt und auf Kundenbedürfnisse eingeht.

Zweck:
Fokussiert die Antwort auf vertriebliche Ziele und Kundennutzen.

Legt fest, wie die KI sprachlich und emotional kommunizieren soll.

Beispiel:

> Tonfall: verbindlich, authentisch und empathisch - wie in einem beratenden Verkaufsgespräch, das Vertrauen aufbaut.

Zweck:
Sorgt für eine glaubwürdige, kundenorientierte Kommunikation.

Liefert Hintergrundinformationen über Produkt, Zielgruppe oder Situation.

Beispiel:

> Kontext: Das Angebot richtet sich an mittelständische Unternehmen im B2B-Bereich, die ihre Vertriebsprozesse digitalisieren möchten.

Zweck:
Ermöglicht präzise und bedarfsorientierte Antworten.

Legt fest, wie die Antwort strukturiert oder präsentiert werden soll.

Beispiel:

> Form: Erstelle eine klare Angebotsstruktur mit Einleitung, Leistungsbeschreibung und Abschlussformel - als formatierte Markdown-Liste.

Zweck:
Sichert professionelle Darstellung und Wiederverwendbarkeit.

Definiert optionale Einschränkungen, um den Fokus zu halten.

Beispiel:

> Grenze: Maximal 200 Wörter, keine technischen Details, Fokus auf Nutzenargumentation.

Zweck:
Hält das Ergebnis präzise, verkaufsstark und kundenorientiert.

#### Die Anweisung Erst mit einer anschließenden **Anweisung** wie: Definiere, aus welcher Sicht die KI antworten soll.\

Beispiel:

> Nimm die Rolle eines erfahrenen Vertriebsprofis mit tiefem Verständnis für Kundenkommunikation, Bedarfsermittlung und lösungsorientiertes Verkaufen ein.

Zweck:
Leite die Perspektive, Argumentationsweise und Kommunikationsschwerpunkte der Antwort ab.

Lege fest, welches konkrete Ergebnis oder welche Aufgabe erreicht werden soll.\

Beispiel:

> Formuliere ein überzeugendes Angebot, das den Mehrwert des Produkts klar vermittelt und auf Kundenbedürfnisse eingeht.

Zweck:
Steuere die Antwort auf ein klares vertriebliches Ziel und den Kundennutzen hin.

Bestimme, wie die KI sprachlich und emotional kommunizieren soll.\

Beispiel:

> Verwende einen verbindlichen, authentischen und empathischen Tonfall - wie in einem beratenden Verkaufsgespräch, das Vertrauen aufbaut.

Zweck:
Erzeuge eine glaubwürdige und kundenorientierte Ausdrucksweise.

Ergänze relevante Hintergrundinformationen über Produkt, Zielgruppe oder Situation.\

Beispiel:

> Beschreibe, dass sich das Angebot an mittelständische B2B-Unternehmen richtet, die ihre Vertriebsprozesse digitalisieren möchten.

Zweck:
Stelle sicher, dass Antworten präzise und bedarfsorientiert sind.

Gib vor, wie die Antwort strukturiert oder präsentiert werden soll.\

Beispiel:

> Erstelle eine Angebotsstruktur mit Einleitung, Leistungsbeschreibung und Abschlussformel - formatiert als Markdown-Liste.

Zweck:
Sichere eine klare, wiederverwendbare und professionelle Darstellung.

Definiere optionale Einschränkungen, um Fokus und Präzision zu gewährleisten.\

Beispiel:

> Begrenze die Antwort auf maximal 200 Wörter, vermeide technische Details und konzentriere dich auf den Nutzen.

Zweck:
Halte das Ergebnis fokussiert, präzise und verkaufsstark.

### Der Unterschied Erklärungen und Anweisungen erfüllen im Prompt-Design unterschiedliche Aufgaben: * **Erklärung:** Liefert Hintergrundwissen über Aufbau und Zweck eines Prompts. Sie richtet sich an Menschen, die verstehen sollen, *wie* ein Prompt funktioniert.\ Beispiel: "Die Rolle legt fest, aus welcher Perspektive die KI antwortet." * **Anweisung:**\ Gibt der KI konkrete Handlungsbefehle, die ihr Verhalten direkt steuern.\ Sie wird im eigentlichen Prompt verwendet.\ Beispiel: "Übernimm die Rolle eines erfahrenen Vertriebsprofis." #### Wozu dann Erklärungen Erklärungen steuern nicht die KI - sie schaffen **Verständlichkeit für Menschen**.\ Sie machen Prompt-Strukturen nachvollziehbar, wiederverwendbar und im Team einfach anwendbar. Erklärungen sind also **Dokumentation, keine Instruktion**.\ Sie halten Prompts übersichtlich, verständlich und konsistent - besonders, wenn mehrere Personen oder Systeme damit arbeiten. **Aber warum prmompten wir gerne mit Erklärungen?**
Weil sie der natürlichen Art, Wissen zu vermitteln folgen: Wir erklären Zusammenhänge, statt nur Anweisungen zu geben.\ So entsteht echtes Verständnis, nicht bloße Ausführung. Obwohl Erklärungen nicht als Instruktion gedacht sind, kann die KI sie inhaltlich deuten, wenn sie semantisch eindeutig formuliert sind. #### Warum funktioniert mein Prompt, obwohl ich hauptsächlich Erklärungen nutze? Weil moderne Sprachmodelle Erklärungen **interpretieren können**.\ Auch wenn du erklärst, *was* getan werden soll, statt es direkt anzuweisen, erkennt das Modell oft den **Zweck** durch semantische Muster und Kontextbezüge. Das bedeutet:\ Selbst erklärende Formulierungen wie "Die Rolle beschreibt, aus welcher Sicht geantwortet wird" enthalten genug Signal, damit die KI daraus ableitet: *"Ich soll diese Sicht einnehmen."* Technisch betrachtet: * Sprachmodelle gewichten Bedeutung, nicht Befehlsform. * Sie lernen aus Milliarden Beispielen, dass beschreibende Sätze oft funktionale Hinweise enthalten. * Dadurch folgt das Modell auch informellen Instruktionen, solange sie klar, konsistent und semantisch eindeutig sind. **Kurz gesagt:**\ Es funktioniert - aber nicht garantiert. Anweisungen erhöhen die Präzision, Erklärungen nur die Wahrscheinlichkeit.\ Für reproduzierbare Ergebnisse sollte dein Prompt deshalb immer **explizite Handlungsanweisungen** enthalten. ## Wie die KI Prompts versteht KI-Modelle erzeugen Text **Token für Token**, also Wortbestandteil für Wortbestandteil.\ Jedes nächste Token basiert auf der **Wahrscheinlichkeit**, mit der es am besten zu den vorherigen passt.\ So entstehen Antworten, die durch Mustererkennung - nicht durch fest programmierte Regeln - gesteuert werden. ### Kernprinzipien Das Modell folgt keiner festen Logik, sondern **statistischen Mustern**.\ Je präziser der Prompt, desto enger wird der mögliche Antwortspielraum.\ Vage Prompts erzeugen weite Streuung - klare Prompts liefern stabile Ergebnisse. Die KI berücksichtigt nur den **sichtbaren Kontext** (den Prompt plus eventuelle Verlaufseinträge wie Chat Historien oder in Ihren Assistenten hochgeladene Informationen).\ Alles außerhalb dieses Fensters existiert für sie nicht.\ Wichtige Fakten müssen also **immer explizit im Prompt stehen**. Wenn mehrere Anweisungen vorliegen, gelten folgende Prioritäten: 1. Systemvorgaben 2. Entwicklervorgaben 3. Nutzereingabe 4. Externe Dokumente oder Beispiele Widersprüche werden zugunsten der höheren Ebene aufgelöst. ### Konsequenzen für Prompts * **Eindeutigkeit schlägt Eloquenz:**\ Klare, kurze Anweisungen führen zu stabileren Ergebnissen als ausschmückende Sprache. * **Beispiele als Anker:**\ Ein Beispiel im Ziel-Format lenkt das Modell zuverlässig in die gewünschte Richtung. * **Trennung von Erklärung und Anweisung:**\ Erklärungen helfen Menschen, Anweisungen steuern die KI.\ Für produktive Prompts gilt: nur Anweisungen und Beispiele einsetzen. ### Reihenfolge und Gewichtung Die Position von Informationen beeinflusst, **wie die KI sie interpretiert**.\ Da Sprachmodelle Text von links nach rechts lesen, zählt die Reihenfolge. ### Schritt 1 - Anfang Früh platzierte Informationen bestimmen, **wie die Aufgabe verstanden wird**.\ Beispiel: > "Nimm die Rolle eines erfahrenen Vertriebsberaters …"\ > beeinflusst alle folgenden Aussagen. ### Schritt 2 - Mitte Der Mittelteil enthält Struktur und Beispiele.\ Er verliert an Gewicht, wenn danach neue oder widersprüchliche Angaben folgen. ### Schritt 3 - Ende Spät platzierte Vorgaben steuern das **konkrete Antwortverhalten**.\ Widersprechen sich Aussagen, folgt die KI meist der letzten Instruktion. **Best Practice:** * Rolle, Ziel und Kontext **am Anfang** * Struktur und Format **in der Mitte** * Kritische Regeln **am Ende** wiederholen Verstehen → Kontext → Ausführen - der die KI sicher durch den Prompt führt. Wiederholungen sind **kein Fehler**, sondern ein bewusstes Steuerungsinstrument. **Sinnvoll:** * Wenn eine Regel **nicht übersehen** werden darf (z. B. "Antworte nur im JSON-Format"). * Bei möglichen Konflikten im Prompt, um Priorität zu klären. * Wenn Stil oder Verhalten **verstärkt** werden soll ("Bleibe sachlich"). **Vermeide:** * Unterschiedliche Formulierungen mit gleicher Bedeutung. * Überbetonung mehrerer Punkte ohne klare Priorität. Tipp: Wiederhole kritische Vorgaben **einmal am Ende**, identisch formuliert. ## Zieldefinition Ein gutes Ziel beschreibt **was** erreicht werden soll und **woran** sich Erfolg messen lässt.\ Es gibt der KI eine klare Richtung und reduziert Interpretationsspielraum. ### Merkmale eines guten Ziels * **Klarer Output-Typ:**\ Definiert, was entstehen soll (z. B. Liste, Erklärung, Code, Tabelle, JSON). * **Prüfbare Qualität:**\ Legt fest, wann eine Antwort "gut genug" ist - z. B. Länge, Stil, Genauigkeit. * **Messbare Kriterien:**\ Enthält konkrete Anforderungen, an denen das Ergebnis überprüft werden kann. * **Negativabgrenzung:**\ Beschreibt, was ausdrücklich **nicht** gewünscht ist (z. B. keine Werbung, kein Smalltalk).
Für klare Ziele öffnen * [ ] Was soll erzeugt werden? * [ ] Für wen ist es gedacht? * [ ] Wie sieht das Endformat aus? * [ ] Welche Qualitätsmerkmale sind entscheidend? * [ ] Was darf ausdrücklich nicht enthalten sein?
### Beispiel für eine präzise Zieldefinition Ein unpräzises Ziel wie > "Schreibe etwas über unser Produkt" führt zu unspezifischen Ergebnissen.\ So sieht ein gutes, vollständiges Ziel aus: ## Ziel Erstelle ein überzeugendes Angebot für Produkt X, das den Mehrwert klar vermittelt\ und auf typische Kundenbedürfnisse im B2B-Bereich eingeht. ## Anforderungen * Abschnitte: Kontext, Optionen, Bewertung, Entscheidung, Risiken * Maximal 200 Wörter * Keine Annahmen oder internen Kommentare * Wenn Daten fehlen: Abschnitt "Offene Punkte" mit Stichworten ### Häufige Fehler (Anti-Patterns) * **Zu vage:**\ "Erstelle einen Text über das Produkt."\ → Unpräzise, offen, nicht steuerbar. * **Mehrdeutig:**\ "Schreibe etwas Informatives, aber kreativ."\ → Kein messbares Ziel, unklare Richtung. * **Widersprüchlich:**\ "Sei sachlich, aber emotional ansprechend."\ → Führt zu Konflikten in der Tonalität. ### Beispielvergleich **Schlecht:**\ Schreibe etwas über unser Produkt.\ → Ergebnis: beliebig, zufällig, ohne klare Zielrichtung. **Gut:**\ Formuliere eine kurze Vertriebszusammenfassung für Produkt X.\ Hebe drei Hauptvorteile für mittelständische Unternehmen hervor,\ zeige ein konkretes Anwendungsbeispiel und schließe mit einem klaren Call-to-Action.\ Maximal 150 Wörter, sachlich und verkaufsorientiert im Stil einer Angebotsmail.\ → Ergebnis: präzise, nachvollziehbar, reproduzierbar. ## Struktur und Syntax Eine klare Struktur und eindeutige Syntax sorgen dafür, dass die KI **valide und wiederverwendbare Ergebnisse** erzeugt.\ Je genauer du das gewünschte Format vorgibst, desto stabiler und automatisierbarer wird der Output. ### Warum Struktur wichtig ist * **Konsistenz:** Gleiche Eingaben liefern gleichartige Ergebnisse. * **Automatisierbarkeit:** Ergebnisse können direkt weiterverarbeitet werden (z. B. in Systemen oder Reports). * **Fehlerprävention:** Strukturen reduzieren Ausschweifungen und Formatfehler. ### Gängige Format-Optionen für Prompts #### **1. Markdown** Klar, lesbar und universell. Ideal für strukturierte Prompts mit Abschnitten, Listen und Beispielen. **Beispiel:** ```md ## Rolle Nimm die Rolle eines erfahrenen Vertriebsberaters an. ## Ziel Erstelle eine kurze Produktbeschreibung. ## Format - Titel - Drei Verkaufsargumente - Call-to-Action ``` #### **2. Plain Text** Einfach und direkt. Gut für kurze Anweisungen oder schnelle Eingaben. **Beispiel:** ``` Formuliere eine kurze Vertriebszusammenfassung für Produkt X. Hebe drei Hauptvorteile für mittelständische Unternehmen hervor, zeige ein konkretes Anwendungsbeispiel und schließe mit einem klaren Call-to-Action. Maximal 150 Wörter, sachlich und verkaufsorientiert im Stil einer Angebotsmail. ``` #### **3. XML** Lesbar und kompakt. Gut geeignet für strukturierte Prompts oder deklarative Vorgaben. **Beispiel:** ```xml Vertriebsberater Erstelle eine Produktbeschreibung Titel Drei Nutzenpunkte Call-to-Action 100 sachlich, überzeugend ``` **Fazit:** * Markdown ist ideal für strukturierte, mehrteilige Prompts. * Plain Text ist schnell und unkompliziert für einfache Aufgaben. * YAML ist nützlich, wenn du Prompts speichern, versionieren oder automatisiert weiterverarbeiten möchtest. **Hinweis für LIVOI-Nutzer:**\ Für LIVOI genügt **Plain Text** vollkommen - das System verarbeitet Prompts zuverlässig auch ohne Formatierung.\ Dennoch empfiehlt es sich, **Markdown zu verwenden**, um die Eingabe für Menschen besser lesbar und leichter wartbar zu machen. Überschriften (`##`), Listen (`-`) und Abschnitte helfen, den Prompt in logische Bereiche zu gliedern - zum Beispiel Rolle, Ziel, Kontext oder Format.\ Das erleichtert späteres **Überarbeiten, Erweitern oder Wiederverwenden** deutlich, ohne dass die technische Funktion verändert wird. ### Best Practices für Formatvorgaben * Lege Überschriften oder Feldnamen **immer im Prompt fest**. * Verwende **Beispiele im Zielformat** - sie wirken als starke Strukturanker. * Füge eine klare Anweisung hinzu, z. B.\ *"Gib ausschließlich gültiges JSON ohne Kommentare aus."* * Halte Formatvorgaben **einheitlich** über alle Prompts hinweg. # Qualitätskontrolle und Iteration Ziel: Deinen Prompt in kleinen Schritten stabilisieren. Fokus auf klaren Befunden, gezielten Änderungen und messbarer Verbesserung. * Ein Ergebnis prüfen * Eine Ursache im Prompt finden * Eine Änderung vornehmen * Neu prüfen und vergleichen * Gute Varianten festhalten ### Schritt 1 - Abweichungen erkennen * Prüfe Inhalt: Fehlt etwas oder ist etwas zu viel? * Prüfe Stil: Zu technisch, zu werblich, zu lang? * Prüfe Format: Struktur, Überschriften, Ausgabeform. * Markiere nur das konkrete Problem, nicht alles. **Mini-Check:** * [ ] Inhalt vollständig * [ ] Stil passend * [ ] Format korrekt ### Schritt 2 - Ursache im Prompt finden Ordne das Problem einer Komponente zu: * Rolle * Ziel * Kontext * Format * Grenzen **Beispiel-Zuordnung:** * Output unstrukturiert → Format schwach * Ton falsch → Rolle unklar * Infos fehlen → Kontext unpräzise ### Schritt 3 - Gezielte Anpassung Nur eine Änderung pro Iteration: * Rolle schärfen: "Nimm die Rolle eines …" * Ziel präzisieren: "Erstelle eine Übersicht in drei Punkten …" * Beispiel ergänzen * Grenze setzen: "Max. 150 Wörter, sachlich" **Beispiel-Änderung:** > Ergänze am Ende: "Gib ausschließlich eine Markdown-Liste ohne Einleitung aus." ### Schritt 4 - Vergleich und Bewertung Vergleiche alt vs. neu: * Wurde das Problem gelöst? * Nebeneffekte? * Reproduzierbarkeit gegeben? **Notizfeld:** * Änderung: … * Effekt: … * Nächster Schritt: … ### Schritt 5 - Systematisch verfeinern * Lege ein Testset mit 3-5 typischen Eingaben an. * Teste jede neue Prompt-Version dagegen. * Versioniere kurz: "v1.3 - Tonfall präziser". **Empfehlung:** * Halte funktionierende Sätze als Snippets vor. * Nutze eine einheitliche Dateistruktur für Prompts. ### Häufige Muster und Fix-Vorlagen * Zu vage: * "Schreibe etwas über das Produkt." * Wirkung: Zufällige, breite Antworten. * Mehrdeutig: * "Informativ, aber kreativ." * Wirkung: Stilkonflikte, nicht messbar. * Widersprüchlich: * "Sachlich, aber emotional ansprechend." * Wirkung: Instabiles Verhalten. * Formatfehler: * "Gib eine Liste aus" ohne Beispiel. * Wirkung: Freies Format, schwer weiterzuverarbeiten. * Ziel schärfen: * "Erzeuge eine Markdown-Liste mit drei Punkten: Nutzen, Beispiel, CTA." * Format zeigen: * "Beispiel: * Nutzen: … * Beispiel: … * CTA: …" * Stil binden: * "Ton: sachlich, keine Superlative." * Grenzen setzen: * "Max. 120 Wörter. Keine Einleitung. Keine Emojis."
Praxis-Checkliste für jeden Iterationslauf * [ ] Problem exakt benannt * [ ] Komponente identifiziert (Rolle/Ziel/Kontext/Format/Grenzen) * [ ] Genau eine Änderung vorgenommen * [ ] Ausgabe verglichen und dokumentiert * [ ] Version markiert und Snippet ggf. übernommen
# About (/docs/about) ## Über LIVOI LIVOI ist eine integrierte Plattform für die Automatisierung von Workflows und die Kommunikation mit KI-Agenten. Sie ermöglicht es Benutzern, ihre Prozesse zu automatisieren und ihre Kommunikation mit KI-Agenten zu optimieren.
Einführung in die Grundlagen der Prompting-Technik Wie funktioniert LIVOI im vergleich zu n8n? Wie LIVOI mit Daten umgeht und wo diese gespeichert werden
# WhatsApp (/docs/integrationen/whatsapp) import { MessageSquare, CheckCircle2, Info, ArrowRight, ExternalLink } from "lucide-react" ## Voraussetzungen
## Begriffserklärung Damit der Einrichtungsprozess klar nachvollziehbar bleibt, hier eine kurze Übersicht der wichtigsten Begriffe rund um die WhatsApp-Integration in LIVOI und Meta Business: * Meta Business-Konto\ Das übergeordnete Unternehmenskonto bei Meta (Facebook).\ Es dient als zentrale Plattform zur Verwaltung aller Meta-Dienste wie Facebook-Seiten, Instagram-Profile, Werbekonten - und auch WhatsApp Business-Konten.\ Hier werden Rollen, Berechtigungen und Zahlungsdaten verwaltet.\ Ohne ein *Meta Business-Konto* kann kein WhatsApp Business-Konto erstellt oder mit LIVOI verknüpft werden. * WhatsApp Business-Konto\ Dieses Konto bildet die Grundlage für die geschäftliche Nutzung von WhatsApp. Es wird innerhalb des *Meta Business Managers* erstellt und verwaltet.\ Darüber werden WhatsApp-Telefonnummern, Berechtigungen, Zahlungen und technische Verbindungen gesteuert - beispielsweise die Integration mit LIVOI. * WhatsApp-Unternehmensprofil\ Das sichtbare Profil, das Kundinnen und Kunden in WhatsApp sehen, wenn sie mit dem Unternehmen schreiben.\ Es enthält Angaben wie den Unternehmensnamen, eine kurze Beschreibung, Kategorie, Website und Kontaktdaten.\ So erkennen Kundinnen und Kunden sofort, mit wem sie kommunizieren.

Schritt-für-Schritt-Anleitung

### Den Wizard starten LIVOI Dashboard: Bereich Integrationen mit WhatsApp-Kachel und Schaltfläche Verbinden Im LIVOI Dashboard → Integrationen → WhatsApp auf Verbinden klicken. Der Pop-up-Wizard öffnet sich und führt durch die Einrichtung. ### Mit Meta Business anmelden Meta-Anmeldedialog zur Verknüpfung des WhatsApp-Unternehmenskontos mit LIVOI Mit dem Facebook-Konto anmelden, das Zugriff auf *Meta Business* hat, dann im Wizard Als ... fortfahren wählen. ### Berechtigungen prüfen und bestätigen Dialog zur Bestätigung der angeforderten WhatsApp- und Ereignisberechtigungen für LIVOI Angeforderte Berechtigungen prüfen und Los geht’s wählen. ### Business-Portfolio auswählen Auswahlansicht für Business-Portfolio und Unternehmensinformationen in Meta Das zugehörige Business-Portfolio des Unternehmens wählen und Weiter klicken. ### Neue Telefonnummer registrieren Optionen im Onboarding: bestehende App verknüpfen oder neue Telefonnummer hinzufügen Neue WhatsApp-Telefonnummer auswählen und mit Weiter fortfahren. ### Konten auswählen oder anlegen Auswahl oder Erstellung von WhatsApp Business-Konto und Unternehmensprofil Bestehendes WhatsApp Business-Konto und Unternehmensprofil wählen oder neu erstellen. * Das WhatsApp Business-Konto verwaltet Ressourcen und Abrechnung in Meta Business. * Das WhatsApp-Unternehmensprofil bestimmt die Darstellung der Telefonnummer in WhatsApp. ### Fehlende Konten anlegen Formular zur Erstellung eines Unternehmensprofils mit Feldern für Anzeigename und Kategorie Falls im vorherigen Schritt keine vorhandenen Konten ausgewählt wurden, können sie hier erstellt werden. * Sind einzelne Voraussetzungen bereits erfüllt, springt der Wizard automatisch zum jeweils nächsten erforderlichen Schritt. ### Telefonnummer hinzufügen Eingabemaske zum Hinzufügen der Telefonnummer und Auswahl der Verifizierung per SMS oder Anruf Neue Nummer hinzufügen, Telefonnummer eingeben, Verifizierungsmethode wählen und Weiter klicken. ### Verifizierungscode eingeben Feld zur Eingabe des sechsstelligen Codes nach SMS- oder Anruf-Verifizierung Den Code eingeben, der an die Telefonnummer gesendet oder telefonisch mitgeteilt wurde, anschließend Weiter wählen. ### Zugriffe bestätigen Übersichtsseite zur Bestätigung der LIVOI-Zugriffsanfrage mit aufgelisteten Berechtigungen Einstellungen prüfen und mit Bestätigen abschließen. ### Zahlungsmethode prüfen Abschlussseite mit Erfolgsmeldung, Nachrichtenlimits und Option zum Hinzufügen einer Zahlungsmethode Aktuelle Limits einsehen. Bei Bedarf eine Zahlungsmethode hinzufügen, sonst auf Fertigstellen klicken. * Eine Zahlungsmethode wird spätestens für das Versenden von Template-Nachrichten benötigt. * Anleitung:{" "} Meta Business - Zahlungsmethode hinzufügen ### Nummer mit Zwei-Faktor-Authentifizierung (2FA) verifizieren LIVOI Pop-up zur 2FA-Registrierung mit PIN-Eingabe für die verbundene Telefonnummer Nach Fertigstellen erscheint im Dashboard ein weiteres Pop-up. Aus Sicherheitsgründen wird die Telefonnummer direkt mit einem zweiten Faktor verifiziert. Der automatisch generierte PIN sollte sicher aufbewahrt werden und kann später angepasst werden. ### Nummernstatus prüfen Übersichtstabelle im LIVOI Dashboard mit WhatsApp-Nummern, Status, Namen und Aktionen Im LIVOI Dashboard → Integrationen → WhatsApp → Übersicht den Status prüfen. Grüner Haken bedeutet einsatzbereit - die Nummer kann einem Agenten zugewiesen werden.
## 🎉 Glückwunsch! Die WhatsApp-Telefonnummer wurde erfolgreich mit LIVOI verknüpft!\ Sie ist nun vollständig einsatzbereit und kann direkt einem Agenten zugewiesen werden.
* Im LIVOI Dashboard den gewünschten Agenten auswählen und die verknüpfte Nummer zuweisen. * Optional: Nachrichtenvorlagen erstellen oder bestehende Templates importieren. * Testnachricht senden, um die erfolgreiche Verbindung zu überprüfen.
# Übersicht (/docs/integrationen) import { Plus } from 'lucide-react' ## Integrationen Mit LIVOI lassen sich externe Kommunikationsdienste über standardisierte Schnittstellen anbinden. Die Integration erfolgt über isolierte, zustandslose Adapter, die Nachrichten bidirektional zwischen dem jeweiligen Dienst (z. B. WhatsApp Business API) und dem LIVOI-Kernsystem austauschen. ## Aktuell verfügbare Integrationen
WhatsApp Business Logo

WhatsApp Business

Automatisiere Kundengespräche, versende Benachrichtigungen und verwalte Anfragen - direkt über dein LIVOI-System. Vollständig DSGVO-konform und mit End-to-End-Verschlüsselung.

Plug and Play
{/* Microsoft Teams */}
Microsoft Teams Logo

Microsoft Teams

Verbinde dein LIVOI-System mit Microsoft Teams über die LIVOI Teams App, um Nachrichten und Benachrichtigungen direkt in Teams zu empfangen. Dokumentation noch nicht verfügbar.

Plug and Play
{/* DATEV Unernehmen Online */}
DATEV Logo

DATEV Unternehmen Online

Übergib Rechnungsdaten automatisch an DATEV Unternehmen Online und verschicke E-Rechnungen direkt aus LIVOI.

🚧 Bald verfügbar

Weitere Dienste in Planung

Telegram, E-Mail, Slack und mehr - coming soon. Hast du einen Wunsch? Sag uns Bescheid!

# Microsoft Agent Builder vs. LIVOI Agents – Welche KI-Agenten-Lösung passt zum Mittelstand? (/blog/2026-01-28-microsoft-agent-builder-vs-livoi-agents) ## Welche KI-Agenten-Lösung passt zum Mittelstand? In Gesprächen mit Unternehmen taucht aktuell immer häufiger dieselbe Frage auf:\ **Reicht der Microsoft Agent Builder aus – oder ist eine spezialisierte Lösung wie LIVOI die passendere Option?** Die Antwort hängt weniger an einzelnen Funktionen, sondern vor allem daran, * **wo** der Agent eingesetzt werden soll, * **welche Daten** er nutzen darf, * und wie wichtig **Datenschutz, Kontrolle und Prozessintegration** sind. Dieser Beitrag ordnet beide Ansätze ein und hilft bei der Entscheidung. ## Was ist Microsoft Agent Builder? Microsoft Agent Builder ist eine Funktion, mit der sich eigene KI-Agenten erstellen lassen, um Aufgaben zu unterstützen und Informationen bereitzustellen. Der Fokus liegt darauf, **schnell und flexibel eigene Agenten aufzubauen**, meist innerhalb bestehender Microsoft-Umgebungen. Er eignet sich besonders, wenn: * Unternehmen zügig starten möchten, * der Agent in einem klar abgegrenzten Rahmen arbeitet, * und erste Agenten-Szenarien erprobt werden sollen. Für viele mittelständische Unternehmen ist das ein **praktikabler Einstieg**, um Erfahrungen mit KI-Agenten zu sammeln und einfache Use Cases umzusetzen. ## Was ist LIVOI? **LIVOI** ist eine unternehmensspezifische KI-Kommunikationsassistenz, die gezielt für typische Einsatzfälle im Mittelstand entwickelt wurde. Der Fokus liegt dort, wo Kommunikation Zeit kostet oder Leads verloren gehen können, zum Beispiel: * beim Erstkontakt, * bei Kunden- und Interessentenfragen, * in Terminprozessen, * im Onboarding, * oder bei wiederkehrenden internen Rückfragen. Ein zentraler Unterschied liegt weniger im Begriff „Agent“, sondern im **Bereitstellungsmodell**. LIVOI wird **als direkt einsetzbares Paket** umgesetzt. Der Agent wird gezielt für einen konkreten Bereich und einen klar definierten Use Case aufgebaut und so bereitgestellt, dass **keine zusätzliche Entwicklungs- oder Aufbauarbeit** im Unternehmen nötig ist. Kund:innen erhalten ein fertiges Setup von P-CATION, das: * auf den gewünschten Einsatzbereich zugeschnitten ist, * definierte Regeln und Übergaben enthält, * und organisatorisch eingebettet wird. Zusätzlich: * LIVOI wird in **Deutschland betrieben**, * verarbeitet Daten **DSGVO-konform**, * läuft in einer **getrennten, geschützten Umgebung**, * und nutzt gezielt **Ihr Unternehmenswissen**, statt allgemeine Antworten zu erzeugen. ## Entscheidungshilfe: 5 Fragen zur Orientierung Die folgenden Fragen helfen dabei, die passende Richtung zu bestimmen: 1. Soll der Agent in der **Kundenkommunikation** eingesetzt werden, zum Beispiel für Erstkontakt, Rückfragen oder Qualifizierung? 2. Soll die KI **konsequent aus Ihrem Unternehmenswissen** antworten, statt allgemein zu formulieren? 3. Sind Anforderungen wie **Hosting in Deutschland** und **DSGVO-konformer Betrieb** für Sie wichtig? 4. Benötigen Sie **klare Regeln**, definierte Übergaben und nachvollziehbare Kommunikation? 5. Soll der Agent **konkrete Szenarien** abdecken – etwa Terminbuchung, Onboarding oder Vertriebsunterstützung – und als **fertiges Paket** bereitgestellt werden? Wenn Sie statt eines Baukastens eine **direkt einsatzfähige Lösung** suchen, ist LIVOI die passende Richtung.\ LIVOI wird für einen konkreten Bereich und Use Case zugeschnitten aufgebaut und als fertiges Paket bereitgestellt, sodass Ihr Team keine zusätzlichen Entwicklungs- oder Aufbauarbeiten übernehmen muss. ## Fazit Microsoft Agent Builder ist eine gute Möglichkeit, **eigene KI-Agenten zu erstellen** und erste Szenarien in einem klar abgegrenzten Rahmen umzusetzen. LIVOI ist eine Option für Unternehmen, die eine **KI-Assistenz für konkrete mittelständische Einsatzbereiche** suchen – zugeschnitten umgesetzt, organisatorisch eingebettet und direkt nutzbar. Je nach Anforderungen inklusive **DSGVO-konformem Betrieb** und **Hosting in Deutschland**. Wenn Sie gerade überlegen, womit Sie starten sollten, lohnt sich ein kurzer Use-Case-Check:\ **Welche ein bis zwei Szenarien bringen Ihnen in 30 Tagen messbare Entlastung?**\ Daran sollte sich die Entscheidung orientieren. [Erstbesprechung vereinbaren](https://calendar.google.com/calendar/u/0/appointments/schedules/AcZssZ0RYHNxC2ckSW9YDZRVSQKrXrkDyfcm3WfR6PguUYnc2hHfJlp8gJG29WqPbMGLksxYsUt-Agvg) # Warum MCP gerade so viele Diskussionen auslöst (/blog/2025-12-04-warum-mcp-gerade-so-viele-diskussionen-ausloest) ## Ein Protokoll im Wandel Das **[Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro)** wurde entwickelt, um KI-Modelle mit externen Werkzeugen zu verbinden. Die Grundidee ist einfach:\ Ein Modell soll nicht nur Text verstehen, sondern auch Tools nutzen können, die Daten liefern, Berechnungen ausführen oder externe Systeme ansprechen. Doch während MCP wächst, zeigt sich ein grundlegendes Problem, das nicht technischer Natur ist, sondern struktureller. Viele Menschen sehen nur die Oberfläche – Tools funktionieren, die KI antwortet – aber der eigentliche Aufwand versteckt sich im Hintergrund. MCP wirkt elegant, erzeugt aber im System Prompt enorme Zusatzlast, weil Tool-Definitionen immer mitgeschickt werden müssen. ## Warum der System Prompt überläuft Ein KI-Modell funktioniert nur zuverlässig, wenn es genaue Informationen erhält. MCP setzt darauf, dass **alle Tool-Beschreibungen, Regeln und Beispiele direkt in den System Prompt geschrieben werden**. Genau dort entsteht das Kernproblem: Je mehr Tools ein Projekt verwendet, desto mehr Prompt-Platz wird benötigt.\ Der verfügbare Kontext schrumpft – und damit oft auch die Qualität der Antworten. Man kann sich das vorstellen wie eine Tasche, die man vor jedem Gespräch füllen muss. Anfangs ist das noch überschaubar. Doch bald steckt darin: * die Systemanweisungen * jede einzelne Tool-Definition * Formatregeln * Anwendungsbeispiele * technische Einschränkungen …bis irgendwann kaum noch Platz für die eigentliche Unterhaltung bleibt. ### Ein weiterer, oft unterschätzter Punkt: Kosten Da MCP **immer sämtliche Tooldefinitionen bei jedem einzelnen Request mitsendet**, steigt nicht nur die technische Last, sondern auch der Preis pro Anfrage.\ Mehr Prompt-Token bedeuten schlicht höhere Betriebskosten – unabhängig davon, ob ein Tool im Gespräch überhaupt gebraucht wird. Gerade bei komplexen oder umfangreichen Toolsets kann diese permanente Grundlast zu einem erheblichen Kostenfaktor werden, der die Skalierbarkeit stark beeinflusst. ## Wie sich die Branche versucht zu behelfen Inzwischen entstehen neue Ansätze, die versuchen, die wachsende Komplexität zu umgehen.\ Ein Beispiel ist Anthropics Konzept der **[Advanced Tool Use](https://www.anthropic.com/engineering/advanced-tool-use)**. Dabei wird ein Teil des MCP-Problems einfach verschoben: Das Modell bekommt nur eine kleine Info: „Es gibt Tools.“ Das Modell schreibt Code, der in einer isolierten Umgebung ausgeführt wird. Dieser Code ruft eine Art Tool-Suchdienst auf. Erst jetzt kommen die vollständigen Tool-Beschreibungen ins Spiel. Die KI erhält die relevanten Daten – aber erst nach mehreren Zwischenschritten. Das entlastet den Prompt, erweitert aber die Architektur um neue Schichten.\ Ob das langfristig einfacher wird oder nur „anders komplex“, ist eine offene Frage. ## Eine Übergangsphase Die gesamte KI-Tooling-Landschaft ist momentan im Umbau. MCP ist weder falsch noch perfekt – es ist ein Teil dieses Übergangs.\ Vieles entsteht gerade erst, manches wird in ein paar Monaten schon wieder anders aussehen. Wichtig ist vor allem zu verstehen:\ Die KI-Welt sucht noch nach stabilen Standards. Experimente gehören dazu. ## Unser Blick bei P-CATION Für **LIVOI** setzen wir auf nachhaltige technische Entscheidungen. Nachhaltigkeit bedeutet für uns auch, Architektur so zu wählen, dass sie nicht beim nächsten Trend komplett ersetzt werden muss. Wir beobachten MCP und seine Alternativen genau – ohne voreilige Schlüsse.\ Denn klar ist: Die besten Lösungen entstehen selten in Momenten des größten Umbruchs, sondern wenn sich der Staub wieder etwas gelegt hat. # AI Act 2026: Was jetzt auf Unternehmen zukommt – und was das für LIVOI bedeutet (/blog/2026-01-27-ai-act-was-jetzt-auf-unternehmen-zukommt) ## AI Act 2026: Warum „einfach ausprobieren“ nicht mehr reicht Viele Unternehmen nutzen heute bereits KI – oft ganz selbstverständlich. Mal als Assistent im Arbeitsalltag, mal als Tool im Marketing, Vertrieb oder Kundenservice. Was dabei lange möglich war, wird sich in den kommenden Jahren ändern. Mit dem **EU AI Act** wird erstmals verbindlich geregelt, **wie KI organisiert, dokumentiert und verantwortet eingesetzt werden muss**. Spätestens ab 2026 reicht es nicht mehr aus, KI nur „nebenbei“ zu nutzen. Dieser Beitrag gibt einen kompakten Überblick: * Was der AI Act in Kurzform bedeutet * Welche Themen für Unternehmen wichtig werden * Was das speziell für den Mittelstand heißt * Und welche Rolle eine KI-Kommunikationsassistenz wie **LIVOI** dabei spielt ## Was ist der EU AI Act in Kurzform? Der EU AI Act ist die europäische KI-Verordnung. Sein Grundprinzip ist einfach: > **Je höher das Risiko eines KI-Einsatzes für Menschen und Grundrechte, desto strenger die Anforderungen.** Nicht jede KI gilt automatisch als Hochrisiko-System. Aber: **Alle Unternehmen, die KI ernsthaft einsetzen, müssen sich mit Verantwortung, Transparenz, Nachvollziehbarkeit und Datenumgang beschäftigen.** ### Zeitlicher Rahmen (vereinfacht) * **Seit 2024:** Der AI Act ist in Kraft. * **Ab 2025:** Erste Pflichten greifen, etwa zu KI-Kompetenz (AI Literacy) und verbotenen Praktiken. * **Ab 2. August 2026:** Der AI Act ist in weiten Teilen anwendbar – insbesondere für Systeme, die mit Menschen interagieren oder Prozesse beeinflussen. Für den Mittelstand bedeutet das:\ **Die nächsten zwei Jahre sind die Phase, in der Strukturen und Spielregeln geschaffen werden sollten.** ## Welche Themen werden für Unternehmen wichtig? In der Praxis lassen sich die Anforderungen auf drei zentrale Bereiche bündeln. ### 1. KI-Kompetenz und klare Zuständigkeiten Mitarbeitende sollen KI verstehen und verantwortungsvoll nutzen können. Dafür braucht es: * Schulungen und Grundverständnis (AI Literacy) * einfache Leitlinien für den Einsatz * klare Verantwortlichkeiten Gleichzeitig muss definiert sein, **welche Tools erlaubt sind**, **welche Daten genutzt werden dürfen** und **wer für KI-Themen zuständig ist**. ### 2. Transparente und nachvollziehbare KI-Nutzung Überall dort, wo KI mit Kundinnen, Mitarbeitenden oder Partnern interagiert, sollte klar sein: * dass eine KI im Einsatz ist * welche Aufgabe sie übernimmt * ab welchem Punkt ein Mensch übernimmt Unternehmen sollten grundsätzlich erklären können, **warum eine Antwort oder Empfehlung zustande gekommen ist** – etwa über Protokolle, Dokumentation und Prüfmöglichkeiten. ### 3. Bewusste Auswahl von Use Cases Statt „KI überall“ geht es um **gezielte, gut steuerbare Einsatzfelder**. Typische Einstiege sind: * Erstkontakt und Qualifizierung * Terminvereinbarung * wiederkehrende Rückfragen (FAQ) Wichtig ist, klein zu starten, **klare Übergaben zwischen Mensch und KI zu definieren** und Effekte messbar zu machen. ## Was bedeutet das konkret für den Mittelstand? Der AI Act ist kein KI-Verbot. Er ist ein Schritt hin zu **professionell betriebenen KI-Systemen**. Für mittelständische Unternehmen heißt das: * KI wird Teil der organisatorischen Realität, nicht nur ein Experiment. * Es reicht nicht mehr, wenn einzelne Mitarbeitende verschiedene KI-Tools „nebenbei“ nutzen. * Wer frühzeitig Strukturen schafft, kann KI sicher, nachvollziehbar und skalierbar einsetzen – statt später unter Druck reagieren zu müssen. ## Und was hat das mit LIVOI zu tun? **LIVOI** ist eine unternehmensspezifische KI-Kommunikationsassistenz. Sie wird dort eingesetzt, wo viele Gespräche, Anfragen und Abstimmungen stattfinden – zum Beispiel: * im Vertrieb * im Kundenservice * im Onboarding * bei internen Rückfragen Gerade im Kontext des AI Act sind drei Punkte besonders relevant. ### Transparenz Unternehmen legen klar fest: * wo LIVOI unterstützt * wie kommuniziert wird * wann an einen Menschen übergeben wird ### Kontrolle und Datenhoheit LIVOI arbeitet ausschließlich mit dem Wissen des jeweiligen Unternehmens – **nicht mit beliebigen Internetdaten**.\ Die Daten: * bleiben in einer geschützten Umgebung * sind getrennt und verschlüsselt pro Kunde * werden nicht für fremdes Training genutzt ### Nachvollziehbarkeit Gesprächsverläufe können dokumentiert, nächste Schritte abgeleitet und Prozesse sauber eingebunden werden.\ LIVOI ist **kein Blackbox-System**, sondern ein Baustein in klar definierten Abläufen. **Kurz gesagt:** LIVOI passt gut zu der Richtung, die der AI Act vorgibt – KI, die in Prozesse passt, statt KI, die nur als Demo beeindruckt. ## Drei Schritte, mit denen Sie jetzt starten können 1. **Bestandsaufnahme:**\ Wo nutzen Sie heute schon KI – bewusst oder unbewusst (Office-Funktionen, CRM, Chatbots, externe Dienste)? 2. **Spielregeln definieren:**\ Welche Tools sind erlaubt, welche Daten dürfen wohin, wer trägt Verantwortung? 3. **Einen klaren Use Case wählen:**\ Zum Beispiel Erstkontakt, Terminbuchung, Qualifizierung von Anfragen oder interne FAQ-Unterstützung. ## Nächster Schritt: KI-Einsatz sauber planen Wenn Sie Ihren KI-Einsatz im Sinne des AI Act strukturiert angehen möchten, lohnt sich ein kurzer Austausch. In einer Erstbesprechung klären wir gemeinsam: * Ihre Ziele und Painpoints * Ihre bestehende Tool- und Datenlandschaft * und ob ein Use Case mit LIVOI oder eine KI-Potenzialanalyse der passende Einstieg ist Sie möchten KI nicht nur nutzen, sondern auch sauber aufstellen?\ Dann zeigen wir Ihnen gern, wie ein **AI-Act-tauglicher Einstieg mit LIVOI** aussehen kann. [Erstbesprechung vereinbaren](https://calendar.google.com/calendar/u/0/appointments/schedules/AcZssZ0RYHNxC2ckSW9YDZRVSQKrXrkDyfcm3WfR6PguUYnc2hHfJlp8gJG29WqPbMGLksxYsUt-Agvg) # KI-Agent vs. Chatbot – Woran Sie echte Agenten erkennen (/blog/2026-01-21-ki-agent-vs-chatbot-woaran-sie-echte-agenten-erkennen) ## Mehr als nur ein neues Etikett Der Begriff **„KI-Agent“** wird aktuell inflationär als Label für fast alles genutzt, was im Chatfenster vernünftige Antworten liefert. Das sorgt nicht nur für Verwirrung, sondern oft auch für falsche Erwartungen in Unternehmen. Das Ergebnis sind häufig Projekte, die zwar eloquente Texte liefern, den Arbeitsalltag aber kaum messbar entlasten. Um die richtige Architektur für ein Unternehmen zu wählen, muss man den fundamentalen Unterschied verstehen: **Kurzdefinition:** Ein Chatbot beantwortet Fragen. Ein KI-Agent bringt einen Vorgang zu einem Ergebnis. Ein Agent sammelt Kontext, stellt gezielte Rückfragen und stößt definierte Schritte innerhalb klarer Regeln an – inklusive einer sauberen Übergabe, wenn der Mensch übernehmen muss. ## Wahrheit 1: Ergebnisse statt Antworten Ein klassischer Chatbot ist darauf trainiert, eine Konversation zu führen. Ein Agent hingegen ist darauf optimiert, etwas **„zu Ende zu bringen“**. Das Ziel ist nicht der Dialog an sich, sondern die Erledigung einer Aufgabe, wie zum Beispiel: * Eine komplexe Anfrage klären * Einen Lead vorqualifizieren * Ein Support-Ticket vorbereiten * Den nächsten logischen Prozessschritt definieren ## Wahrheit 2: Handeln innerhalb von Regeln Damit ein KI-Modell verlässlich arbeiten kann, agiert ein echter Agent nicht im luftleeren Raum, sondern führt definierte Schritte aus. Er halluziniert keine Lösungen, sondern arbeitet Checklisten ab: 1. Fehlen Informationen? → **Parameter abfragen** 2. Werden Daten benötigt? → **Infos aus freigegebenen Quellen zusammenstellen** 3. Muss der Nutzer etwas wissen? → **Unterlagen bereitstellen** 4. Ist der Fall zu komplex? → **Übergabe an die richtige Stelle auslösen** 5. Was passiert danach? → **Follow-ups anstoßen** ## Der 2-Minuten-Check Woran erkennt man nun, ob man es mit einem echten Agentensystem oder einem Chatbot mit neuem Anstrich zu tun hat? Wir nutzen dafür eine Checkliste mit 7 Merkmalen. Fehlen mehrere der folgenden Punkte, handelt es sich meist nur um einen Chatbot. Echte Agenten bieten: * **Zielorientierung** (Fokus auf Abschluss statt Konversation) * **Strukturierte Rückfragen** (Gezieltes Sammeln fehlender Infos) * **Tool-Nutzung** (Zugriff auf freigegebene Quellen/APIs) * **Verwertbares Output-Format** (z.B. JSON, Kurzprofil, Ticket) * **Saubere Übergabe** (Kontext-Transfer an Mensch/System) * **Nachvollziehbarkeit** (Quellenangabe, Regelverweis) * **Kontrollierbarkeit** (Klare Grenzen und Eskalationspfade) ## Ein Szenario aus der Praxis Der Unterschied wird am deutlichsten, wenn man beide Systeme auf dieselbe Anfrage loslässt. *Szenario: Ein Interessent schreibt: „Wir produzieren 5.000 Teile pro Schicht in staubiger Umgebung, welche Lösung passt?“* Er greift auf allgemeines Trainingswissen zurück und nennt pauschal verschiedene Optionen oder listet Produkte auf, die theoretisch passen könnten. Der Nutzer bleibt mit einer Liste allein. Der Agent erkennt die Absicht (Kaufberatung) und prüft die Parameter. Er stellt fest: „Staubig“ und „Menge“ sind da, aber die Materialart fehlt. Er fragt gezielt das fehlende Material ab, grenzt die Optionen basierend auf der Datenbank ein und stellt passende technische Datenblätter als Download bereit. Abschließend erstellt er ein Kurzprofil des Interessenten und übergibt dieses (inklusive der technischen Randbedingungen) an den zuständigen Vertriebsmitarbeiter. ## Häufige Projektfehler vermeiden Warum scheitern viele Initiativen, obwohl die Technologie bereit wäre? Meist liegt es an drei vermeidbaren Fehlern: 1. **Zu breit starten:** Es gibt zu viele Ausnahmen und zu wenig Proof-of-Concept. 2. **Ohne Regeln & Quellen:** Das System liefert hübsche Antworten, aber keine verlässliche Entlastung. 3. **Ohne Messung:** Es gibt keinen Nachweis der Effizienz und somit keine Grundlage zur Skalierung. ## Unser Blick bei P-CATION Bei **LIVOI** betrachten wir Agenten nicht als kurzfristigen Trend, sondern als fundamentale Architekturfrage: *Wie schaffen wir Entlastung im Alltag, ohne die Kontrolle zu verlieren?* Für uns zählen dabei drei Prinzipien, die über den Hype hinausgehen: * **Proof statt Behauptung:** Funktioniert es in echten Abläufen? * **Kontrolle statt Blackbox:** Klare Regeln, definierte Übergaben, volle Nachvollziehbarkeit. * **Skalierbarkeit statt Bastellösung:** Prozesse müssen wiederholbar, messbar und erweiterbar sein. Sie möchten wissen, wo KI in Ihrem Unternehmen realistisch entlastet? In einer kurzen Erstbesprechung klären wir Ziele, Prozesse und Datenlage und entscheiden gemeinsam, was der richtige nächste Schritt ist. [Erstbesprechung vereinbaren](https://calendar.google.com/calendar/u/0/appointments/schedules/AcZssZ0319Na8C9fyYTJHz8fV8WABdTin4c9jMtlP_ROYgAlegmUR49vptziTkbuivZF-tDl527Fq2l6) # Keine verpassten Leads mehr – LIVOI im Einsatz bei VB Airsuspension (/blog/2026-01-21-keine-verpassten-leads-mehr-livoi-im-einsatz-bei-vb-aisuspension) ## Das Problem: Volle Gänge, verpasste Chancen Wer schon einmal auf einer großen Fachmesse unterwegs war, kennt das Szenario: Überfüllte Gänge, unzählige Eindrücke und oft zu wenig Zeit für ein ruhiges Gespräch. Gerade an Ständen mit erklärungsbedürftigen technischen Produkten – wie den Fahrwerkslösungen von **VB Airsuspension** – entsteht schnell ein Engpass. Während das Standpersonal einem Kunden detailliert den Unterschied zwischen Zusatz- und Vollluftfederung erklärt, laufen im Hintergrund drei weitere Interessenten vorbei. Sie schauen kurz, finden keinen Ansprechpartner und gehen weiter. Das Ergebnis: * **Verpasste Kontakte**, weil die Hemmschwelle zum Warten zu hoch ist. * **Stress für das Team**, das versucht, sich zu zerteilen. * **Informationsverlust**, da spontane Fragen nirgendwo festgehalten werden. VB Airsuspension hat sich entschieden, diese Lücke zu schließen – nicht durch mehr Personal, sondern durch eine intelligente Erweiterung des Teams: **LIVOI**. ## Die Lösung: Der unsichtbare Experte am Stand Auf der aktuellen Messe arbeitet neben den Fachberatern und Technikern erstmals ein „unsichtbarer“ Kollege mit. Über gut sichtbare QR-Codes direkt an den Fahrzeugen können Besucher sofort ins Gespräch kommen – digital, aber fachlich tiefgehend. **Der Unterschied:** Es handelt sich nicht um einen simplen Wegweiser, sondern um eine KI-Kommunikationsassistenz, die auf dem spezifischen Fachwissen von VB Airsuspension trainiert ist. LIVOI agiert hierbei als direkter Puffer und Qualifizierer. Er kennt die Produktgruppen, versteht die Unterschiede bei Achslasten und kann Anwendungsfälle für Reisemobile oder Transporter erklären. ## Wie der Prozess für den Besucher aussieht Statt unverrichteter Dinge weiterzugehen, erlebt der Besucher eine sofortige Interaktion. Der Ablauf ist dabei auf maximale Einfachheit ausgelegt: Der Besucher scannt den QR-Code am Fahrzeug oder Aufsteller – egal ob er direkt davor steht oder nur vorbeigeht. LIVOI öffnet den Dialog. Der Besucher fragt: „Welche Luftfederung passt zu meinem Camper?“ LIVOI antwortet nicht generisch, sondern basierend auf den technischen Datenblättern und Erfahrungen des Unternehmens. LIVOI erklärt Vor- und Nachteile konkreter Lösungen (z. B. Vollluftfederung für mehr Komfort) und beantwortet Fragen zum Einbau. Ist das Interesse konkret, nimmt LIVOI die Kontaktdaten auf oder signalisiert dem Standpersonal, dass ein vorinformierter Interessent bereit für ein persönliches Gespräch ist. ## Kein Chatbot, sondern Unternehmensgedächtnis Der entscheidende Faktor für den Erfolg dieses Projekts ist die **Qualität der Antworten**. Ein herkömmlicher Chatbot würde bei spezifischen Fragen zur Fahrwerksgeometrie vermutlich halluzinieren oder auf eine allgemeine Kontaktseite verweisen. LIVOI hingegen arbeitet als **unternehmensspezifischer Assistent**. Das Wissen stammt direkt von den Experten bei VB Airsuspension und wurde strukturiert hinterlegt. Das System: * Erklärt technische Details fundiert. * Arbeitet ausschließlich im Unternehmenskontext. * Verweist auf korrekte Ansprechpartner und Prozesse. ## Datensicherheit als Basis für Vertrauen Gerade im deutschen B2B-Umfeld ist der sorgsame Umgang mit Daten nicht verhandelbar. LIVOI wurde so konzipiert, dass Unternehmen die Kontrolle behalten: * **Speicherung in Deutschland** * **Getrennte, verschlüsselte Instanzen** pro Kunde * **DSGVO-Konformität** und Berücksichtigung der KI-Verordnung So wird sichergestellt, dass das interne Wissen geschützt bleibt und Kundendaten nicht zum Training öffentlicher Modelle verwendet werden. ## Ein Mehrwert über die Messe hinaus Der Einsatz auf der Messe ist für VB Airsuspension erst der Anfang. Die Architektur von LIVOI erlaubt es, dieses „digitale Wissen“ auch in andere Bereiche zu skalieren: 1. **Im Vertrieb:** Als digitale Vorab-Beratung auf der Website. 2. **Im Kundenservice:** Um wiederkehrende Fragen zu Einbau oder Wartung 24/7 zu klären. 3. **Im Onboarding:** Damit neue Mitarbeiter Fragen an das „Unternehmensgedächtnis“ stellen können, statt Kollegen zu unterbrechen. ## Fazit Das Projekt bei VB Airsuspension zeigt exemplarisch, wie KI im Mittelstand funktionieren sollte: Nicht als Spielerei, sondern als konkretes Werkzeug zur Problemlösung. Die persönliche Beratung wird nicht ersetzt, sondern von administrativen und repetitiven Aufgaben befreit. Das Team hat mehr Zeit für echte Verkaufsgespräche, und kein Besucher wird mehr ignoriert. Sie möchten wissen, wie Sie Ihre Messe-Leads oder Ihren Support mit einem echten KI-Agenten optimieren können? Lassen Sie uns in einer kurzen Erstbesprechung prüfen, ob LIVOI zu Ihren Prozessen passt. [Wie würde LIVOI bei Ihnen aussehen? Jetzt Kurzgespräch vereinbaren](https://calendar.google.com/calendar/u/0/appointments/schedules/AcZssZ0RYHNxC2ckSW9YDZRVSQKrXrkDyfcm3WfR6PguUYnc2hHfJlp8gJG29WqPbMGLksxYsUt-Agvg) # Vibe Coding: Warum weniger mehr ist (und der MCP-Wahnsinn enden muss) (/blog/2026-01-26-warum-weniger-oft-mehr-ist) **„Vibe Coding“** ist das Wort der Stunde. Es beschreibt diesen fast magischen Zustand, in dem Entwickler mit KI-Unterstützung Code schneller produzieren, als sie denken können. Doch wenn man hinter die Kulissen vieler Dev-Teams blickt, sieht man einen gefährlichen Gegentrend: **Over-Engineering der Werkzeuge.** Entwickler verbringen mittlerweile mehr Zeit damit, die *perfekte* KI-Umgebung zu konfigurieren, als tatsächlich Features zu shippen. Da werden komplexe RAG-Pipelines gebaut, Dutzende [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) Server installiert und seitenlange „Skills“ definiert. Das Resultat? Ein aufgeblähter Kontext, explodierende Kosten und eine KI, die am Ende verwirrter ist als zuvor. In diesem Beitrag analysieren wir, warum ein radikales „Default-Setup“ oft die überlegene Strategie ist und warum Sie den berüchtigten „Ralph Loop“ um jeden Preis vermeiden sollten. ## Die Falle des „Ralph Loop“ Bevor wir über Lösungen sprechen, müssen wir über den Elefanten im Raum reden: Den **Ralph Loop**. In der Theorie klingt es nach purer Autonomie: Man steckt einen AI-Agenten in eine Bash-Schleife (`while true; do ...`), damit er so lange arbeitet, bis die Tests grün sind. "Lauf einfach, bis es funktioniert." In der Praxis ist das oft **die schnellste Art, Geld zu verbrennen**. Wenn der Agent die Ursache eines Fehlers nicht fundamental versteht, beginnt er zu raten ("Halluzinieren"). Er wendet sinnlose Fixes an, die Tests schlagen fehl, der Loop startet neu. Das Ergebnis ist kein funktionierender Code, sondern ein enormer **Token-Burn** auf Ihrer Kreditkarte. Echte Produktivität entsteht nicht durch blinden Autopilot, sondern durch gezielte Führung. ## Das "Just Talk To It"-Prinzip Warum scheitern komplexe Setups so oft? Weil sie versuchen, Ineffizienzen im Prompting durch Technologie zu erschlagen. Ein Blick auf die produktivsten Vibe Coder der Welt – wie [Peter Steinberger](https://github.com/steipete/) (Gründer von PSPDFKit) – ist augenöffnend. Er realisiert an guten Tagen **150 bis 500 Commits** und managt einen massiven Tech-Stack fast im Alleingang. Sein Setup? Fast schon enttäuschend simpel: * **Standard-Modelle** (GPT-5-Codex oder Claude Opus) als Daily Driver. * **Keine komplexen Frameworks**, sondern simple CLI-Tools. * **Visuelle Kommunikation:** Statt lange CSS-Fehler zu beschreiben, werden einfach Screenshots ("Fix padding here") in den Chat geworfen. Ein Bild spart oft 1000 Worte Prompting. * **Parallele Terminals:** Statt eines Super-Agenten laufen 3–8 Terminals parallel für verschiedene Tasks. Seine Philosophie ist simpel: **„Just talk to it.“** Anstatt komplexe Wrapper zu bauen, redet er mit dem Modell wie mit einem Senior Engineer. ## Die 3 Säulen für echtes Vibe Coding Wenn Sie aufhören, Ihre Tools zu konfigurieren, können Sie anfangen, Ihre Prozesse zu optimieren. Hier sind die Hebel, die wirklich zählen: ### 1. Kampf dem "Context Rot" (und der MCP-Hölle) KI-Modelle haben ein begrenztes Aufmerksamkeitsfenster. Je mehr unnötigen Code, veraltete Dokumentation und Tool-Definitionen („Bloat“) Sie in den Kontext laden, desto mehr „Rauschen“ entsteht. Viele tappen in die Falle, Dutzende MCP-Server für GitHub, Slack und Jira gleichzeitig anzubinden. **Der Pro-Tipp:** Nutzen Sie einfach die CLI. Ein Modell wie GPT-5 weiß bereits, wie man `gh pr create` in der Kommandozeile ausführt. Das kostet **null** „Context-Tax“. **Der "Cross-Referencing" Hack:** Anstatt dem Modell mühsam neue Konzepte zu erklären, verweisen Sie auf bestehenden Code. Ein Prompt wie *"Schau in ../anderes-projekt und implementiere das Logging genauso"* ist mächtiger als jede Dokumentation. Das Modell adaptiert funktionierende Muster aus Ihren Nachbarordnern sofort. ### 2. Dialog statt starrem Plan Mode Früher war der "Plan Mode" (erst planen, dann editieren lassen) essenziell, um ältere Modelle (GPT-4 Ära) in der Spur zu halten. Mit der neuen Generation von Modellen (GPT-5.2, Opus) ist dies oft ein unnötiger Bremser. Die neue Best Practice ist das **Sokratische Gespräch**: * Starten Sie einen Dialog. Lassen Sie das Modell den Code lesen oder googeln. * Entwickeln Sie den Plan *im Chat*. * Erst wenn Sie zufrieden sind, geben Sie den Befehl: *"Build this."* Das ist dynamischer und verhindert, dass Sie in einer veralteten `PLAN.md` festsitzen, während sich die Anforderungen beim Coden organisch ändern. ### 3. Den "Blast Radius" verstehen Ein unterschätzter Aspekt ist das Risiko einer Änderung. Man spricht hier vom **Blast Radius**. * Kleine Änderung? Lassen Sie den Agenten machen. * Großes Refactoring? Wenn Sie eine "Atombombe" auf Ihre Codebase werfen, wird es unmöglich, Fehler zu isolieren. Brechen Sie Aufgaben herunter. Lassen Sie den Agenten **atomare Commits** machen. Wenn etwas schiefgeht, können Sie einen kleinen Schritt zurückrollen, statt den Arbeitstag zu verlieren. ## Fazit: Weniger Config, mehr Output Wenn AI Coding bei Ihnen nicht die gewünschten Ergebnisse liefert, liegt es höchstwahrscheinlich nicht daran, dass Ihnen das neueste 500-Dollar-SaaS-Tool fehlt. Es liegt daran, dass der Prozess zu kompliziert ist. Die erfolgreichsten "AI Engineers" sind die, die ihr Terminal öffnen, den Kontext sauber halten und einfach anfangen zu bauen. **Unsere Empfehlung bei P-CATION:** 1. Deinstallieren Sie unnötige MCPs und Plugins. 2. Nutzen Sie Cross-Referencing statt alles neu zu erklären. 3. Vermeiden Sie Loops – bleiben Sie der Pilot. Sie wollen Ihre Entwicklungsprozesse mit KI beschleunigen, ohne in der Konfigurationshölle zu landen? Lassen Sie uns sprechen. [Erstbesprechung vereinbaren](https://calendar.google.com/calendar/u/0/appointments/schedules/AcZssZ0319Na8C9fyYTJHz8fV8WABdTin4c9jMtlP_ROYgAlegmUR49vptziTkbuivZF-tDl527Fq2l6)