Freigeben über

Generierender AI-App-Entwicklerworkflow

Für die Entwicklung einer robusten generativen KI-Anwendung (Gen KI-App) ist eine bewusste Planung, eine schnelle Entwicklungsrückmeldungsschleife und eine skalierbare Produktionsinfrastruktur erforderlich. Dieser Workflow beschreibt eine empfohlene Abfolge von Schritten, die Sie von der anfänglichen PoC-Bereitstellung (Proof-of-Concept) bis hin zur Produktionsbereitstellung führen.

0. Voraussetzungen

  • Sammeln Sie Anforderungen, um die Eignung von gen KI zu validieren und identifizieren Sie Einschränkungen.
  • Entwerfen Sie Ihre Lösungsarchitektur. Siehe Agent-Systementwurfsmuster

1. Erstellen

  • Bereiten Sie Datenquellen vor, und erstellen Sie die erforderlichen Tools.
  • Erstellen und Validieren des ersten Prototyps (POC).
  • Bereitstellen in der Präproduktionsumgebung.

2. Auswerten und Iterieren

  • Sammeln von Benutzerfeedback und Messen der Qualität
  • Beheben Sie Qualitätsprobleme, indem Sie die Agentlogik und -tools basierend auf der Auswertung verfeinern.
  • Integrieren Sie die Eingaben von Fachleuten (SME), um kontinuierlich die Qualität des Agentensystems zu verbessern.

3. Produktion

  • Bereitstellen der generativen KI-App in der Produktionsumgebung.
  • Überwachen Sie die Leistung und Qualität.
  • Pflegen und Verbessern basierend auf der Nutzung unter realen Bedingungen.

Dieser Workflow sollte iterativ sein: Kehren Sie nach jedem Bereitstellungs- oder Auswertungszyklus zu früheren Schritten zurück, um Datenpipelines zu verfeinern oder die Agentenlogik zu aktualisieren. Beispielsweise kann die Produktionsüberwachung neue Anforderungen offenlegen und Aktualisierungen des Agentdesigns und eine weitere Bewertungsrunde auslösen. Indem Sie diese Schritte systematisch ausführen und databricks MLflow-Ablaufverfolgung, Agent Framework- und Agent-Auswertungsfunktionen nutzen, können Sie hochwertige KI-Apps erstellen, die den Anforderungen der Benutzer zuverlässig entsprechen, Sicherheits- und Complianceanforderungen respektieren und im Laufe der Zeit weiter verbessert werden.

0. Voraussetzungen

Bevor Sie mit der Entwicklung Ihrer generativen KI-Anwendung beginnen, ist es von entscheidender Bedeutung, sich die Zeit zu nehmen, um Folgendes richtig zu erledigen: Anforderungen zu sammeln und eine Lösungsdesign zu erstellen.

Das Sammeln von Anforderungen umfasst die folgenden Schritte:

  • Überprüfen Sie, ob die Gen-KI zu Ihrem Anwendungsfall passt.
  • Definieren Sie die Benutzeroberfläche.
  • Ermitteln von Datenquellen.
  • Legen Sie Leistungseinschränkungen fest.
  • Erfassen Sie Sicherheitsbeschränkungen.

Das Lösungsdesign umfasst Folgendes:

  • Zuordnen von Datenpipelines.
  • Identifizieren Sie die erforderlichen Tools.
  • Skizzieren Sie die allgemeine Systemarchitektur.

Durch die Festlegung dieser Grundarbeiten legen Sie eine klare Richtung für die nachfolgenden Build-, Evaluate- und Production-Phasen fest.

Sammeln von Anforderungen

Das Definieren klarer und umfassender Anwendungsfallanforderungen ist ein wichtiger erster Schritt bei der Entwicklung Ihrer erfolgreichen KI-App. Diese Anforderungen dienen den folgenden Zwecken:

  • Sie helfen dabei, zu bestimmen, ob ein generativer KI-Ansatz für Ihren Anwendungsfall geeignet ist.
  • Sie leiten Lösungsentwurfs-, Implementierungs- und Bewertungsentscheidungen.

Wenn Sie zu Beginn Zeit investieren, um detaillierte Anforderungen zu sammeln, können erhebliche Herausforderungen später im Entwicklungsprozess verhindern und sicherstellen, dass die resultierende Lösung den Anforderungen von Endbenutzern und Stakeholdern entspricht. Gut definierte Anforderungen stellen die Grundlage für die nachfolgenden Phasen des Lebenszyklus Ihrer Anwendung bereit.

Eignet sich der Anwendungsfall gut für die Gen-KI?

Bevor Sie sich für eine generative KI-Lösung verpflichten, überlegen Sie, ob ihre inhärenten Stärken Ihren Anforderungen entsprechen. Einige Beispiele, bei denen eine generative KI-Lösung gut passt, sind:

  • Inhaltsgenerierung: Die Aufgabe erfordert das Generieren neuer oder kreativer Inhalte, die nicht mit statischen Vorlagen oder einfacher regelbasierter Logik erreicht werden können.
  • Dynamische Abfragebehandlung: Benutzerabfragen sind offene oder komplexe Und erfordern flexible, kontextbezogene Antworten.
  • Informationssynthese: Der Anwendungsfall profitiert davon, verschiedene Informationsquellen zu kombinieren oder zusammenzufassen, um eine kohärente Ausgabe zu erzeugen.
  • Agentsysteme: Die Anwendung erfordert mehr als nur das Generieren von Text als Reaktion auf eine Eingabeaufforderung. Es könnte die Fähigkeit besitzen:
    • Planung und Entscheidungsfindung: Formieren einer mehrstufigen Strategie, um ein bestimmtes Ziel zu erreichen.
    • Ergreifen von Aktionen: Auslösen externer Prozesse oder Aufrufen verschiedener Tools zum Ausführen von Aufgaben (z. B. Abrufen von Daten, Ausführen von API-Aufrufen, Ausführen von SQL-Abfragen, Ausführen von Code).
    • Aufrechterhaltung des Zustands: Nachverfolgen des Unterhaltungsverlaufs oder des Aufgabenkontexts über mehrere Interaktionen hinweg, um die Kontinuität zu ermöglichen.
    • Erstellen adaptiver Ausgaben: Generieren von Antworten, die sich basierend auf vorherigen Aktionen, aktualisierten Informationen oder ändernden Bedingungen entwickeln.

Umgekehrt ist ein generativer KI-Ansatz in den folgenden Situationen möglicherweise nicht ideal.

  • Die Aufgabe ist sehr deterministisch und kann effektiv mit vordefinierten Vorlagen oder regelbasierten Systemen gelöst werden.
  • Die gesamte Menge der erforderlichen Informationen ist bereits statisch oder passt in ein einfaches, geschlossenes Framework.
  • Extrem niedrige Latenzantworten (Millisekunden) sind erforderlich, und der Aufwand der generativen Verarbeitung kann nicht berücksichtigt werden.
  • Einfache, vorlagenbasierte Antworten sind für den vorgesehenen Anwendungsfall ausreichend.

Von Bedeutung

In den folgenden Abschnitten werden die Bezeichnungen P0, P1 und P2 verwendet, um die relative Priorität anzugeben.

  •  [P0] Elemente sind kritisch oder unerlässlich. Diese müssen unverzüglich behoben werden.
  •  [P1]- Elemente sind wichtig, können jedoch nach P0-Anforderungen nachfolgen.
  • ⚪ [P2]-Elemente sind Überlegungen oder Verbesserungen mit niedrigerer Priorität, die je nach Zeit und Ressourcen berücksichtigt werden können.

Diese Bezeichnungen helfen Teams, schnell zu erkennen, welche Anforderungen sofortige Aufmerksamkeit erfordern und welche zurückgestellt werden können.

Benutzerfreundlichkeit

Definieren Sie, wie Benutzer mit der KI-Gen-App interagieren und welche Art von Antworten erwartet werden.

  •  [P0] Typische Anforderung: Wie sieht eine typische Benutzeranforderung aus? Sammeln Sie Beispiele von Projektbeteiligten.
  •  [P0] Erwartete Antworten: Welche Art von Antworten sollte das System generieren (z. B. kurze Antworten, Langform-Erklärungen, kreative Erzählungen)?
  •  [P1] Interaktionsmodalitäten: Wie interagieren Benutzer mit der Anwendung (z. B. Chatschnittstelle, Suchleiste, Sprachassistent)?
  •  [P1] Ton, Stil, Struktur: Welcher Ton, Stil und welche Struktur sollten die generierten Ausgaben übernehmen (formal, unterhaltsam, technisch, Aufzählungszeichen oder fortlaufender Text)?
  •  [P1]Fehlerbehandlung: Wie sollte die Anwendung mehrdeutige, unvollständige oder abwegige Abfragen behandeln? Sollte es Feedback geben oder Klarstellung anfordern?
  • ⚪ [P2] Formatierungsanforderungen: Gibt es spezifische Formatierungs- oder Präsentationsrichtlinien für die Ausgaben (einschließlich Metadaten oder Ergänzende Informationen)?

Daten

Bestimmen Sie die Art, die Quelle(n) und die Qualität der Daten, die in der KI-Gen-App verwendet werden.

  • [P0] Datenquellen: Welche Datenquellen sind verfügbar?
    • Bestimmen Sie für jede Quelle Folgendes:
      • Sind die Daten strukturiert oder unstrukturiert?
      • Was ist das Quellformat (z. B. PDF, HTML, JSON, XML)?
      • Wo befinden sich die Daten?
      • Wie viele Daten sind verfügbar?
      • Wie sollte auf die Daten zugegriffen werden?
  • [P1] Datenaktualisierungen: Wie häufig werden die Daten aktualisiert? Welche Mechanismen gelten für die Behandlung von Updates?
  • [P1] Datenqualität: Gibt es bekannte Qualitätsprobleme oder Inkonsistenzen?
    • Überlegen Sie, ob eine Qualitätsüberwachung für Datenquellen erforderlich ist.

