Generativt arbetsflöde för AI-apputvecklare

Att utveckla ett robust generativt AI-program (gen AI-app) kräver avsiktlig planering, en snabb loop för utvärdering av utvecklingsfeedback och skalbar produktionsinfrastruktur. Det här arbetsflödet beskriver en rekommenderad sekvens med steg som vägleder dig från initial proof-of-concept (POC) till produktionsdistribution.

0. Förutsättningar

• Samla in krav för att verifiera gen-AI-anpassning och identifiera begränsningar.
• Utforma din lösningsarkitektur.

1. Skapa

• Förbered datakällor och skapa nödvändiga verktyg.
• Skapa och validera den första prototypen (POC).
• Distribuera i förproduktionsmiljö.

2. Utvärdera & Iterera

• Samla in feedback från användare och mäta kvalitet
• Åtgärda kvalitetsproblem genom att förfina agentlogik och verktyg baserat på utvärdering.
• Införliva indata från ämnesexperten (SME) för att kontinuerligt förbättra agentsystemets kvalitet.

3. Produktion

• Distribuera en gen AI-app till produktionsmiljön.
• Övervaka prestanda och kvalitet.
• Underhålla och förbättra baserat på verklig användning.

Det här arbetsflödet bör vara iterativt: efter varje distributions- eller utvärderingscykel återgår du till tidigare steg för att förfina datapipelines eller uppdatera agentlogik. Produktionsövervakning kan till exempel visa nya krav, utlösa uppdateringar av agentdesignen och en annan utvärderingsrunda. Genom att följa dessa steg systematiskt och utnyttja funktionerna för Databricks MLflow-spårning, agentramverk och agentutvärdering kan du skapa högkvalitativa GEN AI-appar som på ett tillförlitligt sätt uppfyller användarnas behov, respekterar kraven på säkerhet och efterlevnad och fortsätter att förbättras med tiden.

0. Förutsättningar

Innan du börjar utveckla ditt gen-AI-program kan det inte överskattas hur viktigt det är att ta sig tid att göra följande på rätt sätt: samla in krav och lösningsdesign.

Insamlingskrav innehåller följande steg:

• Kontrollera om gen AI passar ditt användningsfall.
• Definiera användarupplevelsen.
• Utforska datakällor.
• Ange prestandabegränsningar.
• Samla in säkerhetsbegränsningar.

Lösningsdesign innehåller följande:

• Mappa ut datapipelines.
• Identifiera nödvändiga verktyg.
• Beskriva den övergripande systemarkitekturen.

Genom att lägga grunden anger du en tydlig riktning för efterföljande Build, Evaluateoch Production stages.

Insamling av krav

Att definiera tydliga och omfattande krav för användningsfall är ett viktigt första steg i utvecklingen av din lyckade gen AI-app. Dessa krav har följande syften:

• De hjälper dig att avgöra om en gen AI-metod är lämplig för ditt användningsfall.
• De vägleder beslut om lösningsdesign, implementering och utvärdering.

Investeringstid från början för att samla in detaljerade krav kan förhindra betydande utmaningar senare i utvecklingsprocessen och säkerställa att den resulterande lösningen uppfyller slutanvändarnas och intressenternas behov. Väldefinierade krav utgör grunden för de efterföljande stegen i programmets livscykel.

Passar användningsfallet bra för gen-AI?

Innan du ansluter dig till en gen AI-lösning bör du överväga om dess inneboende styrkor överensstämmer med dina krav. Några exempel där en generativ AI-lösning passar bra är:

• Innehållsgenerering: Uppgiften kräver att nytt eller kreativt innehåll genereras som inte kan uppnås med statiska mallar eller enkel regelbaserad logik.
• Dynamisk frågehantering: Användarfrågor är öppna eller komplexa och kräver flexibla, sammanhangsmedvetna svar.
• Informationssyntes: Användningsfallet drar nytta av att kombinera eller sammanfatta olika informationskällor för att skapa en sammanhängande utdata.
• AgentSystem: Programmet kräver mer än att bara generera text som svar på en fråga. Den kan behöva kunna:
  • planering och beslutsfattande: att formulera en strategi i flera steg för att uppnå ett specifikt mål.
  • Vidta åtgärder: Utlösa externa processer eller anropa olika verktyg för att utföra uppgifter (till exempel att hämta data, göra API-anrop, köra SQL-frågor, köra kod).
  • Upprätthålla tillstånd: Hålla reda på konversationshistorik eller aktivitetskontext över flera interaktioner för att möjliggöra kontinuitet.
  • Att producera anpassningsbara utdata: Generera svar som utvecklas baserat på tidigare åtgärder, uppdaterad information eller ändrade villkor.

Omvänt är en gen-AI-metod kanske inte idealisk i följande situationer:

• Uppgiften är mycket deterministisk och kan effektivt lösas med fördefinierade mallar eller regelbaserade system.
• Hela uppsättningen nödvändig information är redan statisk eller passar inom ett enkelt, stängt ramverk.
• Svar med extremt låg fördröjning (millisekunder) krävs, och överbelastningen av generativ bearbetning kan inte hanteras.
• Enkla, mallade svar räcker för det avsedda användningsfallet.

Viktig

I avsnitten nedan används etiketter P0, P1och P2 etiketter för att ange relativ prioritet.

• 🟢 [P0] objekt är kritiska eller nödvändiga. Dessa måste åtgärdas omedelbart.
• 🟡 [P1] objekt är viktiga men kan följas efter P0- krav.
• ⚪ [P2] objekt är överväganden med lägre prioritet eller förbättringar som kan åtgärdas när tid och resurser tillåter det.

Dessa etiketter hjälper teamen att snabbt se vilka krav som behöver omedelbar uppmärksamhet jämfört med vilka som kan skjutas upp.

Användarupplevelse

Definiera hur användarna ska interagera med den allmänna AI-appen och vilken typ av svar som förväntas.

• 🟢 [P0] Typisk begäran: Hur ser en typisk användarbegäran ut? Samla in exempel från intressenter.
• 🟢 [P0] Förväntade svar: Vilken typ av svar ska systemet generera (till exempel korta svar, långformsförklaringar, kreativa berättelser)?
• 🟡 [P1] Interaktionsmodalitet: Hur interagerar användarna med programmet (till exempel chattgränssnitt, sökfält, röstassistent)?
• 🟡 [P1] Ton, stil, struktur: Vilken ton, stil och struktur ska de genererade utdata anta (formell, konversations-, teknisk, punkt- eller kontinuerlig prosa)?
• 🟡 [P1]Felhantering: Hur ska programmet hantera tvetydiga, ofullständiga eller icke-målrelaterade frågor? Ska den ge feedback eller begära förtydligande?
• ⚪ [P2] Formateringskrav: Finns det några specifika formaterings- eller presentationsriktlinjer för utdata (inklusive metadata eller kompletterande information)?

Data

Fastställa art, källa och kvalitet för de data som ska användas i den allmänna AI-appen.

• 🟢 [P0] Datakällor: Vilka datakällor är tillgängliga?
  • För varje källa avgör du:
    • Är data strukturerade eller ostrukturerade?
    • Vad är källformatet (till exempel PDF, HTML, JSON, XML)?
    • Var finns data?
    • Hur mycket data är tillgängligt?
    • Hur ska data nås?
• 🟡 [P1] Datauppdateringar: Hur ofta uppdateras data? Vilka mekanismer finns för att hantera uppdateringar?
• 🟡 [P1] Datakvalitet: Finns det kända kvalitetsproblem eller inkonsekvenser?
  • Överväg om det krävs någon kvalitetsövervakning av datakällor.

