KI-Funktionen in deine App einbauen

Um KI-Funktionen in deine App einzubauen, rufst du eine API eines großen Sprachmodells (LLM) von deinem Server aus auf: Du schickst klare Anweisungen plus die relevanten Daten und verwendest die Antwort. Die meisten nützlichen Funktionen folgen einem von vier Mustern: Zusammenfassen, Chatten, strukturierte Daten extrahieren und Klassifizieren. Jedes davon sind ein paar Dutzend Zeilen Code, die ein KI-App-Builder für dich schreiben kann. Ob die Funktion gut ist, entscheidet sich aber an dem, was um den Aufruf herum passiert: den API-Schlüssel auf dem Server halten, die Kosten pro Nutzer im Griff behalten und die Ausgabe prüfen, bevor du ihr vertraust.

Die vier Muster hinter den meisten KI-Funktionen

Extrahieren und Klassifizieren sind oft am wertvollsten und am wenigsten sichtbar. Sie sparen bei jedem Datensatz still ein paar Minuten, und weil die Ausgabe eine feste Form hat, lässt sie sich automatisch prüfen. Chat ist am sichtbarsten, aber am schwersten richtig hinzubekommen und hat einen eigenen Leitfaden: wie du eine KI-Chatbot-App baust.

Wie es in deine App passt

Jedes Muster hat dieselbe Struktur:

1. Der Nutzer handelt: klickt auf „Zusammenfassen“, lädt eine Datei hoch oder schickt eine Nachricht.
2. Dein Frontend ruft deinen eigenen Server auf, nicht den KI-Anbieter.
3. Dein Server baut die Anfrage: Systemanweisungen, die Eingabe des Nutzers und alle Daten aus deiner Datenbank, die das Modell braucht, aber nur Daten, die dieser Nutzer sehen darf.
4. Dein Server ruft die LLM-API auf, mit einem Schlüssel aus einer Umgebungsvariable.
5. Dein Server prüft die Antwort: gültiges JSON, ein bekanntes Label, eine sinnvolle Länge. Dann speichert oder liefert er sie aus.
6. Das Frontend zeigt sie an, bei längeren Antworten als Text, der Schritt für Schritt eintrifft.

Der Schlüssel liegt in Schritt 4 auf dem Server und erreicht nie den Browser. Wenn dir die Idee einer API neu ist, erklärt was eine API ist das kurz, und wie du LLM-APIs nutzt behandelt Tokens, Modelle und Schlüssel ausführlicher.

Anbieter und Modell wählen

Die großen Anbieter, darunter OpenAI, Anthropic, Google und andere, bieten Text-APIs mit recht ähnlichem Aufbau. Nützliche Fragen bei der Auswahl:

• Qualität bei deiner Aufgabe. Probiere einige echte Beispiele aus deiner App auf zwei oder drei Modellen aus. Die Unterschiede zeigen sich auf deinen Daten oft deutlicher als in allgemeinen Benchmarks.
• Größe gegen Kosten. Anbieter bieten größere, leistungsfähigere Modelle und kleinere, günstigere, schnellere. Klassifizieren und einfaches Extrahieren funktionieren oft gut mit einem kleinen Modell; langes Schlussfolgern oder nuanciertes Schreiben braucht eventuell ein größeres.
• Strukturierte Ausgabe. Für Extrahieren und Klassifizieren nimmst du eine API-Funktion, bei der das Modell JSON nach einem von dir vorgegebenen Schema zurückgibt, statt freien Text zu parsen.
• Datenhandhabung. Lies die Bedingungen des Anbieters, ob API-Eingaben gespeichert oder zum Training genutzt werden, und ob das zu den Daten deiner Nutzer passt.
• Limits. Neue Konten haben oft niedrige Ratenlimits; prüfe sie vor einem Start.

Modellnamen und Preise ändern sich oft. Der Code sollte den Modellnamen deshalb aus einer Konfiguration lesen und ihn nicht an vielen Stellen fest eintragen.

Eine Funktion Schritt für Schritt hinzufügen

Ein konkretes Beispiel: ein kleines CRM, bei dem jeder Kontakt eine lange Notizhistorie hat.