Erwägen Sie das Erstellen einer Bestandstabelle, um diese Informationen zu konsolidieren, z. B.:

Datenquelle Quelle Dateityp(n) Größe Aktualisierungshäufigkeit
Datenquelle 1 Unity-Katalog-Volumen JSON 10 GB Täglich
Datenquelle 2 Öffentliche API XML n/v (API) Echtzeit
Datenquelle 3 SharePoint PDF, DOCX 500MB Monatlich

Leistungsbeschränkungen

Erfassen Sie Leistungs- und Ressourcenanforderungen für die generative KI-Anwendung.

Latenz

  • [P0] Zeit bis zum ersten Token: Was ist die maximal akzeptable Verzögerung vor der Bereitstellung des ersten Ausgabetokens?
    • Anmerkung: Die Latenz wird in der Regel mithilfe von p50 (Median) und p95 (95. Perzentil) gemessen, um die durchschnittliche Leistung und im schlimmsten Fall zu erfassen.
  • [P0] Zeit bis zum Abschluss: Was ist die akzeptable Antwortzeit (Zeit bis Zum Abschluss) für Benutzer?
  • [P0] Streaminglatenz: Wenn Antworten gestreamt werden, ist eine höhere Gesamtlatenz akzeptabel?

Skalierbarkeit

  • [P1]Gleichzeitige Benutzer und Anforderungen: Wie viele gleichzeitige Benutzer oder Anfragen sollten das System unterstützen?
    • Hinweis: Skalierbarkeit wird häufig in Bezug auf QPS (Abfragen pro Sekunde) oder QPM (Abfragen pro Minute) gemessen.
  • [P1] Verwendungsmuster: Was sind die erwarteten Datenverkehrsmuster, Spitzenlasten oder zeitbasierte Spitzen in der Nutzung?

Kostenbeschränkungen

  • [P0] Kostenbeschränkungen für Inferenzen: Was sind die Kosteneinschränkungen oder Budgetbeschränkungen für Inferenz-Berechnungsressourcen?

Auswertung

Legen Sie fest, wie die generative KI-App im Laufe der Zeit bewertet und verbessert wird.

  • [P0] Geschäfts-KPIs: Welches Geschäftsziel oder KPI sollte sich auf die Anwendung auswirken? Definieren Sie Ihre Basiswerte und Ziele.
  • [P0] Feedback der Projektbeteiligten: Wer gibt anfängliches und fortlaufendes Feedback zur Anwendungsleistung und -ausgabe? Identifizieren Sie bestimmte Benutzergruppen oder Domänenexperten.
  • [P0] Die Messung der Qualität: Welche Metriken (z. B. Genauigkeit, Relevanz, Sicherheit, Menschliche Bewertungen) werden verwendet, um die Qualität der generierten Ausgaben zu bewerten?
    • Wie werden diese Metriken während der Entwicklung berechnet (z. B. gegen synthetische Daten, manuell kuratierte Datasets)?
    • Wie wird die Qualität in der Produktion gemessen (z. B. Protokollierung und Analyse von Antworten auf echte Benutzerabfragen)?
    • Was ist Ihre Gesamttoleranz für Fehler? (Akzeptieren Sie beispielsweise einen bestimmten Prozentsatz kleiner sachlicher Ungenauigkeiten, oder fordern Sie Korrektheit von nahezu 100 % für kritische Anwendungsfälle.)
    • Ziel ist es, auf einen Auswertungssatz aus tatsächlichen Benutzerabfragen, synthetischen Daten oder einer Kombination aus beiden aufzubauen. Dieser Satz bietet eine konsistente Möglichkeit, die Leistung zu bewerten, während sich das System weiterentwickelt.
  • [P1] Feedbackschleifen: Wie sollten Benutzerfeedback gesammelt werden (z. B. Daumen nach oben/unten, Umfrageformulare) und verwendet werden, um iterative Verbesserungen voranzutreiben?
    • Planen Sie, wie oft Feedback überprüft und integriert wird.

Sicherheit

Identifizieren Sie alle Sicherheits- und Datenschutzaspekte.

  •  [P0] Datensensitivität: Gibt es vertrauliche oder sensible Datenelemente, die eine besondere Behandlung erfordern?
  •  [P1] Zugriffssteuerelemente: Müssen Sie Zugriffssteuerungen implementieren, um bestimmte Daten oder Funktionen einzuschränken?
  • [P1] Bedrohungsbewertung und Risikominderung: Muss Ihre Anwendung vor gängigen KI-Bedrohungen schützen, z. B. Eingabeaufforderungen oder böswillige Benutzereingaben?

Einsatz

Verstehen Sie, wie die GEN-KI-Lösung integriert, bereitgestellt, überwacht und verwaltet wird.

  • [P1] Integration: Wie soll die KI-gestützte Lösung in vorhandene Systeme und Workflows integriert werden?
    • Identifizieren Sie Integrationspunkte (z. B. Slack, CRM, BI-Tools) und erforderliche Datenkonnektoren.
    • Bestimmen Sie, wie Anforderungen und Antworten zwischen der KI-Gen-App und nachgeschalteten Systemen fließen (z. B. REST-APIs, Webhooks).
  • [P1] Bereitstellung: Welche Anforderungen gelten für die Bereitstellung, Skalierung und Versionsverwaltung der Anwendung? In diesem Artikel wird erläutert, wie der End-to-End-Lebenszyklus mit Databricks mithilfe von MLflow, Unity Catalog, Agent Framework, Agent Evaluation und Model Serving verarbeitet werden kann.
  • [P1] Produktionsüberwachung & Observability: Wie überwachen Sie die Anwendung, sobald sie sich in der Produktion befindet?
    • Protokollierung und Ablaufverfolgungen: Erfassen Sie vollständige Ausführungsablaufverfolgungen.
    • Qualitätsmetriken: Bewerten Sie kontinuierlich wichtige Metriken (z. B. Korrektheit, Latenz, Relevanz) für Livedatenverkehr.
    • Warnungen und Dashboards: Einrichten von Warnungen für kritische Probleme.
    • Feedbackschleife: Integrieren Sie Benutzerfeedback in die Produktion (Daumen nach oben oder unten), um Probleme frühzeitig abzufangen und iterative Verbesserungen voranzutreiben.

Beispiel

Betrachten Sie beispielsweise, wie diese Überlegungen und Anforderungen auf eine hypothetische agentische RAG-Anwendung angewendet werden, die von einem Databricks-Kundensupportteam verwendet wird:

Fläche Überlegungen Anforderungen
Benutzerfreundlichkeit
  • Interaktionsmodalitäten.
  • Typische Beispiele für Benutzerabfragen.
  • Erwartetes Antwortformat und Stil.
  • Behandeln von mehrdeutigen oder irrelevanten Abfragen.
  • In Slack integrierte Chatschnittstelle.
  • Beispielabfragen: "Wie kann ich die Startzeit des Clusters reduzieren?" "Welche Art von Supportplan habe ich?"
  • Klare, technische Antworten mit Codeausschnitten und Links zu relevanten Dokumentationen, falls zutreffend.
  • Stellen Sie kontextbezogene Vorschläge bereit, und eskalieren Sie sie bei Bedarf, um Techniker zu unterstützen.
Agentlogik
  • Abfrageverständnis und Klassifizierung.
  • Mehrstufige Planung und Entscheidungsfindung.
  • Autonome Toolauswahl und Ausführung.
  • Status- und Kontextverwaltung über Interaktionen hinweg.
  • Fehlerbehandlungs- und Fallbackmechanismen.
  • LLM-basierte Planung mit deterministischen Ausweichmöglichkeiten.
  • Integrieren Sie sich in eine Reihe vordefinierter Tools (z. B. den Docs-Abruf oder das Salesforce-Abruftool).
  • Aufrechterhalten des Konversationszustands für kohärente mehrteilige Interaktionen und robuste Fehlerwiederherstellung.
Daten
  • Anzahl und Typ von Datenquellen.
  • Datenformat und -position.
  • Datengröße und Aktualisierungshäufigkeit.
  • Datenqualität und -konsistenz.
  • Vier Datenquellen.
  • Unternehmensdokumentation (HTML, PDF).
  • Gelöste Supporttickets (JSON)
  • Beiträge des Communityforums (Delta-Tabelle).
  • Salesforce-Connector
  • Daten, die im Unity-Katalog gespeichert und wöchentlich aktualisiert werden.
  • Gesamtdatengröße: 5 GB.
  • Konsistente Datenstruktur und Gewährleistung der Qualität durch engagierte Dokumentations- und Supportteams
Leistung
  • Maximale zulässige Latenz.
  • Kosteneinschränkungen.
  • Erwartete Nutzung und Gleichzeitigkeit.
  • Maximale Latenzanforderung.
  • Kosteneinschränkungen.
  • Höchstlast erwartet.
Auswertung
  • Verfügbarkeit des Auswertungsdatensatzes.
  • Qualitätsmetriken.
  • Benutzerfeedbacksammlung.
  • Experten aus jedem Produktbereich helfen bei der Überprüfung der Ausgaben und passen falsche Antworten an, um das Auswertungsdatenset zu erstellen.
  • Geschäfts-KPIs.
  • Erhöhung der Rate gelöster Supporttickets
  • Verringerung der pro Supportticket aufgewendeten Benutzerzeit.
  • Qualitätsmetriken.
  • Vom LLM bewertete Korrektheit und Relevanz der Antworten
  • Einschätzung der Abrufgenauigkeit durch das LLM
  • Benutzerseitige Zustimmung oder Ablehnung
  • Feedbacksammlung.
  • Instrumentierung von Slack, um eine positive oder negative Bewertung bereitzustellen