Överväg att skapa en inventeringstabell för att konsolidera den här informationen, till exempel:

Datakälla	Källa	Filtyper	Storlek	Uppdateringsfrekvens
Datakälla 1	Unity Catalog-volymen	JSON	10 GB	Daglig
Datakälla 2	Offentligt API	XML	NA (API)	Realtid
Datakälla 3	SharePoint	PDF, .docx	500 MB	Månatlig

Prestandabegränsningar

Samla in prestanda- och resurskrav för gen AI-programmet.

Svarstid

• 🟢 [P0] Time-to-first-token: Vad är den maximala acceptabla fördröjningen innan du levererar den första token för utdata?
  • Obs! Svarstid mäts vanligtvis med hjälp av p50 (median) och p95 (95:e percentilen) för att samla in både genomsnittliga och sämsta prestanda.
• 🟢 [P0] Time-to-completion: Vad är den acceptabla svarstiden (tid till slutförande) för användare?
• 🟢 [P0] Svarstid för direktuppspelning: Om svar strömmas, är en högre total svarstid acceptabel?

Skalbarhet

• 🟡 [P1]samtidiga användare & begäranden: Hur många samtidiga användare eller begäranden ska systemet stödja?
  • Obs! Skalbarhet mäts ofta när det gäller QPS (frågor per sekund) eller QPM (frågor per minut).
• 🟡 [P1] Användningsmönster: Vilka är de förväntade trafikmönstren, högsta belastningen eller tidsbaserade toppar i användningen?

Kostnadsbegränsningar

• 🟢 [P0] Begränsningar för slutsatsdragningskostnad: Vilka är kostnadsbegränsningarna eller budgetbegränsningarna för beräkningsresurser för slutsatsdragning?

Utvärdering

Fastställa hur den gen-AI-appen ska utvärderas och förbättras över tid.

• 🟢 [P0] KPI:er för företag: Vilket affärsmål eller KPI ska programmet påverka? Definiera dina baslinjevärden och mål.
• 🟢 [P0] Feedback från intressenter: Vem kommer att ge inledande och löpande feedback om programmets prestanda och utdata? Identifiera specifika användargrupper eller domänexperter.
• 🟢 [P0] Mäta kvalitet: Vilka mått (till exempel noggrannhet, relevans, säkerhet, mänskliga poäng) kommer att användas för att bedöma kvaliteten på genererade utdata?
  • Hur beräknas dessa mått under utvecklingen (till exempel mot syntetiska data, manuellt kurerade datamängder)?
  • Hur mäts kvalitet i produktion (till exempel loggning och analys av svar på verkliga användarfrågor)?
  • Vilken är den övergripande feltoleransen? (Acceptera till exempel en viss procentandel mindre faktiska felaktigheter eller kräva nästan 100% korrekthet för kritiska användningsfall.)
  • Syftet är att bygga mot en utvärderingsuppsättning från faktiska användarfrågor, syntetiska data eller en kombination av båda. Den här uppsättningen ger ett konsekvent sätt att utvärdera prestanda när systemet utvecklas.
• 🟡 [P1] Feedbackloopar: Hur ska användarfeedback samlas in (till exempel tummen upp/ner, undersökningsformulär) och användas för att driva iterativa förbättringar?
  • Planera hur ofta feedback ska granskas och införlivas.

Säkerhet

Identifiera eventuella säkerhets- och sekretessöverväganden.

• 🟢 [P0] Datakänslighet: Finns det känsliga eller konfidentiella dataelement som kräver särskild hantering?
• 🟡 [P1] Åtkomstkontroller: Behöver du implementera åtkomstkontroller för att begränsa vissa data eller funktioner?
• 🟡 [P1] Hotbedömning & åtgärd: Behöver ditt program skydda mot vanliga generativa AI-hot, till exempel instruktionsinjektion eller skadliga användarinmatningar?

Utplacering

Förstå hur gen AI-lösningen kommer att integreras, distribueras, övervakas och underhållas.

• 🟡 [P1]-integrering: Hur ska gen-AI-lösningen integreras med befintliga system och arbetsflöden?
  • Identifiera integreringspunkter (till exempel Slack, CRM, BI-verktyg) och nödvändiga dataanslutningar.
  • Bestäm hur begäranden och svar ska flöda mellan gen-AI-appen och underordnade system (till exempel REST-API:er, webhooks).
• 🟡 [P1] Distribution: Vilka är kraven för att distribuera, skala och versionshantera programmet? Den här artikeln beskriver hur livscykeln från slutpunkt till slutpunkt kan hanteras på Databricks med hjälp av MLflow, Unity Catalog, Agent Framework, Agent Evaluationoch Model Serving.
• 🟡 [P1] Produktionsövervakning & observerbarhet: Hur övervakar du programmet när det är i produktion?
  • Loggning av &-spår: Samla in fullständiga exekveringsspår.
  • Kvalitetsmått: Utvärdera kontinuerligt viktiga mått (till exempel korrekthet, svarstid, relevans) för livetrafik.
  • Aviseringar för & dashboards: Konfigurera aviseringar för kritiska problem.
  • Feedbackloop: Införliva användarfeedback i produktion (tummen upp eller ner) för att fånga upp problem tidigt och driva iterativa förbättringar.

Exempel

Tänk till exempel på hur dessa överväganden och krav gäller för ett hypotetiskt agentiskt RAG-program som används av ett Databricks-kundsupportteam:

Område	Överväganden	Krav
Användarupplevelse	Interaktionsmodalitet. Vanliga exempel på användarfrågor. Förväntat svarsformat och stil. Hantera tvetydiga eller irrelevanta frågor.	Chattgränssnitt integrerat med Slack. Exempelfrågor: "Hur minskar jag starttiden för kluster?" "Vilken typ av supportplan har jag?" Tydliga, tekniska svar med kodfragment och länkar till relevant dokumentation där det är lämpligt. Ge sammanhangsberoende förslag och eskalera till supporttekniker när det behövs.
Agentlogik	Frågetolkning och -klassificering. Planering och beslutsfattande i flera steg. Autonomt verktygsval och utförande. Tillstånds- och kontexthantering mellan interaktioner. Felhantering och återställningsmekanismer.	LLM-baserad planering med deterministiska reservåtgärder. Integrera med en uppsättning fördefinierade verktyg (till exempel verktyg för hämtning av dokument eller Salesforce-hämtningsverktyg). Underhåll konversationstillstånd för sammanhängande flerstegsinteraktioner och robust felhantering.
Data	Antal och typ av datakällor. Dataformat och plats. Datastorlek och uppdateringsfrekvens. Datakvalitet och konsekvens.	Fyra datakällor. Företagsdokumentation (HTML, PDF). Lösta supportärenden dokumenterade i JSON-format. Inlägg i gemenskapsforumet (Delta-tabell). Salesforce-koppling. Data som lagras i Unity Catalog och uppdateras varje vecka. Total datastorlek: 5 GB. Konsekvent datastruktur och kvalitet som underhålls av dedikerade dokument och supportteam.
Föreställning	Maximal acceptabel svarstid. Kostnadsbegränsningar. Förväntad användning och samtidighet.	Krav på maximal svarstid. Kostnadsbegränsningar. Förväntad högsta belastning.
Utvärdering	Tillgänglighet för utvärderingsdataset. Kvalitetsmått. Insamling av användarfeedback.	Ämnesexperter från varje produktområde hjälper till att granska utdata och justera felaktiga svar för att skapa utvärderingsdatauppsättningen. KPI:er för företag. Ökning av frekvensen för lösning av supportärenden. Minska användartid som spenderas per supportärende. Kvalitetsmått. LLM-bedömd svars korrekthet och relevans. LLM bedömer precision i informationshämtning. Användarinvändaruppröstning eller nedröstning. Feedbackinsamling. Slack kommer att instrumenteras för att ge tummen upp/ner.
Säkerhet	Hantering av känsliga data. Åtkomstkontrollkrav.	Inga känsliga kunddata ska finnas i hämtningskällan. Användarautentisering via Databricks Community SSO.
Utplacering	Integrering med befintliga system. Distribution och versionshantering.	Integrering med supportärendesystem. Agent distribuerad som en Databricks Model Serving-slutpunkt.

