11. Dez 2023
Lesedauer 8 Min.
Fehleranalyse mit KI
ExceptionAInalyzer
Wie GPT-Modelle Softwareentwicklern bei der Fehlerdiagnose helfen können.
Fehlerbehebung und Problemdiagnose sind in der modernen Softwareentwicklung entscheidend, um die Qualität und Leistung von Anwendungen zu sichern. Könnte eine KI hierbei nicht unterstützen, gerade wenn OpenAI leistungsstarke GPT-Modelle über ihr API anbietet? Diesen Ansatz verfolgt der ExceptionAInalyzer, der OpenAIs KI zur Analyse von Exceptions einsetzt. Der ExceptionAInalyzer erweitert die Exception-Objekte, indem er relevante Fehlerinformationen an das API von OpenAI sendet. Dadurch werden detaillierte Analysen, Benutzermeldungen und Lösungsvorschläge generiert.Durch das Einbinden der KI-Schnittstelle und mithilfe von gezieltem Prompt Engineering (siehe Kasten KI-Begriffe) können Entwickler deserialisierbare Textantworten vom API erhalten, welche die Fehlerdiagnose und -behebung optimieren.
KI-Begriffe
<ul><li>GPT (Generative Pre-trained Transformer) ist ein Sprachmodell, das auf der Transformer-Architektur basiert und darauf trainiert wurde, Textmuster zu erkennen und menschenähnliche Textantworten zu generieren. Es wird in verschiedenen Anwendungen wie Textgenerierung, Übersetzung und Frage-Antwort-Systemen eingesetzt.</li><li>Prompt Engineering bezeichnet die Kunst und Wissenschaft, Anfragen oder Aufforderungen (sogenannte „Prompts“) so zu gestalten, dass maschinelle Lernmodelle, insbesondere Sprachmodelle, gewünschte und genaue Antworten oder Ergebnisse liefern. Es ist ein wichtiger Aspekt beim Arbeiten mit Modellen wie GPT-4, um optimale Ergebnisse zu erzielen.</li><li>Emergenz beschreibt das Auftreten neuer Eigenschaften oder Verhaltensweisen in einem System, die nicht direkt aus den Einzelteilen des Systems vorhersehbar sind. </li><li>Kontext bezeichnet die vollständige Eingabe, inklusive vorangegangenen Informationen, die das Modell nutzt, um die aktuelle Anfrage zu interpretieren und darauf zu antworten.</li></ul>
In diesem Beitrag werden die Implementierung des ExceptionAInalyzers und der Einsatz von Ländercodes zur Sprachanpassung detailliert erläutert. Gegenwärtig gibt es noch Einschränkungen bezüglich Verbindungs- und Antwortzeiten, die bei der Anwendung berücksichtigt werden müssen. Der Hauptfokus liegt jedoch darauf, den Softwareentwicklungsprozess durch das sinnvolle Einbinden von künstlicher Intelligenz zu verbessern und die Fehlerbehebung für alle Beteiligten zu erleichtern.Das GPT-Modell von OpenAI antwortet in der Regel in normalen, für eine maschinelle Auswertung eher ungeeigneten Sätzen. Dennoch hat GPT seit Version 3 mit ausreichend vielen Texten im JSON-Format trainiert, dass die KI auch JSON-Antworten generieren kann.Allerdings bedarf es geschickt formulierter Prompts, um die gewünschten Antworten auch tatsächlich im JSON-Format zu erhalten. Schließlich sollen die JSON-Antworten in eine regelbasierte Programmierung überführt werden.
Fehlerdiagnose in der Softwareentwicklung
Für Softwareentwickler ist die Fehlerdiagnose bei einer unbekannten Codebasis oft zeitaufwendig und besonders schwierig. Das korrekte Interpretieren von Fehlermeldungen und die Analyse von Stack-Traces sind essenziell. Für weniger erfahrene Entwickler stellt dies zumeist eine große Herausforderung dar. Zudem sind technische Fehlermeldungen für Nichttechniker häufig nur schwer verständlich, wodurch die Kommunikation zwischen Entwicklern und anderen Beteiligten erschwert wird.Viele Softwareunternehmen erkennen daher die Notwendigkeit, den Prozess der Fehlerdiagnose und -behebung zu optimieren. Ein idealer Ansatz wäre, sowohl klare Benutzerhinweise als auch technische Analysen bereitzustellen und sich gleichzeitig an unterschiedliche Anwendungskontexte anpassen zu können, um eine breite Anwendbarkeit zu gewährleisten. Diese Expertise kann in der Regel entweder von einem Softwareentwickler mit umfassendem Domain-Wissen oder von einem Service-Mitarbeiter mit tiefem Verständnis für Softwareentwicklung stammen. Beide sind jedoch rar und, wenn vorhanden, oft auch ausgelastet.Wie bereits erwähnt, wurde die GPT-KI mit einer immensen Menge an Daten trainiert. Bei GPT-4 waren es etwa 100 Billionen Parameter – vergleichbar mit rund 20 Billionen Wörtern oder 140 Millionen Büchern. Durch weitere nachträgliche Verfeinerungen der KI erhält man eine Emergenz (siehe Kasten KI-Begriffe) aus dem neuronalen Netz, welche die Kombination aus den Fähigkeiten von Softwareentwicklern und Support-/Service-Mitarbeitern darstellen kann.Integration von OpenAI-API und Entwicklungslogik
Für ein besseres Verständnis des nächsten Abschnitts sollen zunächst einige Grundlagen der Chat- und Kontextverwaltung von OpenAI erläutert werden. In früheren Versionen des API wurde einfach ein Text-String gesendet und ein solcher zurückgegeben. Der gesendete Text enthielt dabei den gesamten Kontext, einschließlich aller vorherigen Konversationsverläufe. Dieses Prinzip blieb im Wesentlichen erhalten, jedoch wurde die Struktur modifiziert, sodass Konversationen nun in einzelne Chat-Nachrichten segmentiert werden. Jede dieser Nachrichten setzt sich aus den Elementen Name, Rolle und Inhalt zusammen. Während der Name für unsere Betrachtungen nebensächlich ist, ist die Klarstellung der verschiedenen Rollen von Bedeutung. Die Details dazu finden Sie in Tabelle 1.Tabelle 1: Beschreibung der OpenAI-Rollen
|
Um der KI ein gezieltes Verhalten anzuweisen, beginnen wir damit, einen System-Prompt zu erstellen. Wichtig zu wissen ist, dass die KI zwar mit umfangreichen Textdaten trainiert wurde, der Großteil der Trainingsdaten jedoch in englischer Sprache vorlag. Daher liefern englischsprachige Eingaben in den Prompt in vielen Fällen bessere Ergebnisse.Aus diesem Grund ist es sinnvoll, so viele Informationen wie möglich in englischer Sprache zu übermitteln. Falls einzelne Segmente der Fehlerbeschreibung dennoch in Deutsch verfasst sind, stellt dies kein größeres Problem dar, solange die zentralen Anweisungen in Englisch gehalten sind. Hier der Inhalt des System-Prompts:
As an AI language model in this role, your purpose is to <span class="hljs-keyword">analyze</span>, interpret, <span class="hljs-keyword">and</span> provide useful information <span class="hljs-keyword">from</span> complex <span class="hljs-keyword">data</span> such <span class="hljs-keyword">as</span> <span class="hljs-keyword">error</span> stack traces, <span class="hljs-keyword">while</span> offering actionable insights <span class="hljs-keyword">to</span> <span class="hljs-keyword">users</span> <span class="hljs-keyword">and</span> developers. Your primary objective <span class="hljs-keyword">is</span> <span class="hljs-keyword">to</span> assist <span class="hljs-keyword">in</span> troubleshooting <span class="hljs-keyword">and</span> <span class="hljs-keyword">error</span> resolution <span class="hljs-keyword">by</span> processing <span class="hljs-keyword">and</span> presenting the relevant details <span class="hljs-keyword">in</span> a <span class="hljs-keyword">clear</span>, concise, <span class="hljs-keyword">and</span> <span class="hljs-keyword">user</span>-friendly manner.
Your <span class="hljs-keyword">key</span> responsibilities <span class="hljs-keyword">include</span>: Analyzing stack traces <span class="hljs-keyword">of</span> <span class="hljs-keyword">exceptions</span> <span class="hljs-keyword">and</span> identifying the root causes <span class="hljs-keyword">of</span> errors. Generating a detailed <span class="hljs-keyword">error</span> analysis that highlights possible causes <span class="hljs-keyword">and</span> affected components. Crafting <span class="hljs-keyword">user</span>-friendly messages <span class="hljs-keyword">to</span> <span class="hljs-keyword">help</span> non-technical <span class="hljs-keyword">users</span> understand the occurred <span class="hljs-keyword">error</span> <span class="hljs-keyword">without</span> overwhelming them <span class="hljs-keyword">with</span> technical jargon. Providing technical descriptions <span class="hljs-keyword">of</span> the <span class="hljs-keyword">error</span> <span class="hljs-keyword">for</span> software developers, <span class="hljs-keyword">including</span> information about affected classes, methods, <span class="hljs-keyword">and</span> line numbers <span class="hljs-keyword">in</span> the code. Suggesting one <span class="hljs-keyword">or</span> more potential solutions <span class="hljs-keyword">to</span> fix the <span class="hljs-keyword">error</span> based <span class="hljs-keyword">on</span> your conducted analysis. <span class="hljs-keyword">Through</span> these responsibilities, your aim <span class="hljs-keyword">is</span>
<span class="hljs-keyword">to</span> streamline the troubleshooting process, improve
communication <span class="hljs-keyword">between</span> technical <span class="hljs-keyword">and</span> non-technical
stakeholders, <span class="hljs-keyword">and</span> expedite <span class="hljs-keyword">error</span> resolution <span class="hljs-keyword">by</span> providing targeted, actionable insights.
<span class="hljs-keyword">At</span> the <span class="hljs-keyword">beginning</span> <span class="hljs-keyword">of</span> the message you will receive a country code (e.g. EN <span class="hljs-keyword">or</span> en-GB). Reply <span class="hljs-keyword">in</span> this language.
Jetzt wird es etwas kniffliger. Wie bereits erwähnt, muss die KI dazu überredet werden, im JSON-Format zu antworten. Dies gelingt besonders gut, indem man der KI ein Beispiel zur Orientierung gibt. Daher wird in den Kontext eine Konversation eingeführt, die als Vorlage für die KI dient. Den Anfang macht eine Benutzereingabe. Hier der Inhalt des ersten Benutzer-Prompts:
en-US: Analyze <span class="hljs-keyword">the</span> following stacktrace <span class="hljs-keyword">of</span> <span class="hljs-keyword">an</span> exception <span class="hljs-keyword">and</span> <span class="hljs-literal">return</span> <span class="hljs-keyword">the</span> results <span class="hljs-keyword">in</span> <span class="hljs-keyword">a</span> JSON structure. The JSON structure must contain <span class="hljs-keyword">the</span> following fields:
<span class="hljs-string">"errorAnalysis"</span>: A <span class="hljs-keyword">detailed</span> analysis <span class="hljs-keyword">of</span> <span class="hljs-keyword">the</span>
error, including possible causes <span class="hljs-keyword">and</span> affected
components.
<span class="hljs-string">"userMessage"</span>: An easy-<span class="hljs-built_in">to</span>-understand message <span class="hljs-keyword">for</span>
<span class="hljs-keyword">the</span> user, providing <span class="hljs-keyword">an</span> overview <span class="hljs-keyword">of</span> <span class="hljs-keyword">the</span> occurred
error <span class="hljs-keyword">without</span> being too technical.
<span class="hljs-string">"developerDetails"</span>: A technical description <span class="hljs-keyword">of</span>
<span class="hljs-keyword">the</span> error <span class="hljs-keyword">for</span> software developers, including
affected classes, methods, <span class="hljs-keyword">and</span> <span class="hljs-built_in">line</span> numbers <span class="hljs-keyword">in</span>
<span class="hljs-keyword">the</span> code.
Example: <span class="hljs-string">"solutions"</span>: One <span class="hljs-keyword">or</span> more possible
solution suggestions <span class="hljs-built_in">to</span> fix <span class="hljs-keyword">the</span> error based <span class="hljs-keyword">on</span>
<span class="hljs-title">the</span> <span class="hljs-title">analysis</span>.
{
<span class="hljs-string">"errorAnalysis"</span>: <span class="hljs-string">"The exception was triggered </span>
<span class="hljs-string"> by an invalid input in the 'calculate' </span>
<span class="hljs-string"> function."</span>,
<span class="hljs-string">"userMessage"</span>: <span class="hljs-string">"An error has occurred: Invalid </span>
<span class="hljs-string"> input. Please check your input and try </span>
<span class="hljs-string"> again."</span>,
<span class="hljs-string">"developerDetails"</span>: <span class="hljs-string">"The invalid input led to </span>
<span class="hljs-string"> an IllegalArgumentException in the </span>
<span class="hljs-string"> 'calculate' function of the 'Calculator' </span>
<span class="hljs-string"> class on line 42."</span>,
<span class="hljs-string">"solutions"</span>: [<span class="hljs-string">"Ensure the input values are </span>
<span class="hljs-string"> within the valid range."</span>,
<span class="hljs-string">"Add input value validation to catch invalid </span>
<span class="hljs-string"> values early."</span>]
}
Darauf wird jetzt die Antwort der KI vorgegeben. Antwort in der Rolle Assistant:
Ok, I got <span class="hljs-keyword">it</span>. Please give <span class="hljs-keyword">me</span> <span class="hljs-keyword">the</span> <span class="hljs-keyword">error</span> message <span class="hljs-keyword">and</span> <span class="hljs-keyword">the</span> stack trace.
Nun erst folgt das eigentliche Beispiel von User und Assistant. Hier das Beispiel der Fehlerübergabe als User:
en-US: Magnetic<span class="hljs-selector-class">.exe</span>
<span class="hljs-selector-class">Framework</span> Version: v4.<span class="hljs-number">0.30319</span>
Description: The process was terminated due to an
unhandled exception<span class="hljs-selector-class">.</span>
<span class="hljs-selector-class">Exception</span> Info: System<span class="hljs-selector-class">.MissingFieldException</span> at
Magnetic<span class="hljs-selector-class">.Presentation</span><span class="hljs-selector-class">.ViewModels</span>
<span class="hljs-selector-class">.ViewModelState</span>..ctor(Prism<span class="hljs-selector-class">.Events</span>
<span class="hljs-selector-class">.IEventAggregator</span>, Magnetic<span class="hljs-selector-class">.Core</span><span class="hljs-selector-class">.Interfaces</span>
<span class="hljs-selector-class">.IDeviceHandlerContainer</span>, Unity
<span class="hljs-selector-class">.IUnityContainer</span>, Magnetic<span class="hljs-selector-class">.BusinessObjects</span>
<span class="hljs-selector-class">.Interfaces</span><span class="hljs-selector-class">.ISignalCollectionInformation</span>,
Magnetic<span class="hljs-selector-class">.Core</span><span class="hljs-selector-class">.Interfaces</span><span class="hljs-selector-class">.IConnectionManager</span>
Es folgt nun die Vorgabe für eine Beispielantwort der KI in der Rolle als Assistant:
{
<span class="hljs-comment">"errorAnalysis"</span>: <span class="hljs-comment">"The exception is due to a </span>
<span class="hljs-comment"> System.MissingFieldException in the </span>
<span class="hljs-comment"> ViewModelState constructor, which led to a </span>
<span class="hljs-comment"> chain of exceptions, causing the application </span>
<span class="hljs-comment"> to terminate. This could be caused by a </span>
<span class="hljs-comment"> missing field, property or parameter in the </span>
<span class="hljs-comment"> ViewModelState class or its dependencies."</span>,
<span class="hljs-comment">"userMessage"</span>: <span class="hljs-comment">"An error has occurred while </span>
<span class="hljs-comment"> initializing the application. Please contact </span>
<span class="hljs-comment"> the support team for assistance."</span>,
<span class="hljs-comment">"developerDetails"</span>: <span class="hljs-comment">"The</span>
<span class="hljs-comment"> System.MissingFieldException occurred in the </span>
<span class="hljs-comment"> ViewModelState constructor at</span>
<span class="hljs-comment"> Magnetic.Presentation.ViewModels</span>
<span class="hljs-comment"> .ViewModelState..ctor. This caused a series </span>
<span class="hljs-comment"> of ResolutionFailedExceptions, </span>
<span class="hljs-comment"> ActivationExceptions, XamlParseExceptions, </span>
<span class="hljs-comment"> RegionCreationExceptions, and </span>
<span class="hljs-comment"> UpdateRegionsExceptions throughout the </span>
<span class="hljs-comment"> application. The root cause likely lies in </span>
<span class="hljs-comment"> the ViewModelState class or its </span>
<span class="hljs-comment"> dependencies."</span>,
<span class="hljs-comment">"solutions"</span>: [
<span class="hljs-comment">"Check the ViewModelState class and its </span>
<span class="hljs-comment"> dependencies for any missing fields, </span>
<span class="hljs-comment"> properties or parameters."</span>,
<span class="hljs-comment">"Ensure the correct version of dependencies </span>
<span class="hljs-comment"> is being used and are compatible with each </span>
<span class="hljs-comment"> other."</span>,
<span class="hljs-comment">"Verify that the ViewModelState constructor is </span>
<span class="hljs-comment"> receiving the correct parameters during </span>
<span class="hljs-comment"> object creation."</span>]
}
Listing 1 zeigt, wie die gerade zusammengestellten Prompts im Code übermittelt werden. Die Prompt-Texte sind dabei nicht erneut aufgeführt, sondern per Platzhalter bezeichnet (etwa „Inhalt des System-Prompts“).
Listing 1: Code der ersten Prompts
ChatMessages.Add(<span class="hljs-keyword">new</span> <span class="hljs-type">ChatMessage</span>(<br/> ChatMessageRole.System, <br/> <span class="hljs-string">"Inhalt des System Prompts"</span>));<br/>ChatMessages.Add(<span class="hljs-keyword">new</span> <span class="hljs-type">ChatMessage</span>(<br/> ChatMessageRole.User, <br/> <span class="hljs-string">"Inhalt des ersten Benutzer Prompts"</span>));<br/>ChatMessages.Add(<span class="hljs-keyword">new</span> <span class="hljs-type">ChatMessage</span>(<br/> ChatMessageRole.Assistant, <br/> <span class="hljs-string">"Antwort in der Rolle Assistant"</span>));<br/>ChatMessages.Add(<span class="hljs-keyword">new</span> <span class="hljs-type">ChatMessage</span>(<br/> ChatMessageRole.User, <br/> <span class="hljs-string">"Beispiel Fehlerübergabe als User"</span>));<br/>ChatMessages.Add(<span class="hljs-keyword">new</span> <span class="hljs-type">ChatMessage</span>(<br/> ChatMessageRole.Assistant, <br/> <span class="hljs-string">"Beispielantwort der KI als Assistant"</span>));
Als Nächstes werden die zentralen Informationen für die eigentliche Aufgabe benötigt. Diese ergeben sich aus der Exception, wobei insbesondere die Fehlermeldung und der Stack-Trace von Bedeutung sind. Diese Informationen werden den Chat-Nachrichten in der Rolle User hinzugefügt. Wichtig ist dabei, den Ländercode aus der CurrentCulture oder einer übergebenen CultureInfo voranzustellen.Mit diesen Informationen kann die Sammlung der Chat-Nachrichten mittels eines ChatRequest an das OpenAI-API übermittelt werden. Dabei sind noch drei relevante Parameter zu ergänzen:
- GPT-Modell. Zumeist ist das Modell mit der höchsten Version auch das am besten trainierte und liefert auch die besten Antworten. Sicherlich kann es hier auch Ausnahmen geben, und theoretisch könnten auch speziell nachtrainierte Modelle genutzt werden, die noch bessere Ergebnisse erzielen. Sicher ist: Je nach gewähltem Modell variieren die Kosten pro Token sowie die Dauer der Antwort.
- Temperature. Die Temperatur liegt zwischen 0 und 2 und sagt aus, wie präzise beziehungsweise kreativ eine KI antworten soll. Erfahrungsgemäß ergibt ein sehr niedriger Wert, also größerer Fokus auf eine präzise Antwort, nicht unbedingt ein besseres Ergebnis. Häufig benötigt eine KI auch einen gewissen Spielraum in der Kreativität; um die erlernten Trainingsdaten abstrahiert auf eine Situation anwenden zu können.
- Maximale Token. Hierüber werden die maximalen Token einer Antwort definiert. Ganz grob entsprechen 750 Wörter 1000 Token.
Listing 2: Beispiel eines API-Aufrufs
currentMessages.Add(new ChatMessage(<br/> ChatMessageRole.User, $<span class="hljs-string">"{CultureInfo</span><br/><span class="hljs-string"> .CurrentCulture.TwoLetterISOLanguageName}: </span><br/><span class="hljs-string"> {exception.Message}\n{exception.StackTrace}"</span>));<br/>ChatRequest <span class="hljs-attr">chatRequest</span> = new() {<span class="hljs-attr">Model</span> = <br/> Model.GPT4, <span class="hljs-attr">Temperature</span> = <span class="hljs-number">1</span>, <span class="hljs-attr">MaxTokens</span> = <span class="hljs-number">2000</span>, <br/> <span class="hljs-attr">Messages</span> = currentMessages};<br/>ChatResult <span class="hljs-attr">chatResult</span> = await openAiApi.Chat<br/> .CreateChatCompletionAsync(chatRequest);<br/>ChatMessage <span class="hljs-attr">openAiMessage</span> = <br/> openAiMessage.Choices[<span class="hljs-number">0</span>].Message;<br/>string <span class="hljs-attr">response</span> = openAiMessage.Content;<br/>AnalyzedException&lt;T&gt; <span class="hljs-attr">analyzedException</span> = <br/> new (exception);<br/>analyzedException.MapAnalysis(<br/> JsonConvert.DeserializeObject&lt;<br/> InternalAnalyzedException&gt;(response));
Das Anwendungsbeispiel in Listing 3 demonstriert die Einsatzmöglichkeiten des beschriebenen Vorgehens. Listing 4 zeigt den Einsatz in Form eines async-Aufrufs in einem Exception-Handler und Listing 5 in einem async-Aufruf mit await.
Listing 3: Anwendungsbeispiel
static void Main(string[] args)<br/>{<br/> try {<br/> // Code, der eine Exception auslösen kann<br/> }<br/> catch (Exception ex) {<br/> AnalyzedException&lt;Exception&gt; analyzedEx = <br/> ex.GetAnalyzedException();<br/> Console.WriteLine(analyzedEx.UserMessage);<br/> SendErrorReport(analyzedEx);<br/> }<br/>}<br/>private static void SendErrorReport(<br/> AnalyzedException&lt;Exception&gt; analyzedEx)<br/>{<br/> // Code zum Senden des Fehlerberichts an das <br/> // Entwicklerteam<br/>} Listing 4: async-Aufruf im ExceptionHandler
static void Main(string[] args)<br/>{<br/> try {<br/> // Code, der eine Exception auslösen kann<br/> }<br/> catch (Exception ex) {<br/> ExceptionHandler.Handle(exception);<br/> }<br/>}<br/>public static class ExceptionHandler<br/>{<br/> public static void Handle(Exception exception)<br/> {<br/> exception.GetAnalyzedExceptionAsync()<br/> .ContinueWith(ProcessAnalyzedException);<br/> }<br/> private static void ProcessAnalyzedException(<br/> Task&lt;AnalyzedException&lt;Exception&gt;&gt; task)<br/> {<br/> AnalyzedException&lt;Exception&gt; analyzedEx = <br/> task.Result;<br/> Console.WriteLine(analyzedEx.UserMessage);<br/> SendErrorReport(analyzedEx);<br/> }<br/> private static void SendErrorReport(<br/> AnalyzedException&lt;Exception&gt; analyzedEx)<br/> {<br/> // Code zum Senden des Fehlerberichts an das <br/> // Entwicklerteam<br/> }<br/>} Listing 5: async-Methode mit await-Aufruf
public static class ExceptionHandler<br/>{<br/> public static async void Handle(<br/> Exception exception)<br/> {<br/> AnalyzedException&lt;Exception&gt; analyzedEx = <br/> await exception.GetAnalyzedExceptionAsync()<br/> Console.WriteLine(analyzedEx.UserMessage);<br/> SendErrorReport(analyzedEx);<br/> }<br/> private static void SendErrorReport(<br/> AnalyzedException&lt;Exception&gt; analyzedEx)<br/> {<br/> // Code zum Senden des Fehlerberichts an das <br/> // Entwicklerteam<br/> }<br/>}
Die Anwendungsbeispiele zeigen eindrücklich, wie mühelos der ExceptionAInalyzer in diverse Applikationstypen integriert werden kann, um die Fehlerbehandlung sowohl effektiver als auch benutzerfreundlicher zu gestalten. Hierbei kommt die Potenz von OpenAIs GPT-Modell zum Tragen, das sowohl Entwicklern als auch Endbenutzern wertvolle Erkenntnisse und Lösungsansätze bietet.
Fazit
Der ExceptionAInalyzer erleichtert das Verständnis von Exceptions mittels klarer Auswertungen und unterstützt so die Kommunikation zwischen verschiedenen Stakeholdern. Die dargestellte Implementierung verdeutlicht die Anwendbarkeit in unterschiedlichen Anwendungskontexten, wobei die Berücksichtigung der CurrentCulture zusätzliche Benutzerorientierung bietet.Trotz gewisser Limitierungen, wie beispielsweise den Antwortzeiten des OpenAI-API, repräsentiert der ExceptionAInalyzer einen innovativen Schritt in der modernen Fehlerbehandlung und der Unterstützung von KI.Der gesamte Code befindet sich auf GitHub [2] und ist dort unter der MIT-Lizenz verfügbar. Wer an der Integration via NuGet interessiert ist, wird in [3] unter dem Namen ExceptionAInalyzer fündig.Fussnoten
- OpenAI-API-Preise, https://openai.com/pricing
- Der Code zum Artikel, http://www.dotnetpro.de/SL2401ExceptionAInalyzer1
- ExceptionAInalyzer als NuGet-Paket, http://www.dotnetpro.de/SL2401ExceptionAInalyzer2