Sicherheit
  • Vertrauliche Datenverarbeitung.
  • Anforderungen an die Zugriffssteuerung.
  • Es sollten keine vertraulichen Kundendaten in der Abrufquelle enthalten sein.
  • Benutzerauthentifizierung über Databricks Community SSO.
Einsatz
  • Integration in vorhandene Systeme.
  • Bereitstellung und Versionsverwaltung.
  • Integration in das Supportticketsystem
  • Bereitstellung als Endpunkt für die Databricks-Modellbereitstellung durch einen Agent

Lösungsentwurf

Weitere Entwurfsüberlegungen finden Sie unter Agent-Systementwurfsmuster.

Datenquellen und Tools

Beim Entwerfen einer KI-App der Generation ist es wichtig, die verschiedenen Datenquellen und Tools zu identifizieren und zuzuordnen, die zum Fördern Ihrer Lösung erforderlich sind. Dazu können strukturierte Datasets, unstrukturierte Datenverarbeitungspipelinen oder Abfragen externer APIs gehören. Im Folgenden finden Sie die empfohlenen Ansätze für die Einbindung verschiedener Datenquellen oder Tools in Ihre KI-Gen-App:

Strukturierte Daten

Strukturierte Daten befinden sich in der Regel in klar definierten tabellarischen Formaten (z. B. einer Delta-Tabelle oder CSV-Datei) und eignet sich ideal für Aufgaben, bei denen Abfragen entweder vorbestimmt sind oder dynamisch basierend auf Benutzereingaben generiert werden müssen. Empfehlungen zum Hinzufügen strukturierter Daten zu Ihrer generativen KI-App finden Sie unter KI-Agent-Tools für den strukturierten Abruf.

Unstrukturierte Daten

Unstrukturierte Daten umfassen rohe Dokumente, PDF-Dateien, E-Mails, Bilder und andere Formate, die nicht mit einem festen Schema übereinstimmen. Für solche Daten ist eine zusätzliche Verarbeitung erforderlich, in der Regel durch eine Kombination aus Analyse, Chunking und Einbetten, damit sie effektiv abgefragt und in einer Gen-AI-Anwendung genutzt werden können. Siehe Erstllen und Tracen von Retriever-Tools für unstrukturierte Daten für Empfehlungen zum Hinzufügen strukturierter Daten zu Ihrer Gen KI App.

Externe APIs und Aktionen

In einigen Szenarien muss Ihre KI-Gen-App möglicherweise mit externen Systemen interagieren, um Daten abzurufen oder Aktionen auszuführen. In Fällen, in denen Ihre Anwendung das Aufrufen von Tools oder die Interaktion mit externen APIs erfordert, empfehlen wir Folgendes:

  • Verwalten von API-Anmeldeinformationen mit einer Unity-Katalogverbindung: Verwenden Sie eine Unity-Katalogverbindung, um API-Anmeldeinformationen sicher zu steuern. Diese Methode stellt sicher, dass Token und geheime Schlüssel zentral verwaltet und zugriffsgesteuert werden.
  • Aufrufen über das Databricks SDK:
    Senden sie HTTP-Anforderungen mithilfe der http_request Funktion aus der databricks-sdk Bibliothek an externe Dienste. Diese Funktion nutzt eine Unity-Katalogverbindung für die Authentifizierung und unterstützt standardmäßige HTTP-Methoden.
  • Nutzen sie Unity-Katalogfunktionen:
    Umschließen externer Verbindungen in einer Unity-Katalogfunktion, um benutzerdefinierte Vor- oder Nachbearbeitungslogik hinzuzufügen.
  • Python-Executor-Tool:
    Um Code für Datentransformation oder API-Interaktionen mithilfe von Python-Funktionen dynamisch auszuführen, verwenden Sie das integrierte Python-Executortool.

Beispiel:

Eine interne Analyseanwendung ruft Live-Marktdaten aus einer externen Finanz-API ab. Die Anwendung verwendet:

Ansatz für die Implementierung

Beim Entwickeln einer KI-App der Generation haben Sie zwei Hauptoptionen für die Implementierung der Logik Ihres Agents: Nutzen eines Open Source-Frameworks oder Erstellen einer benutzerdefinierten Lösung mit Python-Code. Nachfolgend finden Sie eine Aufschlüsselung der Vor- und Nachteile für jeden Ansatz.

Verwenden eines Frameworks (z. B. LangChain, LlamaIndex, CrewAI oder AutoGen)

Vorteile:

  • Sofort einsatzbereite Komponenten: Frameworks verfügen über vorgefertigte Tools für die Prompt-Verwaltung, das Verketten von Aufrufen und die Integration in verschiedene Datenquellen, die die Entwicklung beschleunigen können.
  • Community und Dokumentation: Profitieren Sie von Communitysupport, Lernprogrammen und regelmäßigen Updates.
  • Allgemeine Entwurfsmuster: Frameworks bieten in der Regel eine klare, modulare Struktur für die Orchestrierung allgemeiner Aufgaben, die das Gesamtkonzept des Agenten vereinfachen können.

Nachteile:

  • Abstraktion hinzugefügt: Open-Source-Frameworks führen häufig Ebenen der Abstraktion ein, die für Ihren spezifischen Anwendungsfall möglicherweise unnötig sind.
  • Abhängigkeit von Updates: Möglicherweise sind Sie von den Framework-Betreuern für Fehlerkorrekturen und Featureupdates abhängig, die Ihre Fähigkeit verlangsamen können, sich schnell an neue Anforderungen anzupassen.
  • Potenzieller Aufwand: Eine zusätzliche Abstraktion kann zu Anpassungsproblemen führen, wenn Ihre Anwendung eine feiner abgestimmte Steuerung benötigt.
Verwenden von reinem Python

Vorteile:

  • Flexibilität: Die Entwicklung in reinem Python ermöglicht Es Ihnen, Ihre Implementierung genau auf Ihre Anforderungen anzupassen, ohne durch die Designentscheidungen eines Frameworks eingeschränkt zu werden.
  • Schnelle Anpassung: Sie können Ihren Code schnell anpassen und Änderungen nach Bedarf integrieren, ohne auf Updates von einem externen Framework zu warten.
  • Einfachheit: Vermeiden Sie unnötige Abstraktionsebenen, was potenziell zu einer schlankeren, leistungsreicheren Lösung führen kann.

Nachteile:

  • Steigerung des Entwicklungsaufwands: Das Erstellen von Grund auf erfordert möglicherweise mehr Zeit und Fachwissen, um Features zu implementieren, die ein dediziertes Framework andernfalls bereitstellen könnte.
  • Das Rad neu erfinden: Möglicherweise müssen Sie allgemeine Funktionen (z. B. Verkettung von Tools oder Eingabeaufforderungsverwaltung) eigenständig entwickeln.
  • Wartungsverantwortung: Alle Updates und Fehlerbehebungen sind Ihre Verantwortung, was für komplexe Systeme schwierig sein kann.

Letztendlich sollte Ihre Entscheidung durch die Komplexität, die Leistungsanforderungen und die Steuerungsebene, die Sie benötigen, gesteuert werden. Keiner der Ansätze ist von Natur aus überlegen; jeder bietet je nach Ihren Entwicklungspräferenzen und strategischen Prioritäten unterschiedliche Vorteile.

1. Erstellen

In dieser Phase transformieren Sie Ihr Lösungsdesign in eine funktionierende KI-Anwendung. Anstatt alles vorab zu perfektionieren, beginnen Sie klein mit einem minimalen Proof-of-Concept (POC), das schnell getestet werden kann. Auf diese Weise können Sie so schnell wie möglich in einer Pre-Production-Umgebung bereitstellen, repräsentative Abfragen von tatsächlichen Benutzern oder KMU sammeln und basierend auf realen Feedback verfeinern.

Flussdiagramm, das die Schritte Vorbereiten, Bauen und Bereitstellen zeigt.

Der Buildprozess folgt den folgenden wichtigen Schritten:

a) Vorbereiten von Daten und Tools: Stellen Sie sicher, dass auf die erforderlichen Daten zugegriffen, analysiert und abgerufen werden kann. Implementieren oder registrieren Sie die Unity-Katalogfunktionen und -verbindungen (z. B. Abruf-APIs oder externe API-Aufrufe), die Ihr Agent benötigt. b. Build-Agent: Orchestrieren Sie die Kernlogik, beginnend mit einem einfachen POC-Ansatz. c. Qualitätsprüfung: Überprüfen Sie die wesentlichen Funktionen, bevor Sie die App mehr Benutzern zur Seite stellen. d. Bereitstellen des Vorproduktions-Agents: Stellen Sie das POC (Proof of Concept) Benutzern und Fachexperten zur Verfügung, um erstes Feedback zu erhalten. e. Benutzerfeedback sammeln: Verwenden Sie reale Nutzung, um Verbesserungsbereiche, zusätzliche Daten oder Tools zu identifizieren, die für die nächste Iteration erforderlich sind, und potenzielle Verfeinerungen.

a) Vorbereiten von Daten und Tools

In der Lösungsentwurfsphase haben Sie eine erste Vorstellung von den Datenquellen und Tools, die für Ihre App erforderlich sind. Halten Sie es in dieser Phase minimal: Konzentrieren Sie sich auf nur genügend Daten, um Ihre POC zu überprüfen. Dadurch wird eine schnelle Iteration ohne große Investitionen in komplexe Pipelines sichergestellt.