Lösningsdesign

Datakällor & verktyg

När du utformar en gen AI-app är det viktigt att identifiera och mappa ut de olika datakällor och verktyg som krävs för att driva din lösning. Det kan handla om strukturerade datauppsättningar, ostrukturerade databearbetningspipelines eller frågor mot externa API:er. Nedan visas de rekommenderade metoderna för att införliva olika datakällor eller verktyg i din gen AI-app:

Strukturerade data

Strukturerade data finns vanligtvis i väldefinierade tabellformat (till exempel en Delta-tabell eller CSV-fil) och är idealisk för uppgifter där frågor antingen är förutbestämda eller måste genereras dynamiskt baserat på användarindata. Se AI-agentverktyg för strukturerad hämtning för rekommendationer om hur du lägger till strukturerade data i din gen AI-app.

Ostrukturerade data

Ostrukturerade data innehåller rådata, PDF-filer, e-postmeddelanden, bilder och andra format som inte överensstämmer med ett fast schema. Sådana data kräver ytterligare bearbetning, vanligtvis genom en kombination av parsning, segmentering och inbäddning, för att effektivt efterfrågas och användas i en gen AI-app. Se AI-agentverktyg för ostrukturerad hämtning för rekommendationer om hur du lägger till strukturerade data i din gen AI-app.

Externa API:er & åtgärder

I vissa scenarier kan din gen AI-app behöva interagera med externa system för att hämta data eller utföra åtgärder. I fall där ditt program kräver att du anropar verktyg eller interagerar med externa API:er rekommenderar vi följande:

• Hantera API-autentiseringsuppgifter med en Anslutning till Unity-katalog: Använd en Anslutning till Unity-katalog för att på ett säkert sätt styra API-autentiseringsuppgifter. Den här metoden säkerställer att token och hemligheter hanteras centralt och åtkomstkontrolleras.
• Anropa via Databricks SDK:
  Skicka HTTP-begäranden till externa tjänster med hjälp av funktionen http_request från databricks-sdk-biblioteket. Den här funktionen utnyttjar en Unity Catalog-anslutning för autentisering och stöder HTTP-standardmetoder.
• dra nytta av Unity Catalogfunktioner:
  Omsluta externa anslutningar i en Unity Catalog-funktion för att lägga till anpassad logik före eller efter bearbetning.
• Python-körverktyget:
  Om du vill köra kod dynamiskt för datatransformering eller API-interaktioner med hjälp av Python-funktioner använder du det inbyggda Python-körverktyget.

Exempel:

Ett internt analysprogram hämtar livemarknadsdata från ett externt finansiellt API. Programmet använder:

• extern anslutning i Unity Catalog för att lagra API-autentiseringsuppgifter på ett säkert sätt.
• En anpassad Unity Catalog-funktion omsluter API-anropet för att lägga till förbearbetning (till exempel datanormalisering) och efterbearbetning (till exempel felhantering).
• Dessutom kan programmet direkt anropa API:et via Databricks SDK.

Implementeringsmetod

När du utvecklar en gen AI-app har du två huvudsakliga alternativ för att implementera agentens logik: använda ett ramverk med öppen källkod eller skapa en anpassad lösning med hjälp av Python-kod. Nedan visas en uppdelning av för- och nackdelarna för varje metod.

Använda ett ramverk (till exempel LangChain, LlamaIndex, CrewAI eller AutoGen)

Fördelar:

• Direktanvändbara komponenter: Frameworks levereras med färdiga verktyg för snabb hantering av, kedjeanrop och integrering med olika datakällor, vilket kan snabba upp utvecklingen.
• Community och dokumentation: Dra nytta av gemenskapsstöd, handledningar och regelbundna uppdateringar.
• Vanliga designmönster: Frameworks ger vanligtvis en tydlig, modulär struktur för orkestrering av vanliga uppgifter, vilket kan förenkla den övergripande agentdesignen.

Nackdelar:

• Lade till abstraktion: Ramverk med öppen källkod introducerar ofta abstraktionslager som kan vara onödiga för ditt specifika användningsfall.
• Beroende av uppdateringar: Du kanske är beroende av ramverksunderhållarna för felkorrigeringar och funktionsuppdateringar, vilket kan hindra dig från att snabbt anpassa dig till nya krav.
• Potentiella omkostnader: Extra abstraktion kan leda till anpassningsutmaningar om programmet behöver mer detaljerad kontroll.

Använda ren Python

Fördelar:

• Flexibilitet: med Utveckla i ren Python kan du skräddarsy implementeringen exakt efter dina behov utan att begränsas av ett ramverks designbeslut.
• Snabb anpassning: Du kan snabbt justera koden och införliva ändringar efter behov, utan att vänta på uppdateringar från ett externt ramverk.
• Enkelhet: Undvik onödiga abstraktionsnivåer, vilket potentiellt kan resultera i en smalare och mer högpresterande lösning.

Nackdelar:

• Ökade utvecklingsinsatser: Att bygga från grunden kan kräva mer tid och expertis för att implementera funktioner som ett dedikerat ramverk annars kan ge.
• Återuppfinna hjulet: Du kan behöva utveckla gemensamma funktioner (till exempel verktygslänkning eller snabbhantering) på egen hand.
• Underhållsansvar: Alla uppdateringar och felkorrigeringar blir ditt ansvar, vilket kan vara en utmaning för komplexa system.

I slutändan bör ditt beslut styras av projektets komplexitet, prestandabehov och den kontrollnivå som du behöver. Inget av tillvägagångssätten är i sig överlägset; varje erbjuder distinkta fördelar beroende på dina utvecklingspreferenser och strategiska prioriteringar.

1. Bygga

I det här skedet omvandlar du din lösningsdesign till ett fungerande ai-program. I stället för att försöka perfekta allt från början, börja smått med en minimal prototyp som kan testas snabbt. På så sätt kan du distribuera till en förproduktionsmiljö så snart som möjligt, samla in representativa frågor från faktiska användare eller små och medelstora företag och förfina baserat på verklig feedback.

Byggprocessen följer dessa viktiga steg:

a. Förbered data & verktyg: Verifiera att nödvändiga data är tillgängliga, bearbetade och klara för hämtning. Implementera eller registrera funktionerna och anslutningarna i Unity-katalogen (till exempel hämtning av API:er eller externa API-anrop) som din agent behöver. b. Byggagent: Orkestrera kärnlogiken med en enkel proof of concept-metod. c. Kvalitetskontroll: Verifiera viktiga funktioner innan du exponerar appen för fler användare. d. Distribuera förproduktionsagent: Gör POC tillgängligt för testanvändare och ämnesexperter för inledande feedback. e. Samla in feedback från användare: Använd verklig användning för att identifiera förbättringsområden, ytterligare data eller verktyg som behövs och potentiella förbättringar för nästa iteration.

a. Förbereda data & verktyg

