Übung – Einen benutzerdefinierten Konnektor für Ihren Copiloten erstellen

  • 20 Minuten

Hintergrund

Diese Übung geht von der Übung Azure OpenAI Service konfigurieren, um Informationen zu Ihrem Podcast zu generieren einen Schritt weiter. Ihre Aufgaben für diese Übung bestehen darin, eine .NET-API mit dem .NET Azure OpenAI SDK zu erstellen und einen benutzerdefinierten Konnektor von Visual Studio zu erstellen.

Definitionen

Die folgenden Abschnitte umfassen Definitionen wichtiger Elemente, die Sie für diese Übung kennen müssen.

.NET

.NET ist eine kostenlose, plattformübergreifende Open-Source-Entwicklerplattform für die Erstellung vieler verschiedener Arten von Anwendungen. Mit .NET können Sie mehrere Sprachen, Editoren und Bibliotheken verwenden, um Erstellungen für das Web, Mobilgeräte, Desktop, Spiele, das Internet der Dinge (IoT) und KI durchzuführen.

Weitere Informationen erhalten Sie unter Einführung in .NET.

.NET Azure OpenAI SDK

Die Azure OpenAI-Clientbibliothek für .NET ist eine Adaption der REST-APIs von OpenAI, die eine idiomatische Schnittstelle und umfassende Integration mit dem Rest des Azure SDK-Ökosystems bereitstellen. Es kann mit Azure OpenAI-Ressourcen oder Nicht-Azure-OpenAI-Inferenzendpunkt verbunden werden, was es zu einer großartigen Wahl für die Nicht-Azure-OpenAI-Entwicklung macht.

Unter Azure OpenAI-Clientbibliothek für .NET finden Sie dazu weitere Informationen.

Microsoft Power Platform

Die Microsoft Power Platform hilft Organisationen dabei, ihre Teammitglieder durch ein intuitives Low-Code‑ oder No-Code-Set von Diensten in die Lage zu versetzen, ihre eigenen Lösungen zu entwickeln. Diese Dienste tragen dazu bei, den Prozess des Erstellens von Lösungen zu vereinfachen. Mit Microsoft Power Platform können Sie Lösungen in Tagen oder Wochen anstatt in Monaten oder Jahren erstellen. Microsoft Power Platform besteht aus fünf Schlüsselprodukten: Power Apps, Power Automate, Power BI, Power Virtual Agents und Power Pages.

Weitere Informationen finden Sie unter Microsoft Power Platform.

Benutzerdefinierter Konnektor

Microsoft Azure Logic Apps, Microsoft Power Automate und Microsoft Power Apps bieten über 1.000 Konnektoren für Verbindungen zu Microsoft und verifizierten Diensten. Möglicherweise möchten Sie jedoch mit Diensten kommunizieren, die nicht als vorgefertigte Konnektoren zur Verfügung stehen. Benutzerdefinierte Konnektoren behebt die Probleme dieses Szenarios, indem sie Ihnen die Möglichkeit geben, einen Konnektor mit eigenen Triggern und Aktionen zu erstellen (und auch zu teilen).

Zusätzliche Informationen erhalten Sie unter Benutzerdefinierte Konnektoren.

Voraussetzungen

Stellen Sie für diese Übung Folgendes sicher:

Übungsschritte

Das folgende Video führt Sie durch die Schritte für die Übung dieser Lerneinheit.

Umgebungsvariablen einrichten

Führen Sie die folgenden Schritte aus, um Umgebungsvariablen einzurichten:

  1. Öffnen Sie eine Eingabeaufforderung, und führen Sie dann nacheinander folgende Befehle aus:

     setx AZURE_OPENAI_KEY_WE "REPLACE_WITH_YOUR_WEST_EUROPE_KEY_VALUE_HERE"
 setx AZURE_OPENAI_ENDPOINT_WE https://podcastcopilotwe-{your initials}.openai.azure.com/

    Der vorhergehende Befehl gilt für den Ressourcenschlüssel und Endpunkt „Europa, Westen“.

     setx AZURE_OPENAI_KEY_SC "REPLACE_WITH_YOUR_SWEDEN_CENTRAL_KEY_VALUE_HERE" 
 setx AZURE_OPENAI_ENDPOINT_SC "https://podcastcopilotsc-{your initials}.openai.azure.com/"

    Der vorhergehende Befehl gilt für den Ressourcenschlüssel und Endpunkt „Schweden, Mitte“.

    setx BING_SEARCH_KEY "REPLACE_WITH_YOUR_KEY_VALUE_HERE"

    Der vorhergehende Befehl gilt für den Ressourcenschlüssel „Bing-Suche“.

  2. Schließen Sie die Eingabeaufforderung, nachdem Sie die Umgebungsvariablen festgelegt haben.