Daten

  1. Identifizieren einer repräsentativen Teilmenge von Daten
    • Wählen Sie für strukturierte Daten die wichtigsten Tabellen oder Spalten aus, die für Ihr anfängliches Szenario am relevantesten sind.
    • Bei unstrukturierten Daten priorisieren Sie die Indizierung nur einer Teilmenge repräsentativer Dokumente. Verwenden Sie eine einfache Chunking-/Einbettungspipeline mit Mosaic AI Vector Search, sodass Ihr Agent bei Bedarf relevante Textblöcke abrufen kann.
  2. Einrichten des Datenzugriffs
  3. Überprüfen der grundlegenden Abdeckung
    • Vergewissern Sie sich, dass die ausgewählten Datenuntermengen den Benutzerabfragen, die Sie testen möchten, angemessen adressieren.
    • Speichern Sie alle zusätzlichen Datenquellen oder komplexe Transformationen für zukünftige Iterationen. Ihr aktuelles Ziel sollte eine grundlegende Machbarkeit nachweisen und Feedback sammeln.

Werkzeuge

Nachdem Ihre Datenquellen eingerichtet wurden, besteht der nächste Schritt darin, die Tools zu implementieren und zu registrieren, die Ihr Agent zur Laufzeit im Unity-Katalog aufruft. Ein Tool ist eine Einzelinteraktionsfunktion, z. B. eine SQL-Abfrage oder ein externer API-Aufruf, die der Agent zum Abrufen, Zur Transformation oder zur Aktion aufrufen kann.

Datenabruftools

  • Eingeschränkte, strukturierte Datenabfragen: Wenn Abfragen behoben sind, schließen Sie sie in eine Unity-Katalog-SQL-Funktion oder eine Python-UDF ein. Dadurch bleibt die Logik zentralisiert und auffindbar.
  • Offene, strukturierte Datenabfragen: Falls Abfragen offener sind, sollten Sie einen Genie-Bereich einrichten, um Text-zu-SQL-Abfragen zu bearbeiten.
  • Unstrukturierte Datenhilfsfunktionen: Erstellen Sie für unstrukturierte Daten, die in der Mosaik AI Vector Search gespeichert sind, ein unstrukturiertes Datenabruftool , das der Agent aufrufen kann, um relevante Textblöcke abzurufen.

API-Aufruftools

  • Externe API-Aufrufe:API-Aufrufe können mithilfe der Methode des Databricks SDK http_request.
  • Optionale Wrapper: Wenn Sie vor- oder nach der Verarbeitungslogik (z. B. Datennormalisierung oder Fehlerbehandlung) implementieren müssen, schließen Sie den API-Aufruf in eine Unity Catalog-Funktion um.

Halten Sie es minimal

  • Beginnen Sie nur mit wichtigen Tools: Konzentrieren Sie sich auf einen einzelnen Abrufpfad oder einen begrenzten Satz von API-Aufrufen. Sie können mehr hinzufügen, während Sie iterieren.
  • Interaktiv überprüfen: Testen Sie jedes Tool unabhängig (z. B. in einem Notizbuch), bevor Sie es in das Agentsystem integrieren.

Nachdem Ihre Prototyptools bereit sind, fahren Sie mit dem Erstellen des Agents fort. Der Agent koordiniert diese Tools, um Abfragen zu beantworten, Daten abzurufen und aktionen nach Bedarf auszuführen.

b. Build-Agent

Nachdem Ihre Daten und Tools vorhanden sind, können Sie den Agent erstellen, der auf eingehende Anforderungen wie Benutzerabfragen antwortet. Um einen ersten Prototyp-Agent zu erstellen, verwenden Sie entweder Python oder KI-Playground. Folgen Sie diesen Schritten:

  1. Einfach anfangen
    • Wählen Sie ein einfaches Entwurfsmuster aus: Beginnen Sie für einen POC entweder mit einer einfachen Kette (z. B. einer festen Abfolge von Schritten) oder einem einzelnen Toolaufruf-Agent (bei dem die LLM dynamisch ein oder zwei wesentliche Tools aufrufen kann).
      • Wenn Ihr Szenario mit einem der in der Databricks-Dokumentation bereitgestellten Beispielnotizbücher übereinstimmt, passen Sie diesen Code als Skelett an.
    • Minimale Eingabeaufforderung: Widersetzen Sie sich dem Drang, zu diesem Zeitpunkt die Eingabeaufforderungen zu übertechnisieren. Halten Sie Anweisungen prägnant und direkt für Ihre anfänglichen Aufgaben relevant.
  2. Integrieren von Tools
    • Toolintegration: Bei Verwendung eines Kettenentwurfsmusters werden die Schritte, die jedes Tool aufrufen, hartcodiert. In einem Toolaufruf-Agent geben Sie ein Schema an, damit die LLM weiß, wie die Funktion aufgerufen wird.
      • Überprüfen Sie, ob die isolierten Tools wie erwartet ausgeführt werden, bevor Sie sie in das Agentsystem integrieren und End-to-End testen.
    • Leitplanken: Wenn Ihr Agent externe Systeme ändern oder Code ausführen kann, stellen Sie sicher, dass Sie über grundlegende Sicherheitsprüfungen und Schutzmaßnahmen verfügen (z. B. die Anzahl der Anrufe beschränken oder bestimmte Aktionen einschränken). Implementieren Sie diese in einer Unity-Katalogfunktion.
  3. Verfolgen und Protokollieren des Agents mit MLflow
    • Verfolgen Sie jeden Schritt nach: Verwenden Sie die MLflow-Ablaufverfolgung , um Eingaben, Ausgaben und verstrichene Zeit pro Schritt zu erfassen, um Probleme zu debuggen und die Leistung zu messen.
    • Protokollieren Sie den Agent: Verwenden Sie die MLflow-Nachverfolgung , um den Code und die Konfiguration des Agents zu protokollieren.

In dieser Phase ist Perfektion nicht das Ziel. Sie möchten einen einfachen, funktionierenden Agent, den Sie für frühzeitiges Feedback von Testbenutzern und KMU bereitstellen können. Der nächste Schritt besteht darin, eine schnelle Qualitätsprüfung auszuführen, bevor sie in einer Vorproduktionsumgebung verfügbar ist.

c. Qualitätsprüfung

Bevor Sie den Agent für ein größeres Vorproduktionspublikum verfügbar machen, führen Sie eine hinreichende Offline-Qualitätsprüfung durch, um wichtige Probleme zu erfassen, bevor Sie ihn an einem Endpunkt implementieren. In dieser Phase verfügen Sie in der Regel nicht über ein großes, robustes Evaluierungsdatensatz, aber Sie können dennoch einen Schnelldurchlauf ausführen, um sicherzustellen, dass sich der Agent bei einigen Beispielsanfragen wie beabsichtigt verhält.

  1. Interaktives Testen in einem Notizbuch
    • manuelle Inspektion: Rufen Sie Ihren Agenten manuell mit repräsentativen Anfragen an. Achten Sie darauf, ob sie die richtigen Daten abruft, Tools richtig aufruft und dem gewünschten Format folgt.
    • Prüfen der MLflow-Ablaufverfolgungen: Wenn Sie die MLflow-Ablaufverfolgung aktiviert haben, prüfen Sie die Telemetriedaten Schritt für Schritt. Vergewissern Sie sich, dass der Agent die entsprechenden Tools auswählt, Fehler ordnungsgemäß behandelt und keine unerwarteten Zwischenanforderungen oder Ergebnisse generiert.
    • Latenz überprüfen: Beachten Sie, wie lange jede Anforderung ausgeführt werden muss. Wenn die Reaktionszeiten oder die Tokenverwendung zu hoch sind, müssen Sie möglicherweise Schritte löschen oder die Logik vereinfachen, bevor Sie fortfahren.
  2. Stimmungsüberprüfung
    • Dies kann entweder in einem Notizbuch oder in AI Playground erfolgen.
    • Kohärenz und Korrektheit: Ergibt die Ausgabe des Agents für die von Ihnen getesteten Abfragen Sinn? Gibt es eklatante Ungenauigkeiten oder fehlende Details?
    • Grenzfälle: Hat der Agent immer noch logisch reagiert oder zumindest ordnungsgemäß einen Fehler zurückgegeben (indem er beispielsweise höflich die Antwort verweigert hat, statt eine unsinnige Antwort zu erzeugen), als Sie einige ungewöhnliche Abfragen ausprobiert haben?
    • Prompte Einhaltung: Wenn Sie allgemeine Anweisungen wie z. B. gewünschte Töne oder Formatierungen bereitgestellt haben, folgt der Agent diesen?
  3. Bewerten der Qualität als „ausreichend“
    • Wenn Sie an diesem Punkt auf Testabfragen beschränkt sind, sollten Sie synthetische Daten generieren. Siehe Erstellen eines Auswertungssatzes.
    • Behandeln wichtiger Probleme: Wenn Sie wichtige Fehler entdecken (z. B. ruft der Agent wiederholt ungültige Tools an oder gibt Unsinn aus), beheben Sie diese Probleme, bevor Sie sie einer breiteren Zielgruppe zur Verfügung stellen. Sehen Sie sich allgemeine Qualitätsprobleme an und erfahren Sie, wie Sie sie beheben können.
    • Entscheiden Sie über die Rentabilität: Wenn der Agent eine einfache Leiste der Benutzerfreundlichkeit und Korrektheit für eine kleine Gruppe von Abfragen erfüllt, können Sie fortfahren. Falls nicht, verfeinern Sie die Eingabeaufforderungen, beheben Sie Tool- oder Datenprobleme, und testen Sie es erneut.
  4. Planen der nächsten Schritte
    • Verbesserungen nachverfolgen: Dokumentieren Sie alle Mängel, die Sie verschieben möchten. Nachdem Sie realitätsnahes Feedback in der Vorproduktionsphase gesammelt haben, können Sie diese überarbeiten.