Från lösningsdesignfasen får du en första uppfattning om de datakällor och verktyg som krävs för din app. I det här skedet bör du hålla det minimalt: fokusera på tillräckligt med data för att verifiera din POC. Detta möjliggör snabb iteration utan stora investeringar i komplexa pipelines.

Data

1. Identifiera en representativ delmängd av data
   • För strukturerade dataväljer du de nyckeltabeller eller kolumner som är mest relevanta för ditt första scenario.
   • För ostrukturerade dataprioriterar du endast indexering av en delmängd av representativa dokument. Använd en grundläggande pipeline för segmentering/inbäddning med Mosaic AI Vector Search så att agenten kan hämta relevanta textsegment om det behövs.
2. Konfigurera dataåtkomst
   • Om du behöver din app för att göra externa API-anrop lagrar du autentiseringsuppgifterna på ett säkert sätt med hjälp av en Unity Catalog-anslutning.
3. Verifiera grundläggande täckning
   • Bekräfta att de valda dataunderuppsättningarna hanterar de användarfrågor som du planerar att testa på ett tillfredsställande sätt.
   • Spara eventuella ytterligare datakällor eller komplexa transformeringar för framtida iterationer. Ditt nuvarande mål bör vara att bevisa grundläggande genomförbarhet och samla feedback.

Arbetsredskap

När dina datakällor har konfigurerats är nästa steg att implementera och registrera de verktyg som agenten anropar vid körning till Unity Catalog. Ett verktyg är en funktion för enkel interaktion, till exempel en SQL-fråga eller ett externt API-anrop, som agenten kan anropa för hämtning, transformering eller åtgärd.

Datahämtningsverktyg

• Begränsade, strukturerade datafrågor: Om frågor är fasta omsluter du dem i en sql-funktion i Unity Catalog eller en Python UDF-. Detta gör att logiken är centraliserad och kan identifieras.
• Öppna, strukturerade datafrågor: Om frågorna är mer öppna kan du överväga att konfigurera ett Genie-utrymme för att hantera text-till-SQL-frågor.
• Ostrukturerade datahjälpfunktioner: För ostrukturerade data som lagras i Mosaic AI Vector Search skapa ett ostrukturerat datahämtningsverktyg som agenten kan anropa för att hämta relevanta textsegment.

API-anropsverktyg

• externa API-anrop:API-anrop kan anropas direkt med hjälp av Databricks SDK:s http_request-metod.
• Valfria omslutningar: Om du behöver implementera logik före eller efter bearbetning (till exempel datanormalisering eller felhantering) omsluter du API-anropet i en Unity Catalog-funktion.

Håll den minimal

• Börja endast med viktiga verktyg: Fokusera på en enda sökväg för hämtning eller en begränsad uppsättning API-anrop. Du kan lägga till mer när du itererar.
• Verifiera interaktivt: Testa varje verktyg separat (till exempel i en notebook-fil) innan du införlivar det i agentsystemet.

När prototypverktygen är klara fortsätter du med att skapa agenten. Agenten samordnar dessa verktyg för att besvara frågor, hämta data och utföra åtgärder efter behov.

b. Skapa agent

När dina data och verktyg är på plats kan du skapa agenten som svarar på inkommande begäranden, till exempel användarfrågor. Om du vill skapa en första prototypagent använder du antingen Python eller AI Playground. Följ dessa steg:

1. Börja enkelt
   • Välj ett grundläggande designmönster: För en POC börjar du med antingen en grundläggande kedja (till exempel en fast sekvens med steg) eller en enda verktygsanropsagent (där LLM dynamiskt kan anropa ett eller två viktiga verktyg).
     • Om ditt scenario överensstämmer med ett av de exempelanteckningsböcker som finns i Databricks-dokumentationen kan du anpassa koden som ett skelett.
   • Minimal prompt: Motstå uppmaningen att överkompetera uppmaningar i det här läget. Håll instruktionerna kortfattade och direkt relevanta för dina inledande uppgifter.
2. Införliva verktyg
   • Tool-integrering: Om du använder ett mönster för kedjedesign blir stegen som anropar varje verktyg hårdkodade. I en agent för verktygsanrop anger du ett schema så att LLM:n vet hur funktionen anropas.
     • Kontrollera att verktygen fungerar som förväntat när de används separat innan de införlivas i agentsystemet och testas i sin helhet.
   • Skyddsräcken: Om din agent kan ändra externa system eller köra kod kontrollerar du att du har grundläggande säkerhetskontroller och skyddsräcken (till exempel att begränsa antalet anrop eller begränsa vissa åtgärder). Genomför dessa i den Unity Catalog-funktion.
3. Spåra och logga agenten med MLflow
   • Spåra varje steg: Använd MLflow-spårning för att samla in indata, utdata och förfluten tid per steg för att felsöka problem och mäta prestanda.
   • Logga agenten: Använd MLflow Tracking för att logga agentens kod och konfiguration.

I detta skede är perfektion inte målet. Du vill ha en enkel, fungerande agent som du kan distribuera för tidig feedback från testanvändare och små och medelstora företag. Nästa steg är att köra en snabb kvalitetskontroll innan du gör den tillgänglig i en förproduktionsmiljö.

c. Kvalitetskontroll

Innan du exponerar agenten för en bredare förproduktionspublik kör du en "tillräckligt bra" offlinekvalitetskontroll för att fånga upp eventuella större problem innan du distribuerar den till en slutpunkt. I det här skedet har du vanligtvis inte en stor, robust utvärderingsdatauppsättning, men du kan fortfarande göra ett snabbt pass för att säkerställa att agenten fungerar som den är avsedd för en handfull exempelfrågor.

1. Testa interaktivt i en notebook -
   • Manuell testning: Anropa din agent manuellt med representativa förfrågningar. Var uppmärksam på om den hämtar rätt data, anropar verktygen korrekt och följer önskat format.
   • Granska MLflow-spårningar: Om du har aktiverat MLflow-spårning, granskar du steg-för-steg-telemetrin. Bekräfta att agenten väljer lämpliga verktyg, hanterar fel korrekt och genererar inte oväntade mellanliggande begäranden eller resultat.
   • Kontrollera svarstiden: Observera hur lång tid varje begäran tar att köra. Om svarstiderna eller tokenanvändningen är för höga kan du behöva beskära steg eller förenkla logiken innan du går vidare.
2. Vibe-kontroll
   • Detta kan göras antingen i en notebook eller i AI Playground.
   • Enhetlig & korrekthet: Är agentens utdata meningsfulla för de frågor som du testade? Finns det uppenbara felaktigheter eller information som saknas?
   • Gränsfall: Om du provade några ovanliga frågor, svarade agenten fortfarande logiskt eller åtminstone misslyckades graciöst (till exempel att artigt avböja att svara snarare än att ge meningslösa svar)?
   • Överensstämmelse med riktlinjer: Om du har angett instruktioner på hög nivå, till exempel önskad ton eller formatering, följer agenten dem?
3. Utvärdera "tillräckligt bra" kvalitet
   • Om du är begränsad till testfrågor i det här läget kan du överväga att generera syntetiska data. Se Skapa en utvärderingsuppsättning.
   • Åtgärda stora problem: Om du upptäcker stora brister (till exempel att agenten upprepade gånger kallar ogiltiga verktyg eller utdata nonsens) kan du åtgärda dessa problem innan du exponerar dem för en bredare målgrupp. Se Vanliga kvalitetsproblem och hur du åtgärdar dem.
   • Bestäm om genomförbarhet: Om agenten uppfyller en grundläggande tröskel för användbarhet och korrekthet för en liten uppsättning frågeställningar kan du gå vidare. Om inte, förfina prompterna, åtgärda problem med verktyg eller data och testa igen.