1. Schlüssel speichern. Erstelle im Dashboard deines Anbieters einen Schlüssel und speichere ihn als Geheimnis auf dem Server, zum Beispiel OPENAI_API_KEY oder ANTHROPIC_API_KEY.

2. Eine schmale Funktion anfragen:

Füge der Kontaktseite einen Button „Zusammenfassen“ hinzu. Schicke auf dem Server die letzten 20 Notizen des Kontakts an [PROVIDER] und nutze dafür das Geheimnis [ENV_NAME]. Die Anweisung lautet, drei Stichpunkte zu schreiben: aktueller Stand, offene Fragen, nächster Schritt. Berücksichtige nur Notizen, die der angemeldete Nutzer sehen darf. Zeige einen Ladezustand, speichere die Zusammenfassung mit Zeitstempel und zeige „Im Moment konnte nicht zusammengefasst werden“, wenn der Aufruf fehlschlägt. Der Schlüssel darf nie an den Browser gehen.

3. Extraktion dort ergänzen, wo sie Tipparbeit spart:

Wenn ein Nutzer eine E-Mail-Signatur in das Feld „Schnell hinzufügen“ einfügt, rufe auf dem Server [PROVIDER] auf und gib JSON mit Name, Firma, Berufsbezeichnung, E-Mail und Telefon zurück, mit der strukturierten Ausgabefunktion des Anbieters. Prüfe das JSON auf dem Server, fülle damit das Formular für neue Kontakte vor und lass den Nutzer vor dem Speichern alles bearbeiten. Lass Felder leer, statt zu raten.

„Der Nutzer kann vor dem Speichern bearbeiten“ ist der wichtige Teil: Das Modell schlägt vor, der Mensch entscheidet.

4. Im Hintergrund klassifizieren:

Wenn ein neues Support-Ticket eingeht, ordne es genau einer dieser Kategorien zu: Abrechnung, Fehler, Funktionswunsch, Kontozugang, Sonstiges. Nutze ein kleines, günstiges Modell. Ist die Antwort keines dieser Labels, speichere „Sonstiges“. Zeige das Label als bearbeitbaren Tag.

5. Mit unordentlichen echten Daten testen: lange Notizen, leere Notizen, andere Sprachen, eine Signatur ohne Telefonnummer. Prüfe zwanzig Ausgaben nebeneinander, bevor du startest.

Anweisungen, die funktionieren

Die Anweisungen, die du bei jeder Anfrage mitschickst (oft Systemprompt genannt), bestimmen die Qualität.

• Sag, für wen es ist und was gut ist. „Zusammenfassungen liest eine Vertriebsmitarbeiterin in 10 Sekunden vor einem Anruf“ gibt dem Modell ein Ziel.
• Lege das Format fest. Genaue Anzahl der Stichpunkte, Längenlimit, Felder, Labels.
• Sag, was bei Unsicherheit zu tun ist. „Wenn die Notizen keinen nächsten Schritt nennen, schreibe ‚Kein nächster Schritt erfasst‘.“ Das verringert erfundene Antworten.
• Gib zwei oder drei Beispiele für gute Eingabe und Ausgabe bei Extraktion und Klassifizierung.
• Halte Anweisungen und Nutzerinhalt getrennt und kennzeichne den Nutzerinhalt klar, damit das Modell beides unterscheiden kann.

Bewahre die Prompts in Dateien im Code auf, damit sie versioniert und prüfbar sind wie jeder andere Code.

Kosten im Griff behalten

LLM-APIs berechnen nach Tokens, also kleinen Textstücken, sowohl für das, was du schickst, als auch für das, was zurückkommt. Die Kosten wachsen mit der Menge an Kontext pro Anfrage, multipliziert mit der Häufigkeit. Praktische Stellschrauben:

• Nur senden, was nötig ist. Die letzten 20 Notizen, nicht die ganze Historie. Kürze lange Dokumente oder teile sie auf.
• Das kleinste Modell nehmen, das die Aufgabe erfüllt. Teste, bevor du standardmäßig das größte wählst.
• Die Ausgabelänge begrenzen mit der Einstellung für maximale Tokens der API.
• Ergebnisse zwischenspeichern. Speichere eine Zusammenfassung und erzeuge sie nur neu, wenn sich die Quelle ändert, statt bei jedem Seitenaufruf.
• Pro Nutzer begrenzen. Ein tägliches Limit pro Konto oder Tarif verhindert, dass ein Vielnutzer oder ein Skript die Rechnung hochtreibt.
• Den Endpunkt mit einem Ratenlimit versehen wie jede andere teure Route.
• Budget oder Warnung im Dashboard des Anbieters festlegen und die Nutzung nach dem Start wöchentlich prüfen.
• Token-Verbrauch pro Funktion protokollieren, damit du weißt, welche Funktion was kostet.

Wenn KI-Funktionen zentral für dein Produkt sind, kalkuliere die laufenden Kosten in deine Preise ein, statt sie zu schlucken.

Sicherheit und Vertrauen

Die Ausgabe einer KI ist probabilistisch. Sie kann falsch sein, ohne dass es so klingt, und sie lässt sich durch den Text steuern, den sie liest. Baue darauf Rücksicht:

• Behandle die Ausgabe als unsichere Eingabe. Prüfe die Struktur, maskiere sie, bevor du sie als HTML darstellst, und führe sie nie als Code oder Datenbankabfrage aus.
• Halte einen Menschen im Prozess bei allem mit Folgen: eine E-Mail verschicken, einen Datensatz ändern, eine Zahlung erstatten. Das Modell entwirft, eine Person bestätigt.
• Schütze dich gegen Prompt Injection. Ein Dokument oder eine Nachricht kann Text enthalten wie „ignoriere deine Anweisungen“. Begrenze, was das Modell sehen kann, auf das, was der aktuelle Nutzer sehen darf, und gib ihm keine Werkzeuge für sensible Aktionen, ohne dass dein Code vorher die Berechtigung prüft.
• Kennzeichne KI-Inhalte, damit Nutzer wissen, dass eine Zusammenfassung oder ein Vorschlag erzeugt wurde und sie ihn prüfen können.
• Fange Fehler sauber ab. Anbieter haben Ausfälle und Ratenlimits. Setze Zeitüberschreitungen, zeige eine klare Meldung und lass den Rest der App weiterlaufen.
• Achte darauf, was Nutzer senden. Bei offenen Texteingaben solltest du eine Moderation erwägen, und deine Datenschutzerklärung sollte klar sagen, dass Inhalte von einem externen KI-Anbieter verarbeitet werden.

Die breitere Liste der Prüfungen steht in der Sicherheits-Checkliste für KI-gebaute Apps.

Häufige Fehler

• Mit einem allgemeinen Chatbot anfangen, obwohl ein einziger Button „Zusammenfassen“ oder „Kategorisieren“ mehr Menschen helfen würde.
• Den Schlüssel in den Frontend-Code legen oder in ein öffentliches Repository.
• Die ganze Datenbank als Kontext senden. Das ist langsam, teuer und setzt Daten anderer Nutzer aufs Spiel.
• Freitext-Ausgaben vertrauen, wo ein Schema oder eine feste Labelmenge sie prüfbar machen würde.
• Keine Limits pro Nutzer, und das merkt man erst, wenn die erste Rechnung kommt.

KI-Funktionen mit Mythex

In Mythex fügst du KI in deine eigene App hinzu, indem du im Chat danach fragst und deinen eigenen Anbieter-Schlüssel verwendest. Speichere den Schlüssel als Projekt-Geheimnis. Wenn der Agent ihn braucht, zeigt Mythex eine Geheimnis-Karte im Chat, sodass du den Schlüssel nicht in die Unterhaltung einfügen musst. Der Agent schreibt dann die Server-Route, die Prompts und die Oberfläche. Die KI-Nutzung deiner App wird von deinem Anbieter abgerechnet, getrennt von den Mythex-Credits, die du fürs Bauen ausgibst. In der Dokumentation gibt es einen Start-Prompt unter KI-Funktionen mit deinen eigenen API-Schlüsseln hinzufügen.

Fragen