Wenn alles für einen begrenzten Rollout geeignet erscheint, können Sie den Agent in der Präproduktion bereitstellen. Ein gründlicher Evaluierungsprozess erfolgt in späteren Phasen, insbesondere wenn Sie mehr echte Daten, KMU-Feedback und einen strukturierten Evaluierungssatz haben. Konzentrieren Sie sich jetzt darauf, sicherzustellen, dass Ihr Agent zuverlässig seine Kernfunktionen demonstriert.

d. Bereitstellen des Präproduktions-Agents

Nachdem Ihr Agent einen grundlegenden Qualitätsschwellenwert erreicht hat, besteht der nächste Schritt darin, ihn in einer Vorproduktionsumgebung zu hosten, damit Sie verstehen können, wie Benutzer die App abfragen und ihr Feedback sammeln können, um die Entwicklung zu leiten. Diese Umgebung kann Ihre Entwicklungsumgebung während der POC-Phase sein. Die Hauptanforderung besteht darin, dass die Umgebung für die Auswahl interner Tester oder Domänenexperten zugänglich ist.

  1. Bereitstellen des Agents
  2. Ableitungstabellen
    • Agent Framework speichert Anforderungen, Antworten und Ablaufverfolgungen für jeden Bereitstellungsendpunkt automatisch zusammen mit Metadaten in einer Rückschlusstabelle in Unity Catalog.
  3. Sichern und Konfigurieren
    • Zugriffssteuerung:Einschränken des Endpunktzugriffs auf Ihre Testgruppe (SMEs, Power Users). Dadurch wird eine kontrollierte Verwendung sichergestellt und unerwartete Datenexposition vermieden.
    • Authentifizierung: Vergewissern Sie sich, dass alle erforderlichen geheimen Schlüssel, API-Token oder Datenbankverbindungen ordnungsgemäß konfiguriert sind.

Sie haben jetzt eine kontrollierte Umgebung zum Sammeln von Feedback zu echten Abfragen. Eine der Möglichkeiten, mit dem Agent schnell zu interagieren, befindet sich in AI Playground, wo Sie den neu erstellten Model Serving-Endpunkt auswählen und den Agent abfragen können.

e. Sammeln von Benutzerfeedback

Nachdem Sie Ihren Agent in einer Vorproduktionsumgebung bereitgestellt haben, besteht der nächste Schritt darin, Feedback von realen Benutzern und KMU zu sammeln, um Lücken aufzudecken, Ungenauigkeiten zu erkennen und Ihren Agenten weiter zu verfeinern.

  1. Verwenden der Rezensions-App

    • Wenn Sie Ihren Agent mit Agent Framework bereitstellen, wird eine einfache Review-App im Chatstil erstellt. Es bietet eine benutzerfreundliche Oberfläche, über die Tester Fragen stellen und sofort die Antworten des Agenten bewerten können.
    • Alle Anfragen, Antworten und Benutzerfeedback (Daumen nach oben/unten, geschriebene Kommentare) werden automatisch an einer Rückschlusstabelle protokolliert, sodass sie später einfach analysiert werden können.

  2. Verwenden der Überwachungs-UI zum Überprüfen von Protokollen

    • Verfolgen Sie die Bewertungen (Daumen nach oben/Daumen nach unten) oder das textuelle Feedback in der Überwachungsbenutzeroberfläche nach, um zu sehen, welche Antworten die Testpersonen als besonders hilfreich (oder nicht hilfreich) empfunden haben.

  3. Einbeziehen von Domänenexperten

    • Ermutigen Sie KMU, typische und ungewöhnliche Szenarien zu durchlaufen. Domänenwissen hilft dabei, subtile Fehler wie Richtlinienfehler oder fehlende Daten zu erkennen.
    • Führen Sie eine Liste von Problemen – von geringfügigen Promptanpassungen bis hin zu umfassenderen Umgestaltungen der Datenpipeline. Entscheiden Sie, welche Korrekturen priorisiert werden sollen, bevor Sie fortfahren.

  4. Zusammenstellen neuer Auswertungsdaten

    • Konvertieren Sie wichtige oder problematische Interaktionen in Testfälle. Im Laufe der Zeit bilden diese die Grundlage eines stabileren Auswertungsdatensatzes.
    • Fügen Sie nach Möglichkeit korrekte oder erwartete Antworten zu diesen Fällen hinzu. Dies hilft dabei, die Qualität in nachfolgenden Auswertungszyklen zu messen.

  5. Iterieren basierend auf Feedback

    • Wenden Sie schnelle Korrekturen wie kleine Änderungen der Eingabeaufforderung oder neue Schutzmaßnahmen an, um aktuelle Probleme zu beheben.
    • Für komplexere Probleme, z. B. das Erfordern einer erweiterten mehrstufigen Logik oder neuer Datenquellen, sammeln Sie genügend Beweise, bevor Sie in wichtige Architekturänderungen investieren.

Durch die Nutzung von Feedback aus der Überprüfungs-App, Rückschlusstabellenprotokollen und SME-Erkenntnissen hilft diese Vorproduktionsphase dabei, wichtige Lücken zu erkennen und Ihren Agent iterativ zu optimieren. Die in diesem Schritt gesammelten realen Interaktionen bilden die Grundlage für die Erstellung eines strukturierten Evaluierungssatzes, sodass Sie von Ad-hoc-Verbesserungen zu einem systematischeren Ansatz zur Qualitätsmessung wechseln können. Nachdem wiederkehrende Probleme behoben und die Leistung stabilisiert wurden, sind Sie gut vorbereitet für eine Produktionsbereitstellung mit robuster Auswertung.

2. Auswerten und Iterieren

Nachdem Ihre KI-Gen-App in einer Vorproduktionsumgebung getestet wurde, besteht der nächste Schritt darin, die Qualität systematisch zu messen, zu diagnostizieren und zu verfeinern. Diese Phase "evaluieren und iterieren" wandelt rohes Feedback um und meldet sich in einen strukturierten Evaluierungssatz ein, sodass Sie wiederholt Verbesserungen testen und sicherstellen können, dass Ihre App die erforderlichen Standards für Genauigkeit, Relevanz und Sicherheit erfüllt.

Diese Phase umfasst die folgenden Schritte:

  • Sammeln Sie echte Abfragen aus Protokollen: Konvertieren Sie hochwertige oder problematische Interaktionen aus Ihren Ableitungstabellen in Testfälle.
  • Hinzufügen von Expertenbezeichnungen: Fügen Sie nach Möglichkeit Grundwahrheiten oder Stile und Richtlinien an diese Fälle an, damit Sie die Korrektheit, Bodenigkeit und andere Qualitätsdimensionen objektiver messen können.
  • Nutzen der Agent-Auswertung: Nutzen Sie integrierte LLM-Richter oder benutzerdefinierte Überprüfungen, um die App-Qualität zu messen.
  • Wiederholen: Verbessern Sie die Qualität, indem Sie die Logik, Datenpipelinen oder Eingabeaufforderungen Ihres Agents verfeinern. Führen Sie die Auswertung erneut aus, um zu überprüfen, ob Wichtige Probleme behoben wurden.

Beachten Sie, dass diese Funktionen auch dann funktionieren, wenn Ihre KI-Gen-App außerhalb von Databricks ausgeführt wird. Indem Sie Ihren Code mit der MLflow-Ablaufverfolgung instrumentieren, können Sie Ablaufverfolgungen aus jeder Umgebung erfassen und in der Databricks Data Intelligence Platform vereinheitlichen, um eine konsistente Auswertung und Überwachung zu ermöglichen. Wenn Sie weiterhin neue Abfragen, Feedback und KMU-Einblicke integrieren, wird Ihr Auswertungsdatensatz zu einer lebendigen Ressource, die einen kontinuierlichen Verbesserungszyklus untermauert, um sicherzustellen, dass Ihre KI-Gen-App robust, zuverlässig und mit den Geschäftszielen übereinstimmt.

Flussdiagramm mit den Schritten

a. Auswerten des Agents

Nachdem Ihr Agent in einer Vorproduktionsumgebung aktiv ist, besteht der nächste Schritt darin, seine Leistung über gelegentliche Stimmungstests hinaus systematisch zu messen. Mosaik AI Agent Evaluation ermöglicht es Ihnen, Evaluationssets zu erstellen, Qualitätsprüfungen mit integrierten oder benutzerdefinierten LLM-Richtern durchzuführen und schnell an Problembereichen zu iterieren.

Offline und Online-Evaluierungen

Bei der Bewertung von KI-Anwendungen der Generation gibt es zwei primäre Ansätze: Offline-Auswertung und Online-Auswertung. Diese Phase des Entwicklungszyklus konzentriert sich auf die Offline-Auswertung, die sich auf eine systematische Bewertung außerhalb der Live-Benutzerinteraktionen bezieht. Die Onlineauswertung wird später behandelt, wenn Sie die Überwachung Ihres Agenten in der Produktion besprechen.

Teams verlassen sich im Entwicklungsworkflow häufig zu lange zu sehr auf die Stimmungsüberprüfung, indem sie informell eine Handvoll Abfragen ausprobieren und subjektiv beurteilen, ob Antworten sinnvoll erscheinen. Obwohl dies einen Ausgangspunkt bietet, mangelt es an der notwendigen Strenge und Abdeckung, die erforderlich sind, um Anwendungen in professioneller Qualität zu erstellen.