4. Planera nästa steg
   • Spåra förbättringar: Dokumentera eventuella brister som du bestämmer dig för att skjuta upp. När du har samlat in verklig feedback i förproduktion kan du gå tillbaka till dessa.

Om allt ser bra ut för en begränsad lansering är du redo att distribuera agenten till testmiljö. En grundlig utvärderingsprocess sker i senare faser, särskilt efter att du har mer verkliga data, feedback från små och medelstora företag och en strukturerad utvärderingsuppsättning. För tillfället kan du fokusera på att se till att din agent på ett tillförlitligt sätt visar dess kärnfunktioner.

d. Implementera förproduktionsagent

När din agent uppfyller ett tröskelvärde för baslinjekvalitet är nästa steg att vara värd för den i en förproduktionsmiljö så att du kan förstå hur användare frågar efter appen och samlar in feedback för att vägleda utvecklingen. Den här miljön kan vara din utvecklingsmiljö under POC-fasen. Det viktigaste kravet är att miljön är tillgänglig för att välja interna testare eller domänexperter.

1. Distribuera agenten
   • Logga och registrera agent: Först loggar agenten som en MLflow-modell och registrera den i Unity Catalog.
   • Distribuera med Agent Framework: Använda Agent Framework för att ta den registrerade agenten och distribuera den som en modellserverslutpunkt.
2. inferenstabeller
   • Agent Framework lagrar automatiskt begäranden, svar och spårningar tillsammans med metadata i en slutsatsdragningstabell i Unity Catalog för varje serverslutpunkt.
3. Skydda och konfigurera
   • Åtkomstkontroll:Begränsa slutpunktsåtkomst till din testgrupp (små och medelstora företag, power-användare). Detta säkerställer kontrollerad användning och undviker oväntad dataexponering.
   • Authentication: Bekräfta att alla nödvändiga hemligheter, API-token eller databasanslutningar är korrekt konfigurerade.

Nu har du en kontrollerad miljö för att samla in feedback om verkliga frågor. Ett sätt att snabbt interagera med agenten är i AI Playground, där du kan välja den nyligen skapade modellserverslutpunkten och fråga agenten.

e. Samla in feedback från användare

När du har distribuerat din agent till en förproduktionsmiljö är nästa steg att samla in feedback från verkliga användare och små och medelstora företag för att upptäcka luckor, upptäcka felaktigheter och förfina din agent ytterligare.

1. Använd granskningsappen

   • När du distribuerar din agent med Agent Framework skapas en enkel Granska app. Det ger ett användarvänligt gränssnitt där testare kan ställa frågor och omedelbart betygsätta agentens svar.
   • Alla begäranden, svar och användarfeedback (tummen upp/ned, skriftliga kommentarer) loggas automatiskt till en slutsatsdragningstabell, vilket gör det enkelt att analysera senare.

2. Använd användargränssnittet för övervakning för att inspektera loggar

   • Spåra röster uppåt/nedåt eller skriftlig feedback i Monitoring UI för att se vilka svar som testarna fann särskilt användbara (eller ohjälpsamma).

3. Engagera domänexperter

   • Uppmuntra små och medelstora företag att gå igenom typiska och ovanliga scenarier. Domänkunskap hjälper till att visa subtila fel, till exempel feltolkningar av principer eller saknade data.
   • Behåll en lista över problem, från snabba justeringar till generella omstruktureringar av datapipelines. Bestäm vilka korrigeringar som ska prioriteras innan du går vidare.

4. Kurera nya utvärderingsdata

   • Konvertera anmärkningsvärda eller problematiska interaktioner till testfall. Med tiden utgör dessa grunden för en mer robust utvärderingsdatauppsättning.
   • Lägg eventuellt till korrekta eller förväntade svar för dessa fall. Detta hjälper till att mäta kvalitet i efterföljande utvärderingscykler.

5. Iterera baserat på feedback

   • Använd snabbkorrigeringar som små snabba ändringar eller nya skyddsräcken för att åtgärda omedelbara smärtpunkter.
   • För mer komplexa problem, till exempel att kräva avancerad logik i flera steg eller nya datakällor, samlar du in tillräckligt med bevis innan du investerar i större arkitekturändringar.

Genom att dra nytta av feedback från granskningsappen, slutsatsdragningstabellloggar och insikter för små och medelstora företag hjälper den här förproduktionsfasen till att lösa viktiga luckor och förfina din agent iterativt. De verkliga interaktioner som samlas in i det här steget skapar grunden för att skapa en strukturerad utvärderingsuppsättning, så att du kan övergå från ad hoc-förbättringar till ett mer systematiskt tillvägagångssätt för kvalitetsmätning. När återkommande problem har åtgärdats och prestandan stabiliserats är du väl förberedd för en produktionsdistribution med robust utvärdering på plats.

2. Utvärdera & iterera

När din gen AI-app har testats i en förproduktionsmiljö är nästa steg att systematiskt mäta, diagnostisera och förfina dess kvalitet. Den här "utvärdera och iterera"-fasen omvandlar rå feedback och loggar till en strukturerad utvärderingsuppsättning, så att du upprepade gånger kan testa förbättringar och se till att din app uppfyller de standarder som krävs för noggrannhet, relevans och säkerhet.

Den här fasen innehåller följande steg:

• Samla in verkliga frågor från loggar: Konvertera värdefulla eller problematiska interaktioner från dina slutsatsdragningstabeller till testfall.
• Lägg till expertetiketter: Om möjligt bifogar du grundsanningar eller stil- och principriktlinjer i dessa fall så att du kan mäta korrekthet, grundinställning och andra kvalitetsdimensioner mer objektivt.
• Utnyttja agentutvärdering: Använd inbyggda LLM-domare eller anpassade kontroller för att kvantifiera appkvaliteten.
• Iterera: Förbättra kvaliteten genom att förfina agentens logik, datapipelines eller uppmaningar. Kör utvärderingen igen för att bekräfta om du har löst viktiga problem.

Observera att dessa funktioner fungerar även om din gen AI-app körs utanför Databricks. Genom att instrumentera koden med MLflow Tracing kan du samla in spårningar från valfri miljö och förena dem i Databricks Data Intelligence Platform för konsekvent utvärdering och övervakning. När du fortsätter att införliva nya frågor, feedback och SME-insikter blir din utvärderingsdatauppsättning en levande resurs som ligger till grund för en kontinuerlig förbättringscykel, vilket säkerställer att din gen AI-app förblir robust, tillförlitlig och i linje med affärsmålen.

a. Utvärdera agent

När agenten körs i en förproduktionsmiljö är nästa steg att systematiskt mäta dess prestanda utöver ad hoc-vibe-kontroller. Mosaic AI Agent Evaluation kan du skapa utvärderingsuppsättningar, köra kvalitetskontroller med inbyggda eller anpassade LLM-domare och iterera snabbt på problemområden.

Evalueringar offline och online

När du utvärderar gen-AI-program finns det två huvudsakliga metoder: offlineutvärdering och onlineutvärdering. Den här fasen av utvecklingscykeln fokuserar på offlineutvärdering, som avser systematisk utvärdering utanför liveanvändarinteraktioner. Onlineutvärdering behandlas senare när man diskuterar hur man övervakar din agent i produktion.