Ein neues .NET-Web-API-Projekt erstellen

Ihre nächste Aufgabe ist es, die folgenden Schritte auszuführen, um ein neues .NET-Web-API-Projekt zu erstellen:

  1. Öffnen Sie Visual Studio, und wählen Sie die Option Ein neues Projekt erstellen aus.

    Screenshot der Option „Neues Projekt erstellen“ in Visual Studio

  2. Suchen Sie nach Web-API, und wählen Sie ASP.NET Core Web-API aus. Stellen Sie sicher, dass Sie die C#-Projektvorlage auswählen.

    Screenshot der Projektvorlage A S P dot net Core Web-API

  3. Wählen Sie Weiter aus.

  4. Geben Sie Ihrem Projekt den Namen PodcastAppAPI, und klicken Sie dann auf Weiter.

  5. Stellen Sie sicher, dass das Framework auf .NET 8 und der Authentifizierungstyp auf Keine eingerichtet ist sowie dass die Option Für HTTPS konfigurieren ausgewählt ist. Wählen Sie Erstellen aus.

    Screenshot der Projekteinstellungen

  6. Nachdem das System das Projekt erstellt hat, öffnen Sie den Projektmappen-Explorer, klicken Sie mit der rechten Maustaste auf das Projekt PodcastAppAPI, um das Kontextmenü zu öffnen. Klicken Sie dann auf Im Terminal öffnen.

  7. Führen Sie im Terminalfenster den folgenden Befehl aus, um die Vorabversion vom Azure OpenAI SDK zu installieren:

    dotnet add package Azure.AI.OpenAI --version 1.0.0-beta.13

  8. Führen Sie zum Installieren des Newtonsoft.Json-Pakets den folgenden Befehl aus:

    dotnet add package Newtonsoft.Json --version 13.0.3

Die PodcastCopilot-Klasse erstellen