Im Gegensatz dazu führt ein ordnungsgemäßer Offlineauswertungsprozess die folgenden Aktionen aus:

  • Erstellt eine Qualitätsbasislinie vor einer breiteren Bereitstellung, wodurch klare Metriken erstellt werden, die zur Verbesserung bestimmt werden sollen.
  • Identifiziert spezifische Schwachstellen , die Aufmerksamkeit erfordern und über die Begrenzung der Testverfahren hinausgehen, die sich nur auf erwartete Anwendungsfälle konzentrieren.
  • Erkennt Qualitätsregressionen , während Sie Ihre App verfeinern, indem Sie die Leistung in allen Versionen automatisch vergleichen.
  • Stellt quantitative Metriken bereit, um Verbesserungen für die Projektbeteiligten zu veranschaulichen.
  • Hilft, Randfälle und potenzielle Fehlermodi zu ermitteln, bevor es die Benutzer tun.
  • Verringert das Risiko , dass ein unperformanter Agent in die Produktion eingeführt wird.

Wenn Sie Zeit in die Offlinebewertung investieren, zahlt sich langfristig eine erhebliche Dividende aus, was Ihnen hilft, konsequent hochwertige Antworten zu liefern.

Erstellen eines Auswertungssatzes

Ein Evaluationssatz dient als Grundlage für die Messung der Leistung Ihrer generativen KI-App. Ähnlich wie bei einer Testsuite bei der herkömmlichen Softwareentwicklung wird diese Sammlung repräsentativer Abfragen und erwarteter Antworten zu Ihrem Qualitäts-Benchmark und Regressionstest-Dataset.

Flussdiagramm: Schritte zum Vorbereiten, Erstellen, Bereitstellen und Beheben von Problemen mit einem Auswertungssatz.

Sie können einen Evaluierungssatz durch mehrere ergänzende Ansätze erstellen:

  1. Transformieren von Rückschlusstabellenprotokollen in Auswertungsbeispiele

    Die wertvollsten Auswertungsdaten stammen direkt aus der realen Nutzung. Ihre Präproduktionsbereitstellung hat Rückschlusstabellenprotokolle generiert, die Anforderungen, Agent-Antworten, Toolaufrufe und abgerufenen Kontext enthalten.

    Das Konvertieren dieser Protokolle in einen Auswertungssatz bietet mehrere Vorteile:

    • Praxisnahe Abdeckung: Auch unvorhergesehene Benutzerverhalten, die Sie eventuell nicht erwartet haben, sind mit einbezogen.
    • Problemorientiert: Sie können speziell nach negativen Feedback- oder langsamen Antworten filtern.
    • Repräsentative Verteilung: Die tatsächliche Häufigkeit verschiedener Abfragetypen wird erfasst.

  2. Generieren synthetischer Auswertungsdaten

    Wenn Sie nicht über einen kuratierten Satz von Benutzerabfragen verfügen, können Sie automatisch ein synthetisches Auswertungsdatenset generieren. Dieser "Startsatz" von Abfragen hilft Ihnen, schnell zu beurteilen, ob der Agent:

    • Gibt kohärente, genaue Antworten zurück.
    • Antwortet im richtigen Format.
    • Respektiert Struktur, Tonalität und Richtlinien.
    • Richtiges Abrufen des Kontexts (für RAG).

    Synthetische Daten sind in der Regel nicht perfekt. Stellen Sie sich es als temporären Sprungstein vor. Außerdem möchten Sie:

    • Lassen Sie KMU oder Domänenexperten alle irrelevanten oder sich wiederholenden Abfragen überprüfen und beschneiden.
    • Ersetzen oder erweitern Sie sie später durch reale Verwendungsprotokolle.

  3. Manuelles Zusammenstellen von Abfragen

    Wenn Sie sich lieber nicht auf synthetische Daten verlassen oder noch keine Rückschlussprotokolle haben, identifizieren Sie 10 bis 15 echte oder repräsentative Abfragen, und erstellen Sie einen Auswertungssatz aus diesen. Repräsentative Abfragen können aus Benutzerinterviews oder Entwickler-Brainstorming stammen. Selbst eine kurze, kuratierte Liste kann blendende Fehler in den Antworten Ihres Agenten offenlegen.

Diese Ansätze schließen sich nicht gegenseitig aus, sondern ergänzen sich. Ein effektiver Evaluierungssatz entwickelt sich im Laufe der Zeit und kombiniert in der Regel Beispiele aus mehreren Quellen, einschließlich der folgenden:

  • Beginnen Sie mit manuell kuratierten Beispielen, um die Kernfunktionalität zu testen.
  • Fügen Sie optional synthetische Daten hinzu, um die Abdeckung zu erweitern, bevor Sie über echte Benutzerdaten verfügen.
  • Integrieren Sie schrittweise reale Protokolle, sobald sie verfügbar sind.
  • Aktualisieren Sie ständig mit neuen Beispielen, die sich ändernde Verwendungsmuster widerspiegeln.
Bewährte Methoden für Auswertungsabfragen

Fügen Sie bei der Erstellung Ihres Auswertungssatzes absichtlich verschiedene Abfragetypen wie die folgenden ein:

  • Sowohl erwartete als auch unerwartete Verwendungsmuster (z. B. sehr lange oder kurze Anforderungen).
  • Potenzielle Missbrauchsversuche oder Angriffe durch Prompteinschleusung (etwa Versuche, den Systemprompt offenzulegen).
  • Komplexe Abfragen, die mehrere Denkschritte oder Toolaufrufe erfordern.
  • Randfälle mit geringen oder mehrdeutigen Informationen (z. B. Rechtschreibfehler oder vage Abfragen).
  • Beispiele für unterschiedliche Benutzerkenntnisse und Hintergründe.
  • Abfragen, die auf potenzielle Voreingenommenheiten in Antworten testen (z. B. "Unternehmen A und Unternehmen B vergleichen").

Denken Sie daran, dass Ihr Evaluierungssatz zusammen mit Ihrer Anwendung wachsen und weiterentwickelt werden sollte. Wenn Sie neue Fehlermodi oder Benutzerverhalten aufdecken, fügen Sie repräsentative Beispiele hinzu, um sicherzustellen, dass Ihr Agent in diesen Bereichen weiterhin verbessert wird.

Hinzufügen von Bewertungskriterien

Jedes Bewertungsbeispiel sollte Kriterien haben, um die Qualität zu bewerten. Diese Kriterien dienen als Standards, mit denen die Antworten des Agenten gemessen werden, was eine objektive Bewertung über mehrere Qualitätsdimensionen ermöglicht.

Auf der Grundwahrheit basierende Tatsachen oder Referenzantworten

Bei der Bewertung der tatsächlichen Genauigkeit gibt es zwei Hauptansätze: erwartete Fakten oder Referenzantworten. Jeder dient einem anderen Zweck in Ihrer Bewertungsstrategie.

Verwenden sie erwartete Fakten (empfohlen)

Der expected_facts Ansatz umfasst die Auflistung der wichtigsten Fakten, die in einer korrekten Antwort erscheinen sollten. Ein Beispiel finden Sie unter Beispielauswertungssatz mit request, , response, guidelinesund expected_facts.

Dieser Ansatz bietet erhebliche Vorteile:

  • Ermöglicht Flexibilität bei der Darstellung der Fakten in der Antwort.
  • Erleichtert SMEs die Bereitstellung der Grundwahrheit.
  • Berücksichtigt verschiedene Antwortstile, während sichergestellt wird, dass kerne Informationen vorhanden sind.
  • Ermöglicht eine zuverlässigere Auswertung über Modellversionen oder Parametereinstellungen hinweg.

Der integrierte Korrektheitsrichter überprüft, ob die Reaktion des Agenten diese wesentlichen Fakten enthält, unabhängig von Ausdrücken, Anordnungen oder zusätzlichen Inhalten.

Verwenden der erwarteten Antwort (Alternative)

Alternativ können Sie eine vollständige Antwort als Referenz bereitstellen. Dieser Ansatz funktioniert in den folgenden Situationen am besten:

  • Sie haben Goldstandard-Antworten, die von Experten erstellt wurden.
  • Der genaue Wortlaut oder die Struktur der Antwort ist wichtig.
  • Sie bewerten Antworten in stark regulierten Kontexten.

Databricks empfiehlt im Allgemeinen die Verwendung von expected_facts über expected_response, da dies mehr Flexibilität bietet und gleichzeitig die Genauigkeit gewährleistet.

Richtlinien für Stil, Ton oder Richtlinieneinhaltung

Über die tatsächliche Genauigkeit hinaus müssen Sie möglicherweise bewerten, ob Antworten bestimmten Stil-, Ton- oder Richtlinienanforderungen entsprechen.

Nur Richtlinien

Wenn Ihr Hauptanliegen das Erzwingen von Stil- oder Richtlinienanforderungen und nicht die tatsächliche Genauigkeit ist, können Sie Richtlinien ohne erwartete Fakten bereitstellen:

# Per-query guidelines
eval_row = {
    "request": "How do I delete my account?",
    "guidelines": {
        "tone": ["The response must be supportive and non-judgmental"],
        "structure": ["Present steps chronologically", "Use numbered lists"]
    }
}

# Global guidelines (applied to all examples)
evaluator_config = {
    "databricks-agent": {
        "global_guidelines": {
            "rudeness": ["The response must not be rude."],
            "no_pii": ["The response must not include any PII information (personally identifiable information)."]
        }
    }
}

Der LLM-Richter interpretiert diese Anweisungen in natürlicher Sprache und prüft, ob die Antwort den Richtlinien entspricht. Dies eignet sich besonders gut für subjektive Qualitätsdimensionen wie Ton, Formatierung und Einhaltung von Organisationsrichtlinien.

Benutzeroberfläche des LLM-Richters zur Bewertung von Stil und Ton

Kombinieren von Grundwahrheit und Richtlinien