Team förlitar sig ofta för mycket på informella tester av känsla under för lång tid i utvecklarens arbetsflöde, och provar ett fåtal frågor samt bedömer subjektivt om svaren verkar rimliga. Detta är en utgångspunkt, men den saknar den noggrannhet och täckning som krävs för att skapa program av produktionskvalitet.

En korrekt utvärderingsprocess offline gör däremot följande:

• Upprättar en kvalitetsbaslinje före en bredare distribution, vilket skapar tydliga mått som mål för förbättringar.
• Identifierar specifika svagheter som kräver uppmärksamhet och som går utöver begränsningen av testning endast förväntade användningsfall.
• Identifierar kvalitetsregressioner när du förfinar din app genom att automatiskt jämföra prestanda mellan versioner.
• Tillhandahåller kvantitativa mått för att demonstrera förbättringar för intressenter.
• Hjälper till att identifiera gränsfall och potentiella fellägen innan användarna gör det.
• Minskar risken att distribuera en underpresterande agent till produktionsmiljö.

Att investera tid i offlineutvärdering ger betydande utdelningar på lång sikt, vilket hjälper dig att uppnå konsekvent högkvalitativa svar.

Skapa en utvärderingsuppsättning

En utvärderingsuppsättning fungerar som grund för att mäta prestanda för din gen AI-app. På samma sätt som i en testsvit inom traditionell programvaruutveckling blir den här samlingen av representativa frågor och förväntade svar din datauppsättning för kvalitetstestning och regressionstestning.

Du kan skapa en utvärderingsuppsättning med flera kompletterande metoder:

1. Omvandla inferenstabellloggar till utvärderingsexempel

   De mest värdefulla utvärderingsdata kommer direkt från verklig användning. Förproduktionsutplaceringen har genererat inferenstabellloggar som innehåller förfrågningar, agentsvar, verktygsanrop och hämtad kontextinformation.

   Att konvertera dessa loggar till en utvärderingsuppsättning ger flera fördelar:

   • Verklig täckning: oförutsägbara användarbeteenden som du kanske inte hade väntat dig ingår.
   • Problemfokuserat: Du kan filtrera specifikt efter negativ feedback eller långsamma svar.
   • Representativ distribution: Den faktiska frekvensen för olika frågetyper samlas in.

2. Generera syntetiska utvärderingsdata

   Om du inte har en kuraterad uppsättning användarfrågor kan du generera en syntetisk utvärderingsdatauppsättning automatiskt. Den här "startuppsättningen" med frågor hjälper dig att snabbt utvärdera om agenten:

   • Returnerar sammanhängande, korrekta svar.
   • Svarar i rätt format.
   • Respekterar riktlinjer för struktur, tonalitet och principer.
   • Hämtar korrekt kontext (för RAG).

   Syntetiska data är vanligtvis inte perfekta. Se det som en tillfällig språngbräda. Du vill också:

   • Låt små och medelstora företag eller domänexperter granska och rensa eventuella irrelevanta eller repetitiva frågor.
   • Ersätt eller utöka det senare med verkliga användningsloggar.

3. manuellt hantera sökfrågor

   Om du föredrar att inte förlita dig på syntetiska data eller inte har slutsatsdragningsloggar ännu kan du identifiera 10 till 15 verkliga eller representativa frågor och skapa en utvärderingsuppsättning från dessa. Representativa frågor kan komma från användarintervjuer eller brainstorming för utvecklare. Även en kort, kurerad lista kan avslöja uppenbara brister i agentens svar.

Dessa metoder är inte ömsesidigt uteslutande utan kompletterar varandra. En effektiv utvärderingsuppsättning utvecklas över tid och kombinerar vanligtvis exempel från flera källor, inklusive följande:

• Börja med manuellt utvalda exempel för att testa kärnfunktioner.
• Du kan också lägga till syntetiska data för att bredda täckningen innan du har riktiga användardata.
• Införliva gradvis verkliga loggar när de blir tillgängliga.
• Uppdatera kontinuerligt med nya exempel som återspeglar förändrade användningsmönster.

Metodtips för utvärderingsfrågor

När du skapar din utvärderingsuppsättning ska du avsiktligt inkludera olika frågetyper, till exempel följande:

• Både förväntade och oväntade användningsmönster (till exempel mycket långa eller korta begäranden).
• Potentiella missbruksförsök eller snabba inmatningsattacker (till exempel försök att avslöja systemprompten).
• Komplexa frågor som kräver flera resonemangssteg eller verktygsanrop.
• Edge-fall med minimal eller tvetydig information (till exempel felstavningar eller vaga frågor).
• Exempel som representerar olika användarkunskapsnivåer och bakgrunder.
• Frågor som testar potentiella fördomar i svar (till exempel "jämför företag A jämfört med företag B").

Kom ihåg att utvärderingsuppsättningen bör växa och utvecklas tillsammans med ditt program. När du upptäcker nya fellägen eller användarbeteenden lägger du till representativa exempel för att säkerställa att agenten fortsätter att förbättras inom dessa områden.

Lägg till utvärderingsvillkor

Varje utvärderingsexempel bör ha kriterier för att bedöma kvalitet. Dessa kriterier fungerar som de standarder som agentens svar mäts mot, vilket möjliggör objektiv utvärdering över flera kvalitetsdimensioner.

Grundfakta eller referenssvar

När du utvärderar faktisk noggrannhet finns det två huvudsakliga metoder: förväntade fakta eller referenssvar. Var och en har olika syften i din utvärderingsstrategi.

Använd förväntade fakta (rekommenderas)

Den expected_facts metoden omfattar en lista över de viktigaste fakta som bör visas i ett korrekt svar. Ett exempel finns i Exempelutvärderingsuppsättning med request, response, guidelinesoch expected_facts.

Den här metoden erbjuder betydande fördelar:

• Ger flexibilitet i hur fakta uttrycks i svaret.
• Gör det lättare för små och medelstora företag att tillhandahålla grundsanning.
• Rymmer olika svarsstilar och säkerställer att kärninformation bevaras.
• Möjliggör mer tillförlitlig utvärdering mellan modellversioner eller parameterinställningar.

Den inbyggda korrekthetsdomaren kontrollerar om agentens svar innehåller dessa viktiga fakta, oavsett frasering, ordning eller ytterligare innehåll.

Använd förväntat svar (alternativ)

Alternativt kan du ge ett fullständigt referenssvar. Den här metoden fungerar bäst i följande situationer:

• Du har guldstandardsvar som skapats av experter.
• Den exakta formuleringen eller strukturen för svaret är viktig.
• Du utvärderar svar i strikt reglerade kontexter.

Databricks rekommenderar vanligtvis att du använder expected_facts över expected_response eftersom det ger mer flexibilitet samtidigt som noggrannheten säkerställs.

Riktlinjer för stil, ton eller principefterlevnad

Utöver faktisk noggrannhet kan du behöva utvärdera om svaren följer specifika krav på stil, ton eller princip.

endast riktlinjer

Om ditt främsta problem är att framtvinga stil- eller principkrav i stället för faktisk noggrannhet kan du tillhandahålla riktlinjer utan förväntade fakta:

# 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)."]
        }
    }
}

LLM-domaren tolkar dessa instruktioner i naturligt språk och bedömer om svaret uppfyller dem. Detta fungerar särskilt bra för subjektiva kvalitetsdimensioner som ton, formatering och efterlevnad av organisationsprinciper.

Kombinera grundsanning och riktlinjer

För omfattande utvärdering kan du kombinera kontroller med faktisk noggrannhet med stilriktlinjer. Se Exempel på utvärderingsuppsättning med request, response, guidelinesoch expected_facts. Den här metoden säkerställer att svaren både är faktamässigt korrekta och följer organisationens kommunikationsstandarder.