Führen Sie die folgenden Schritte aus, um die Klasse PodcastCopilot zu erstellen:

  1. Nachdem der Befehl ausgeführt ist, fügen Sie dem Projekt eine neue Klasse hinzu, indem Sie mit der rechten Maustaste auf das Projekt PodcastAppAPI klicken, um das Kontextmenü zu öffnen. Wählen Sie dann Hinzufügen > Klasse aus. Geben Sie der Klasse den Namen PodcastCopilot.

    Screenshot des Hinzufügens einer neuen Klasse zu einem Projekt

  2. Fügen Sie in der Klasse PodcastCopilot oben die folgenden using-Anweisungen hinzu:

     using System.Web;
 using Azure.AI.OpenAI;
 using Azure;    
 using Newtonsoft.Json.Linq;

  3. Fügen Sie in der Klasse PodcastCopilot den folgenden Code hinzu:

     //Initializing the Endpoints and Keys
 static string endpointWE = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT_WE");
 static string keyWE = Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY_WE");

 static string endpointSC = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT_SC");
 static string keySC = Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY_SC");

 static string bingSearchUrl = "https://api.bing.microsoft.com/v7.0/search";
 static string bingSearchKey = Environment.GetEnvironmentVariable("BING_SEARCH_KEY");

 //Instantiate OpenAI Client for Whisper and GPT-3
 static OpenAIClient clientWE = new OpenAIClient(
     new Uri(endpointWE), 
     new AzureKeyCredential(keyWE));

 //Instantiate OpenAI Client for Dall.E 3
 static OpenAIClient clientSC = new OpenAIClient(
     new Uri(endpointSC), 
     new AzureKeyCredential(keySC));

  4. Fügen Sie unter dem vorhergehenden Code den folgenden Code hinzu, um Audio-Transkription auszuführen:

     //Get Audio Transcription
 public static async Task<string> GetTranscription(string podcastUrl)
 {
     var decodededUrl = HttpUtility.UrlDecode(podcastUrl);

     HttpClient httpClient = new HttpClient();
     Stream audioStreamFromBlob = await httpClient.GetStreamAsync(decodededUrl);

     var transcriptionOptions = new AudioTranscriptionOptions()
     {
         DeploymentName = "whisper",
         AudioData = BinaryData.FromStream(audioStreamFromBlob),
         ResponseFormat = AudioTranscriptionFormat.Verbose,
         Filename = "file.mp3"
     };

     Response<AudioTranscription> transcriptionResponse = await clientWE.GetAudioTranscriptionAsync(
         transcriptionOptions);
     AudioTranscription transcription = transcriptionResponse.Value;

     return transcription.Text;
 }

  5. Fügen Sie den folgenden Code hinzu, um die Extraktion des Gästenamens auszuführen:

     //Get Audio Transcription
 public static async Task<string> GetTranscription(string podcastUrl)
 {
     var decodededUrl = HttpUtility.UrlDecode(podcastUrl);

     HttpClient httpClient = new HttpClient();
     Stream audioStreamFromBlob = await httpClient.GetStreamAsync(decodededUrl);

     var transcriptionOptions = new AudioTranscriptionOptions()
     {
         DeploymentName = "whisper",
         AudioData = BinaryData.FromStream(audioStreamFromBlob),
         ResponseFormat = AudioTranscriptionFormat.Verbose,
         Filename = "file.mp3"
     };

     Response<AudioTranscription> transcriptionResponse = await clientWE.GetAudioTranscriptionAsync(
         transcriptionOptions);
     AudioTranscription transcription = transcriptionResponse.Value;

     return transcription.Text;
 }

  6. Fügen Sie der Klasse PodcastCopilot den folgenden Code hinzu, um Extraktion der Gastbiografie aus Bing durchführen:

     //Get Guest Bio from Bing
 public static async Task<string> GetGuestBio(string guestName)
 {
     var client = new HttpClient();

     client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", bingSearchKey);

     HttpResponseMessage response = await client.GetAsync($"{bingSearchUrl}?q={guestName}");

     string responseBody = await response.Content.ReadAsStringAsync();

     // Parse responseBody as JSON and extract the bio.
     JObject searchResults = JObject.Parse(responseBody);
     var bio = searchResults["webPages"]["value"][0]["snippet"].ToString();

     return bio;
 }

  7. Fügen Sie den folgenden Code hinzu, um den nächsten Schritt des Verfahrens PodcastCopilot auszuführen: Einen Social-Media-Text erstellen.

     //Create Social Media Blurb
 public static async Task<string> GetSocialMediaBlurb(string transcription, string bio)
 {
     var completionOptions = new ChatCompletionsOptions()
     {
         DeploymentName = "gpt35turbo",
         Messages =
         {
             new ChatRequestSystemMessage(
                 @"You are a helpful large language model that can create a 
                 LinkedIn promo blurb for episodes of the podcast 
                 Behind the Tech, when given transcripts of the podcasts.
                 The Behind the Tech podcast is hosted by Kevin Scott.\n"
             ),
             new ChatRequestUserMessage(
                 @"Create a short summary of this podcast episode 
                 that would be appropriate to post on LinkedIn to    
                 promote the podcast episode. The post should be 
                 from the first-person perspective of Kevin Scott, 
                 who hosts the podcast.\n" +
                 $"Here is the transcript of the podcast episode: {transcription} \n" +
                 $"Here is the bio of the guest: {bio} \n"
             )
         },
         Temperature = (float)0.7
     };

     Response<ChatCompletions> completionsResponse = await clientWE.GetChatCompletionsAsync(
         completionOptions);
     ChatCompletions completion = completionsResponse.Value;

     return completion.Choices[0].Message.Content;
 }

  8. Fügen Sie den folgenden Code hinzu, um den nächsten Schritt des Verfahrens PodcastCopilot auszuführen: Eine Dall.E-Eingabeaufforderung erstellen.

     //Generate a Dall-E prompt
 public static async Task<string> GetDallEPrompt(string socialBlurb)
 {
     var completionOptions = new ChatCompletionsOptions()
     {
         DeploymentName = "gpt35turbo",
         Messages =
     {
         new ChatRequestSystemMessage(
             @"You are a helpful large language model that generates 
             DALL-E prompts, that when given to the DALL-E model can 
             generate beautiful high-quality images to use in social 
             media posts about a podcast on technology. Good DALL-E 
             prompts will contain mention of related objects, and 
             will not contain people or words. Good DALL-E prompts 
             should include a reference to podcasting along with 
             items from the domain of the podcast guest.\n"
         ),
         new ChatRequestUserMessage(
             $@"Create a DALL-E prompt to create an image to post along 
             with this social media text: {socialBlurb}"
         )
     },
         Temperature = (float)0.7
     };

     Response<ChatCompletions> completionsResponse = await clientWE.GetChatCompletionsAsync(
     completionOptions);

     ChatCompletions completion = completionsResponse.Value;

     return completion.Choices[0].Message.Content;
 }

  9. Fügen Sie den folgenden Code hinzu, um den nächsten Schritt des Verfahrens PodcastCopilot auszuführen: Das Social-Media-Bild von DallE generieren.

     //Create social media image with a Dall-E
 public static async Task<string> GetImage(string prompt)
 {
     var generationOptions = new ImageGenerationOptions()
     {
         Prompt = prompt + ", high-quality digital art",
         ImageCount = 1,
         Size = ImageSize.Size1024x1024,
         Style = ImageGenerationStyle.Vivid,
         Quality = ImageGenerationQuality.Hd,
         DeploymentName = "dalle3",
         User = "1",
     };

     Response<ImageGenerations> imageGenerations =
         await clientSC.GetImageGenerationsAsync(generationOptions);

     return imageGenerations.Value.Data[0].Url.ToString();
 }