Für eine umfassende Auswertung können Sie Faktengenauigkeitsprüfungen mit Stilrichtlinien kombinieren. Siehe Beispielauswertungssatz mit request, response, , guidelinesund expected_facts. Mit diesem Ansatz wird sichergestellt, dass Die Antworten sowohl sachlich korrekt sind als auch den Kommunikationsstandards Ihrer Organisation entsprechen.

Verwenden von vorab erfassten Antworten

Wenn Sie bereits Anforderungsantwortpaare aus der Entwicklung oder dem Testen erfasst haben, können Sie sie direkt auswerten, ohne Ihren Agent erneut aufzufordern. Dies ist nützlich für:

  • Analysieren vorhandener Muster im Verhalten Ihres Agenten.
  • Benchmarking der Leistung im Vergleich zu früheren Versionen.
  • Sparen Sie Zeit und Kosten, indem Sie antworten nicht neu generieren.
  • Bewertung eines außerhalb von Databricks bereitgestellten Agenten.

Ausführliche Informationen zum Bereitstellen der relevanten Spalten in Ihrem Auswertungs-DataFrame finden Sie unter Beispiel: Übergeben zuvor generierter Ausgaben an die Agent-Auswertung. Mosaik AI Agent Evaluation verwendet diese vorgespeicherten Werte, anstatt Ihren Agenten erneut aufzurufen, während weiterhin dieselben Qualitätsprüfungen und Metriken angewendet werden.

Bewährte Methoden für Bewertungskriterien

Beim Definieren der Bewertungskriterien:

  1. Seien Sie spezifisch und objektiv: Definieren Sie klare, messbare Kriterien, die verschiedene Bewerter auf ähnliche Weise interpretieren würden.
    • Erwägen Sie das Hinzufügen von benutzerdefinierten Metriken, um die von Ihnen gewünschten Qualitätskriterien zu messen.
  2. Konzentrieren Sie sich auf den Benutzerwert: Priorisieren Sie Kriterien, die ihren Benutzern am wichtigsten sind.
  3. Beginnen Sie einfach: Beginnen Sie mit einem Kernsatz von Kriterien, und erweitern Sie sich, wenn Ihr Verständnis der Qualitätsanforderungen wächst.
  4. Ausgewogene Abdeckung: Berücksichtigen Sie Kriterien, die verschiedene Aspekte der Qualität abdecken (z. B. faktische Genauigkeit, Stil und Sicherheit).
  5. Iterieren Sie basierend auf Feedback: Verfeinern Sie Ihre Kriterien basierend auf den Rückmeldungen der Nutzer und den sich ändernden Anforderungen.

Weitere Informationen zum Erstellen von hochwertigen Auswertungsdatensätzen finden Sie unter "Bewährte Methoden für die Entwicklung eines Evaluierungssatzes ".

Ausführen von Auswertungen

Nachdem Sie nun ein Evaluierungsset mit Abfragen und Kriterien erstellt haben, können Sie eine Auswertung mit mlflow.evaluate() durchführen. Mit dieser Funktion wird der gesamte Auswertungsprozess behandelt, von der Aufrufung Ihres Agenten bis hin zur Analyse der Ergebnisse.

Einfacher Auswertungsworkflow

Das Ausführen einer grundlegenden Auswertung erfordert nur einige Codezeilen. Ausführliche Informationen finden Sie unter Ausführen einer Auswertung.

Wenn die Auswertung ausgelöst wird:

  1. Für jede Zeile in Ihrem Auswertungssatz führt mlflow.evaluate() Folgendes aus:
    • Ruft Ihren Agent mit der Abfrage auf (wenn Sie noch keine Antwort bereitgestellt haben).
    • Wendet integrierte LLM-Richter an, um Qualitätsdimensionen zu bewerten.
    • Berechnet betriebstechnische Metriken wie Tokenverwendung und Latenz.
    • Zeichnet detaillierte Gründe für jede Bewertung auf.
  2. Die Ergebnisse werden automatisch bei MLflow protokolliert, wodurch Folgendes erstellt wird:
    • Zeilenbasierte Qualitätsauswertungen.
    • Aggregierte Metriken in allen Beispielen.
    • Detaillierte Protokolle zum Debuggen und Analysieren.

LLM-Richter-Benutzeroberfläche mit Richterbewertungen.

Anpassen der Auswertung

Sie können die Auswertung mit zusätzlichen Parametern auf Ihre spezifischen Anforderungen anpassen. Der evaluator_config Parameter ermöglicht Folgendes:

  • Wählen Sie aus, welche integrierten Richter ausgeführt werden sollen.
  • Legen Sie globale Richtlinien fest, die für alle Beispiele gelten.
  • Konfigurieren Sie Schwellenwerte für Richter.
  • Stellen Sie Few-Shot-Beispiele bereit, um Auswertungen anzuleiten.

Ausführliche Informationen und Beispiele finden Sie unter "Beispiele".

Bewerten Sie Agenten außerhalb von Databricks

Ein leistungsstarkes Feature der Agentenevaluierung ist die Fähigkeit, generative KI-Anwendungen zu bewerten, die überall implementiert werden, nicht nur auf Databricks.

Welche Richter berufen werden

Standardmäßig wählt die Agent-Auswertung automatisch die geeigneten LLM-Richter basierend auf den in Ihrem Auswertungssatz verfügbaren Daten aus. Ausführliche Informationen zur Bewertung der Qualität finden Sie unter " Qualität wird von LLM-Richtern bewertet".

Analysieren von Auswertungsergebnissen

Nach dem Ausführen einer Auswertung bietet die MLflow-UI Visualisierungen und Einblicke, um die Leistung Ihrer App zu verstehen. Mit dieser Analyse können Sie Muster identifizieren, Probleme diagnostizieren und Verbesserungen priorisieren.

Wenn Sie die MLflow-Benutzeroberfläche öffnen, nachdem Sie ausgeführt mlflow.evaluate(), haben, finden Sie mehrere miteinander verbundene Ansichten. Informationen zum Navigieren in diesen Ergebnissen in der MLflow-UI finden Sie unter "Ergebnisse mit der MLflow-UI überprüfen".

Anleitungen zum Interpretieren von Fehlermustern finden Sie unter b. Verbessern von Agent und Tools.

Benutzerdefinierte KI-Richter und Metriken

Während integrierte Richter viele allgemeine Prüfungen (z. B. Korrektheit, Stil, Richtlinie und Sicherheit) abdecken, müssen Sie möglicherweise domänenspezifische Aspekte der Leistung Ihrer App bewerten. Mit benutzerdefinierten Richtern und Metriken können Sie die Auswertungsfunktionen erweitern, um Ihre einzigartigen Qualitätsanforderungen zu erfüllen.

Benutzerdefinierte LLM-Richter

Ausführliche Informationen zum Erstellen eines benutzerdefinierten LLM-Richters aus einer Eingabeaufforderung finden Sie unter Erstellen von KI-Richtern aus einer Eingabeaufforderung.

Benutzerdefinierte Richter zeichnen sich bei der Bewertung subjektiver oder nuancierter Qualitätsdimensionen aus, die von menschlichem Urteil profitieren, z. B.:

  • Domänenspezifische Compliance (legal, medical, financial).
  • Markenstimme und Kommunikationsstil.
  • Kulturelle Empfindlichkeit und Angemessenheit.
  • Komplexe Begründungsqualität.
  • Spezielle Schreibkonventionen.

Die Ausgabe des Richters wird auf der MLflow-Benutzeroberfläche zusammen mit integrierten Richtern angezeigt. Dabei werden die gleichen detaillierten Begründungen der Bewertungen dargestellt.

Benutzerdefinierte Metriken

Für weitere programmgesteuerte, deterministische Bewertungen können Sie benutzerdefinierte Metriken mithilfe des @metric Dekorators erstellen. Siehe @metric Dekorateur.

Benutzerdefinierte Metriken eignen sich ideal für:

  • Überprüfen technischer Anforderungen wie Formatüberprüfung und Schemakompatibilität.
  • Überprüfen auf die Anwesenheit oder das Fehlen bestimmter Inhalte.
  • Durchführen quantitativer Messungen wie Antwortlänge oder Komplexitätsbewertungen.
  • Implementieren von geschäftsspezifischen Gültigkeitsprüfungsregeln.
  • Integration in externe Validierungssysteme.

b. Verbesserung von Agenten und Tools

Nach der Auswertung und dem Identifizieren von Qualitätsproblemen besteht der nächste Schritt darin, diese Probleme systematisch zu beheben, um die Leistung zu verbessern. Die Auswertungsergebnisse liefern wertvolle Einblicke darüber, wo und wie Ihr Agent fehlschlägt, sodass Sie gezielte Verbesserungen statt zufällige Anpassungen vornehmen können.

Häufige Qualitätsprobleme und wie sie behoben werden

Die Bewertungen der LLM-Richter aus Ihren Auswertungsergebnissen verweisen auf bestimmte Arten von Fehlern in Ihrem Agent-System. In diesem Abschnitt werden diese allgemeinen Fehlermuster und ihre Lösungen erläutert. Informationen zum Interpretieren von LLM-Richterergebnissen finden Sie unter Ausgaben von KI-Richtern.

Bewährte Methoden für die Qualitätsiteration