Använda förinsamlade svar

Om du redan har samlat in par med begärandesvar från utveckling eller testning kan du utvärdera dem direkt utan att återaktivera agenten. Detta är användbart för:

• Analysera befintliga mönster i agentens beteende.
• Prestandamätning mot tidigare versioner.
• Spara tid och kostnader genom att inte återskapa svar.
• Utvärdera en agent som hanteras utanför Databricks.

Mer information om hur du anger relevanta kolumner i din utvärderingsdataram finns i Exempel: Så här skickar du tidigare genererade utdata till Agentutvärdering. Mosaic AI Agent Evaluation använder dessa förinsamlade värden i stället för att anropa din agent igen, samtidigt som samma kvalitetskontroller och mått tillämpas.

Metodtips för utvärderingskriterier

När du definierar utvärderingskriterierna:

1. Var specifik och objektiv: Definiera tydliga, mätbara kriterier som olika utvärderare skulle tolka på liknande sätt.
   • Överväg att lägga till anpassade mått för att mäta de kvalitetskriterier som du bryr dig om.
2. Fokusera på användarvärde: Prioritera kriterier som överensstämmer med det som är viktigast för användarna.
3. Börja enkelt: Börja med en grundläggande uppsättning kriterier och expandera när din förståelse för kvalitetsbehov växer.
4. Saldotäckning: Inkludera kriterier som behandlar olika kvalitetsaspekter (till exempel faktisk noggrannhet, stil och säkerhet).
5. Iterera baserat på feedback: Förfina dina kriterier baserat på användarfeedback och föränderliga krav.

Mer information om hur du skapar högkvalitativa utvärderingsdatauppsättningar finns i Metodtips för att utveckla en utvärderingsuppsättning.

Köra utvärderingar

Nu när du har förberett en utvärderingsuppsättning med frågor och kriterier kan du köra en utvärdering med hjälp av mlflow.evaluate(). Den här funktionen hanterar hela utvärderingsprocessen, från att anropa din agent till att analysera resultaten.

Arbetsflöde för grundläggande utvärdering

För att köra en grundläggande utvärdering krävs bara några rader kod. Mer information finns i Kör en utvärdering.

När utvärderingen utlöses:

1. För varje rad i utvärderingsuppsättningen gör mlflow.evaluate() följande:
   • Anropar din agent med frågan (om du inte redan har angett ett svar).
   • Tillämpar inbyggda LLM-domare för att bedöma kvalitetsdimensioner.
   • Beräknar driftsmått som tokenanvändning och svarstid.
   • Innehåller detaljerade motiveringar för varje utvärdering.
2. Resultaten loggas automatiskt till MLflow och skapar:
   • Kvalitetsutvärderingar per rad.
   • Aggregerade mått i alla exempel.
   • Detaljerade loggar för felsökning och analys.

Anpassa utvärdering

Du kan skräddarsy utvärderingen efter dina specifika behov med hjälp av ytterligare parametrar. Med parametern evaluator_config kan du göra följande:

• Välj vilka inbyggda värderingsalgoritmer som ska köras.
• Ange globala riktlinjer som gäller för alla exempel.
• Konfigurera tröskelvärden för domare.
• Ge exempel på några bilder för att vägleda domarbedömningar.

Mer information och exempel finns i Exempel.

Utvärdera agenter utanför Databricks

En kraftfull funktion i Agent Evaluation är dess möjlighet att utvärdera generativa AI-appar som distribueras var som helst, inte bara på Databricks.

Vilka domare som tillämpas

Som standardinställning väljer agentutvärdering automatiskt lämpliga LLM-domare baserat på tillgängliga data i utvärderingsdatamängden. Mer information om hur kvalitet bedöms finns i Hur kvaliteten bedöms av LLM-domare.

Analysera utvärderingsresultat

När du har kört en utvärdering tillhandahåller MLflow-användargränssnittet visualiseringar och insikter för att förstå appens prestanda. Den här analysen hjälper dig att identifiera mönster, diagnostisera problem och prioritera förbättringar.

Navigera i utvärderingsresultat

När du öppnar användargränssnittet för MLflow när du har kört mlflow.evaluate(), hittar du flera sammankopplade vyer. Information om hur du navigerar i dessa resultat i användargränssnittet för MLflow finns i Granska utdata med hjälp av MLflow-användargränssnittet.

Vägledning om hur du tolkar felmönster finns i b. Förbättra agenten och verktygen.

Anpassade AI-domare & bedömning

Inbyggda domare täcker många vanliga kontroller (till exempel korrekthet, stil, princip och säkerhet), men du kan behöva utvärdera domänspecifika aspekter av appens prestanda. Med anpassade domare och mått kan du utöka utvärderingsfunktionerna för att uppfylla dina unika kvalitetskrav.

anpassade LLM-domare

Mer information om hur du skapar en anpassad LLM-domare från en fråga finns i Skapa AI-domare från en fråga.

Anpassade domare utmärker sig för att utvärdera subjektiva eller nyanserade kvalitetsdimensioner som drar nytta av mänskligt omdöme, till exempel:

• Domänspecifik efterlevnad (juridisk, medicinsk, ekonomisk).
• Varumärkesröst och kommunikationsstil.
• Kulturell känslighet och lämplighet.
• Komplex resonemangskvalitet.
• Specialiserade skrivkonventioner.

Domarens utdata visas i MLflow-användargränssnittet tillsammans med inbyggda domare, med samma detaljerade motiveringar som förklarar utvärderingar.

Anpassade mått

För mer programmatiska, deterministiska utvärderingar kan du skapa anpassade mått med hjälp av @metric dekoratör. Se @metric dekoratör.

Anpassade mått är idealiska för:

• Verifiera tekniska krav, till exempel formatverifiering och schemaefterlevnad.
• Söker efter förekomst eller frånvaro av specifikt innehåll.
• Utföra kvantitativa mått, till exempel svarslängd eller komplexitetspoäng.
• Implementera affärsspecifika valideringsregler.
• Integrera med externa valideringssystem.

b. Förbättra agenten och verktygen

När du har kört utvärdering och identifierat kvalitetsproblem är nästa steg att systematiskt åtgärda dessa problem för att förbättra prestandan. Utvärderingsresultaten ger värdefulla insikter om var och hur din agent misslyckas, så att du kan göra riktade förbättringar i stället för slumpmässiga justeringar.

Vanliga kvalitetsproblem och hur du åtgärdar dem

LLM-domarnas utvärderingar från dina utvärderingsresultat pekar på specifika typer av fel i ditt agentsystem. I det här avsnittet går vi igenom de här vanliga felmönstren och deras lösningar. För information om hur du tolkar LLM-bedömningsutdata, se AI-bedömningsutdata.

Bästa praxis för kvalitetsiteration

När du itererar förbättringar bör du underhålla rigorös dokumentation. Till exempel:

1. Version dina ändringar
   • Logga varje betydande iteration med hjälp av MLflow Tracking.
   • Spara prompter, konfigurationer och nyckelparametrar i en central konfigurationsfil. Säkerställ att detta loggas med agenten.
   • För varje ny distribuerad agent upprätthåller du en ändringslogg på lagringsplatsen med information om vad som har ändrats och varför.
2. Dokumentera både vad som fungerade och inte fungerade
   • Dokumentera både lyckade och misslyckade metoder.
   • Observera den specifika effekten av varje ändring på mått. Länka tillbaka till MLflow-körningen för agentutvärdering.