Sie haben nun die Klasse PodcastCopilot erstellt, die die Methoden zum Ausführen des Prozesses enthält, der eine Podcast-URL entgegennimmt und einen Social-Media-Beitrag und ein Bild für diesen Podcast zurückgibt. Sie können jetzt die Klasse SocialMediaPost erstellen.

Die SocialMediaPost-Klasse erstellen

Ihre nächste Aufgabe ist das Erstellen der Klasse SocialMediaPost.

Klicken Sie mit der rechten Maustaste auf das Projekt PodcastAppAPI, um das Kontextmenü zu öffnen. Wählen Sie dann Hinzufügen > Klasse aus. Geben Sie der Klasse den Namen SocialMediaPost, und fügen Sie der Klasse dann den folgenden Code hinzu:

```
public class SocialMediaPost
{
    public string ImageUrl { get; set; }
    public string Blurb { get; set; }
}
```

Die Klasse sollte wie im folgenden Beispiel aussehen.

Screenshot der Klasse Social-Media-Beitrag

Nachdem Sie nun die Klasse SocialMediaPost erstellt haben, können Sie eine weitere Methode der Klasse PodcastCopilot zur Rückgabe eines Objekts SocialMediaPost hinzufügen.

Die PodcastCopilot-Klasse aktualisieren

Öffnen Sie zur Aktualisierung der PodcastCopilot die Klasse PodcastCopilot, und fügen Sie der Klasse die folgende Methode hinzu:

```
public static async Task<SocialMediaPost> GenerateSocialMediaPost(string podcastUrl)
{
    var transcription = await GetTranscription(podcastUrl);
    var guestName = await GetGuestName(transcription);
    var guestBio = await GetGuestBio(guestName);
    var generatedBlurb = await GetSocialMediaBlurb(transcription, guestBio);
    var dallePrompt = await GetDallEPrompt(generatedBlurb);
    var generatedImage = await GetImage(dallePrompt);

    var socialMediaPost = new SocialMediaPost()
    {
        ImageUrl = generatedImage,
        Blurb = generatedBlurb
    };

    return socialMediaPost;
}
```