Wenn Sie Verbesserungen vornehmen, behalten Sie eine strenge Dokumentation bei. Beispiel:

  1. Version Ihrer Änderungen
    • Protokollieren Sie jede signifikante Iteration mithilfe der MLflow-Nachverfolgung.
    • Speichern Sie Eingabeaufforderungen, Konfigurationen und Schlüsselparameter in einer zentralen Konfigurationsdatei. Stellen Sie sicher, dass dies mit dem Agent protokolliert wird.
    • Bewahren Sie für jeden neuen bereitgestellten Agent einen Änderungsprotokoll in Ihrem Repository auf, in dem die änderungen und warum beschrieben werden.
  2. Dokumentieren, was funktioniert hat und was nicht funktioniert hat
    • Dokumentieren Sie erfolgreiche und erfolglose Ansätze.
    • Beachten Sie die spezifischen Auswirkungen jeder Änderung auf Metriken. Stellen Sie eine Verknüpfung mit der MLflow-Ausführung der Agent-Auswertung her.
  3. Abstimmen mit Projektbeteiligten
    • Verwenden Sie die Überprüfungs-App, um Verbesserungen mit KMU zu überprüfen.
    • Für einen parallelen Vergleich verschiedener Versionen eines Agents sollten Sie mehrere Agent-Endpunkte erstellen und das Modell in AI Playground verwenden. Auf diese Weise können Benutzer dieselbe Anforderung an separate Endpunkte senden und die Antwort und Ablaufverfolgungen nebeneinander untersuchen.

3. Produktion

Nachdem Sie Ihre App iterativ ausgewertet und verbessert haben, haben Sie ein Qualitätsniveau erreicht, das Ihren Anforderungen entspricht und für eine breitere Verwendung bereit ist. Die Produktionsphase umfasst die Bereitstellung Ihres optimierten Agenten in Ihrer Produktionsumgebung und die Implementierung einer kontinuierlichen Überwachung, um die Qualität im Laufe der Zeit aufrechtzuerhalten.

Die Produktionsphase umfasst:

  • Bereitstellen des Agents für die Produktion: Richten Sie einen produktionsfähigen Endpunkt mit entsprechenden Sicherheits-, Skalierungs- und Authentifizierungseinstellungen ein.
  • Überwachung des Agents in der Produktion: Etablieren Sie eine kontinuierliche Qualitätsbewertung, Leistungsnachverfolgung und Warnmeldungen, um sicherzustellen, dass Ihr Agent hohe Qualität und Zuverlässigkeit im Echtweltbetrieb gewährleistet.

Dadurch wird eine kontinuierliche Feedbackschleife erstellt, in der Die Überwachung von Erkenntnissen weitere Verbesserungen ermöglicht, die Sie testen, bereitstellen und weiterhin überwachen können. Dieser Ansatz stellt sicher, dass Ihre App während ihres gesamten Lebenszyklus qualitativ hochwertig, konform und auf die sich wandelnden Geschäftsanforderungen ausgerichtet bleibt.

Flussdiagramm mit vollständigem KI-Entwicklungsworkflow, einschließlich Überwachung und Protokollen.

a) Bereitstellen des Agents in der Produktion

Nachdem Sie eine gründliche Bewertung und iterative Verbesserung abgeschlossen haben, können Sie Ihren Agent in einer Produktionsumgebung bereitstellen. [Mosaik AI Agent Framework](/generative-ai/agent-framework/build-gen AI-apps.md#agent-framework) vereinfacht diesen Prozess, indem viele Bereitstellungsbedenken automatisch behandelt werden.

Bereitstellungsprozess

Die Bereitstellung Ihres Agents in der Produktion umfasst die folgenden Schritte:

  1. Protokollieren und registrieren Sie Ihren Agent als MLflow-Modell in Unity Catalog.
  2. Stellen Sie den Agent mithilfe des Agent-Frameworks bereit.
  3. Konfigurieren Sie die Authentifizierung für abhängige Ressourcen , auf die Ihr Agent zugreifen muss.
  4. Testen Sie die Bereitstellung, um die Funktionalität in der Produktionsumgebung zu überprüfen.
    • Nachdem das Modell zum Verarbeiten des Endpunkts bereit ist, können Sie mit dem Agent im KI-Playground interagieren, in dem Sie die Funktionalität testen und überprüfen können.

Ausführliche Implementierungsschritte finden Sie unter Bereitstellen eines Agents für generative KI-Anwendungen.

Überlegungen zur Produktionsimplementierung

Beachten Sie bei der Umstellung auf die Produktion die folgenden wichtigen Überlegungen:

Leistung und Skalierung

  • Wägen Sie Kosten gegen Leistung ab, basierend auf Ihren erwarteten Nutzungsmustern.
  • Erwägen Sie die Aktivierung von Scale-to-Zero für zeitweise verwendete Agenten, um die Kosten zu reduzieren.
  • Verstehen der Latenzanforderungen basierend auf den Benutzererfahrungsanforderungen Ihrer Anwendung.

Sicherheit und Governance

Integrationsansatz

  • Bestimmen Sie, wie Ihre Anwendung mit dem Agent interagiert (z. B. mithilfe einer API oder einer eingebetteten Schnittstelle).
  • Überlegen Sie, wie Sie Agentantworten in Ihrer Anwendung behandeln und anzeigen.
    • Wenn Ihre Clientanwendung zusätzlichen Kontext benötigt (z. B. Quelldokumentverweise oder Konfidenzbewertungen), entwerfen Sie ihren Agent so, dass diese Metadaten in die Antworten eingeschlossen werden (z. B. mithilfe von benutzerdefinierten Ausgaben).
  • Planen Sie die Fehlerbehandlung und Fallbackmechanismen für den Fall, dass der Agent nicht verfügbar ist.

Feedbacksammlung

  • Nutzen Sie die Review-App für das Feedback der Stakeholder während des ersten Rollouts.
  • Entwerfen Sie Mechanismen, um Benutzerfeedback direkt auf der Benutzeroberfläche zu sammeln.
  • Stellen Sie sicher, dass Feedbackdaten in Ihren Auswertungs- und Verbesserungsprozess fließen.

b. Überwachen des Agents in der Produktion

Nachdem Ihr Agent für die Produktion bereitgestellt wurde, ist es wichtig, die Leistung, Qualität und Nutzungsmuster kontinuierlich zu überwachen. Im Gegensatz zu herkömmlicher Software, bei der Funktionalität deterministisch ist, können KI-Apps Qualitätsabweichungen oder unerwartete Verhaltensweisen aufweisen, wenn sie auf reale Eingaben stoßen. Mithilfe der effektiven Überwachung können Sie Probleme frühzeitig erkennen, Nutzungsmuster verstehen und die Qualität Ihrer Anwendung kontinuierlich verbessern.

Einrichten der Agent-Überwachung

Mosaik AI bietet integrierte Überwachungsfunktionen , mit denen Sie die Leistung Ihres Agents nachverfolgen können, ohne benutzerdefinierte Überwachungsinfrastruktur zu erstellen:

  1. Erstellen Sie einen Monitor für Ihren bereitgestellten Agent.
  2. Konfigurieren Sie die Samplingrate und -häufigkeit basierend auf den Anforderungen für Datenverkehrsvolumen und Überwachung.
  3. Wählen Sie Qualitätsmetriken aus, die bei stichprobenierten Anforderungen automatisch ausgewertet werden sollen.

Wichtige Überwachungsdimensionen

Im Allgemeinen sollte eine wirksame Überwachung drei kritische Dimensionen umfassen:

  1. Operative Metriken

    • Fordern Sie Volumen und Muster an.
    • Antwortlatenz.
    • Fehlerraten und -typen.
    • Tokennutzung und Kosten

  2. Qualitätsmetriken

    • Relevanz für Benutzerabfragen.
    • Fundiertheit im abgerufenen Kontext
    • Sicherheit und Richtlinientreue.
    • Gesamte Qualitätserfolgsquote

  3. Benutzerfeedback

    • Explizites Feedback (Daumen nach oben/unten).
    • Implizite Signale (Nachverfolgungsfragen, verlassene Unterhaltungen).
    • Probleme, die an Supportkanäle gemeldet wurden.

Verwenden der Überwachungsbenutzeroberfläche

Die Überwachungs-Benutzeroberfläche bietet visualisierte Einblicke in diese Dimensionen über zwei Registerkarten.

Mithilfe von Filterfunktionen können Benutzer nach bestimmten Abfragen suchen oder nach Auswertungsergebnissen filtern. Weitere Informationen finden Sie unter Was ist Lakehouse Monitoring für generative KI? (MLflow 2).

Erstellen von Dashboards und Warnungen

Für eine umfassende Überwachung:

  • Erstellen Sie benutzerdefinierte Dashboards unter Verwendung der Überwachungsdaten, die in der Tabelle für ausgewertete Traces gespeichert sind.
  • Richten Sie Warnungen für kritische Qualitäts- oder Betriebsschwellenwerte ein.
  • Planen Sie regelmäßige Qualitätsüberprüfungen mit wichtigen Projektbeteiligten.

Kontinuierlicher Verbesserungszyklus

Die Überwachung ist am wertvollsten, wenn sie wieder in Ihren Verbesserungsprozess eingespeist wird:

  1. Identifizieren Sie Probleme durch Überwachen von Metriken und Benutzerfeedback.
  2. Exportieren Sie problematische Beispiele in Ihren Auswertungssatz.
  3. Ursachen diagnostizieren mithilfe der MLflow-Ablaufverfolgungsanalyse und LLM-Bewertungsergebnissen (wie in häufigen Qualitätsproblemen und wie man sie behebt besprochen).
  4. Entwickeln und testen Sie Verbesserungen anhand Ihres erweiterten Evaluierungssatzes.
  5. Bereitstellen von Updates und Überwachen der Auswirkungen.

Mit diesem iterativen, geschlossenen Loop-Ansatz können Sie sicherstellen, dass Ihr Agent basierend auf realen Nutzungsmustern weiterhin verbessert wird und gleichzeitig hohe Qualität bei gleichzeitiger Anpassung an sich ändernde Anforderungen und Benutzerverhalten gewährleistet. Mit der Agent-Überwachung erhalten Sie Einblick in die Leistung Ihres Agenten in der Produktion, sodass Sie Probleme proaktiv beheben und Qualität und Leistung optimieren können.