3. Anpassa efter intressenter
   • Använd granskningsappen för att verifiera förbättringar med små och medelstora företag.
     • Kommunicera ändringar till granskare med hjälp av granskarinstruktioner.
   • Om du vill jämföra olika versioner av en agent sida vid sida bör du överväga att skapa flera agentslutpunkter och använda modellen i AI Playground-. På så sätt kan användarna skicka samma begäran till separata slutpunkter och undersöka svaret och spårningarna sida vid sida.

3. Produktion

När du har utvärderat och förbättrat appen iterativt har du nått en kvalitetsnivå som uppfyller dina krav och är redo för bredare användning. Produktionsfasen omfattar distribution av din raffinerade agent till produktionsmiljön och implementering av kontinuerlig övervakning för att upprätthålla kvalitet över tid.

Produktionsfasen omfattar:

• Distribuera agent till produktion: Konfigurera en produktionsklar slutpunkt med lämpliga inställningar för säkerhet, skalning och autentisering.
• Övervaka agenten i produktion: Etablera kontinuerlig kvalitetsutvärdering, prestandaspårning och aviseringar för att säkerställa att din agent upprätthåller hög kvalitet och tillförlitlighet i verklig drift.

Detta skapar en kontinuerlig feedbackloop där övervakning av insikter ger ytterligare förbättringar, som du kan testa, distribuera och fortsätta att övervaka. Den här metoden säkerställer att din app förblir av hög kvalitet, kompatibel och anpassad till föränderliga affärsbehov under hela livscykeln.

a. Distribuera agenten till produktionsmiljö

När du har slutfört en grundlig utvärdering och iterativ förbättring är du redo att distribuera din agent till en produktionsmiljö. [Mosaic AI Agent Framework](/generative-ai/agent-framework/build-gen AI-apps.md#agent-framework) förenklar den här processen genom att hantera många distributionsproblem automatiskt.

Utrullningsprocess

Distributionen av din agent till produktion omfattar följande steg:

1. logga och registrera din agent som en MLflow-modell i Unity Catalog.
2. Distribuera agenten med Agent Framework.
3. Konfigurera autentisering för alla beroende resurser din agent behöver åtkomst till.
4. Testa distributionen för att verifiera funktionaliteten i produktionsmiljön.
   • När modellserverns slutpunkt är klar kan du interagera med agenten i AI Playground, där du kan testa och verifiera funktioner.

Detaljerade implementeringssteg finns i Distribuera en agent för generativ AI-program.

Överväganden för produktionsdistribution

Tänk på följande när du går över till produktion:

Prestanda och skalning

• Balansera kostnader jämfört med prestanda baserat på dina förväntade användningsmönster.
• Överväg att aktivera skalning ned till noll med - för agenter som används intermittent för att minska kostnaderna.
• Förstå svarstidskrav baserat på programmets användarupplevelsebehov.

Säkerhet och styrning

• Se till att alla agentkomponenter har rätt åtkomstkontroller på Unity-katalognivå.
• Använd inbyggda autentisering passthrough för Databricks-resurser där det är möjligt.
• Konfigurera lämplig hantering av autentiseringsuppgifter för externa API:er eller datakällor.

integreringsmetod

• Avgör hur ditt program ska interagera med agenten (till exempel med hjälp av ett API eller ett inbäddat gränssnitt).
• Överväg hur du hanterar och visar agentsvar i din applikation.
  • Om klientprogrammet behöver ytterligare kontext (till exempel källdokumentreferenser eller konfidenspoäng) utformar du agenten så att den inkluderar dessa metadata i sina svar (till exempel genom att använda anpassade utdata).
• Planera för felhantering och återställningsmekanismer för när agenten inte är tillgänglig.

Feedbacksamling

• Använd granskningsappen för feedback från intressenter under den första distributionen.
• Utforma mekanismer för att samla in användarfeedback direkt i programgränssnittet.
  • Den feedbackslutpunkt som skapats för att samla in feedback från granskningsappen kan också användas av externa program för att ge feedback om din agent. Se Ge feedback om en distribuerad agent.
• Se till att feedbackdata flödar in i utvärderings- och förbättringsprocessen.

b. Övervaka agenten i produktion

När agenten har distribuerats till produktion är det viktigt att kontinuerligt övervaka dess prestanda, kvalitet och användningsmönster. Till skillnad från traditionell programvara där funktioner är deterministiska kan gen-AI-appar uppvisa kvalitetsavvikelser eller oväntade beteenden när de stöter på verkliga indata. Med effektiv övervakning kan du identifiera problem tidigt, förstå användningsmönster och kontinuerligt förbättra programmets kvalitet.

Konfigurera agentövervakning

Mosaic AI tillhandahåller inbyggda övervakningsfunktioner som gör att du kan spåra agentens prestanda utan att skapa anpassad övervakningsinfrastruktur:

1. Skapa en övervakare för din distribuerade agent.
2. Konfigurera samplingshastighet och frekvens baserat på trafikvolym- och övervakningsbehov.
3. Välj kvalitetsmått för att automatiskt utvärdera på exempelbegäranden.

Viktiga övervakningsdimensioner

I allmänhet bör effektiv övervakning omfatta tre kritiska dimensioner:

1. Driftmått

   • Begär volym och mönster.
   • Svarsfördröjning.
   • Felfrekvenser och typer.
   • Tokenanvändning och kostnader.

2. Kvalitetsmått

   • Relevans för användarfrågor.
   • Förankring i hämtad kontext.
   • Säkerhet och riktlinjeefterlevnad.
   • Övergripande kvalitetspassfrekvens.

3. Användarfeedback

   • Explicit feedback (tummen upp/ner).
   • Implicita signaler (uppföljningsfrågor, övergivna konversationer).
   • Problem som rapporteras till stödkanaler.

Använda övervakningsgränssnittet

Övervakningsgränssnittet ger visualiserade insikter i dessa dimensioner via två flikar.

• fliken Diagram: Visa trender i begärandevolym, kvalitetsmått, svarstid och fel över tid.
• Loggar-fliken: Granska enskilda begäranden och svar, inklusive deras utvärderingsresultat.

Med filtreringsfunktioner kan användare söka efter specifika frågor eller filtrera efter utvärderingsresultat. Mer information finns i Använda övervakningsgränssnittet.

Skapa instrumentpaneler och aviseringar

För omfattande övervakning:

• Skapa anpassade instrumentpaneler med hjälp av övervakningsdata som lagras i tabellen för utvärdering av spår.
• Konfigurera aviseringar för tröskelvärden för kritisk kvalitet eller drift.
• Schemalägga regelbundna kvalitetsgranskningar med viktiga intressenter.

Kontinuerlig förbättringscykel

Övervakning är mest värdefull när den matas tillbaka till din förbättringsprocess:

1. Identifiera problem med hjälp av övervakningsmått och användarfeedback.
2. Exportera problematiska exempel till din utvärderingsuppsättning.
3. Diagnostisera grundorsaker med MLflow-spårningsanalys och LLM-bedömningsresultat (som beskrivs i Vanliga kvalitetsproblem och deras lösningar).
4. Utveckla och testa förbättringar mot din utökade utvärderingsuppsättning.
5. Distribuera uppdateringar och övervaka effekten.

Detta iterativ, sluten loop-metod hjälper till att säkerställa att din agent fortsätter att förbättras baserat på verkliga användningsmönster, upprätthålla hög kvalitet samtidigt som den anpassas till förändrade krav och användarbeteenden. Med Agentövervakning får du insyn i hur din agent presterar i produktion, så att du proaktivt kan hantera problem och optimera kvalitet och prestanda.