Sie können jetzt die Datei Program.cs aktualisieren, um die Minimal-API zu implementieren.

Die Datei Program.cs mit der Minimal-API-Implementierung aktualisieren

Ihre nächste Aufgabe ist es, die Datei Program.cs mit der Minimal-API-Implementierung zu aktualisieren.

Öffnen Sie dazu zunächst die Datei Program.cs. Ersetzen Sie dann den gesamten Code in dieser Datei mit folgendem Code:

```
var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

//Implement Minimal APIs

app.Run();
```

Sie können nun Ihre API in einen benutzerdefinierten Konnektor umwandeln, sodass Sie sie in Microsoft Power Platform verwenden können.

Einen benutzerdefinierten Konnektor von Visual Studio erstellen

Befolgen Sie diese Schritte, um einen benutzerdefinierten Konnektor von Visual Studio zu erstellen:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten Verbundene Dienste, um das Kontextmenü zu öffnen. Klicken Sie dann auf Hinzufügen > Microsoft Power Platform.

    Screenshot zum Hinzufügen des neuen verbundenen Services

  2. Stellen Sie sicher, dass Sie mit dem gleichen Konto angemeldet sind wie Ihr Power Apps-Entwicklerplan. Konfigurieren Sie dann im Popup-Fenster Mit Microsoft Power Platform verbinden die folgenden Einstellungen:

    • Power Platform-Umgebungen – Wählen Sie beliebig eine Umgebung aus.

    • Power Platform-Lösungen – Wählen Sie eine Lösung Ihrer Wahl aus.

    • Benutzerdefinierte Konnektoren – Erstellen Sie einen neuen benutzerdefinierten Konnektor, und geben Sie ihm den Namen PodcastCopilot_Connector.

    • OpenAPI-Spezifikation – Wählen Sie die Option OpenAPI-V2-Spezifikation automatisch generieren aus.

    • Einen öffentlichen Entwicklungstunnel auswählen – Erstellen Sie einen neuen Entwicklungstunnel, und geben Sie ihm den Namen PodcastCopilot_Tunnel.

  3. Wählen Sie Weiter > Fertig stellen aus.

    Screenshot zum Konfigurieren des neuen verbundenen Services

  4. Schließen Sie das Popup-Fenster, nachdem der Abhängigkeitskonfigurationsprozess abgeschlossen wurde.

  5. Führen Sie die Anwendung aus. Wenn im Browserfenster die folgende Nachricht angezeigt wird, wählen Sie die Option Weiter aus, um die Verbindung mit Ihrem Entwicklertunnel herzustellen.

    Screenshot der Nachricht zur Verbindung Ihres Entwicklertunnels und der Schaltfläche „Weiter“

    Nachdem der Entwicklertunnel eine Verbindung hergestellt hat, zeigt das System eine einzelne API-Operation an, die Sie testen können, um festzustellen, ob sie richtig funktioniert oder nicht.

  6. Wählen Sie den Vorgang GenerateSocialMediaPost aus, um ihn zu erweitern, und klicken Sie dann auf die Schaltfläche Testen.

    Screenshot mit dem Prozess „Testen“

  7. Geben Sie die URL der Podcast-Episode ein, die Sie in der vorherigen Übung in Azure Blob Storage hochgeladen haben, und wählen Sie anschließend die Option Ausführen aus.

  8. Achten Sie auf ein Antwort aus der API-Operation, das eine Bild-URL und einen Social-Media-Text darstellt, den das System mit Azure OpenAI aus dem Podcast-Audio generiert.

    Screenshot der Antwort aus dem API-Vorgang

Sie haben jetzt mit dem .NET Azure OpenAI SDK eine .NET-API und zudem einen benutzerdefinierten Konnektor von Visual Studio erstellt. Sie können jetzt die API in Microsoft Power Platform verwenden.

Nächste Schritte

Sie haben gelernt, wie Sie eine .NET-API und einen zugehörigen benutzerdefinierten Konnektor erstellen. Als Nächstes erfahren Sie, wie Sie diesen benutzerdefinierten Konnektor in Microsoft Power Platform Tools integrieren.