Verarbeiten von benutzerdefinierten Daten für KI-Anwendungen

In dieser Schnellstartanleitung erfahren Sie, wie Sie eine Datenaufnahmepipeline erstellen, um benutzerdefinierte Daten für KI-Anwendungen zu verarbeiten und vorzubereiten. Die App verwendet die Microsoft.Extensions.DataIngestion Bibliothek, um Dokumente zu lesen, Inhalte durch KI zu bereichern, Text semantisch zu segmentieren und Einbettungen in einer Vektordatenbank für die semantische Suche zu speichern.

Die Datenaufnahme ist für RAG-Szenarien (Retrieval Augmented Generation) von wesentlicher Bedeutung, bei denen Sie große Mengen unstrukturierter Daten verarbeiten und für KI-Anwendungen durchsuchbar machen müssen.

Voraussetzungen

.NET 8.0 SDK oder höher – .NET 8 SDKinstallieren.
Azure-Abonnement – kostenloses Abonnement erstellen.
Azure Developer CLI (optional) – Installieren oder Aktualisieren der Azure Developer CLI.

Erstellen der App

Führen Sie die folgenden Schritte aus, um eine .NET-Konsolen-App zu erstellen.

Verwenden Sie in einem leeren Verzeichnis auf Ihrem Computer den Befehl dotnet new, um eine neue Konsolen-App zu erstellen:
```
dotnet new console -o ProcessDataAI
```
Wechseln Sie das Verzeichnis in den App-Ordner:
```
cd ProcessDataAI
```

Installieren Sie die erforderlichen Pakete:

dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Microsoft.Extensions.DataIngestion --prerelease
dotnet add package Microsoft.Extensions.DataIngestion.Markdig --prerelease
dotnet add package Microsoft.Extensions.Logging.Console
dotnet add package Microsoft.ML.Tokenizers.Data.O200kBase
dotnet add package Microsoft.SemanticKernel.Connectors.SqliteVec --prerelease

Erstellen Sie den KI-Dienst

Führen Sie zum Bereitstellen eines Azure OpenAI-Diensts und -Modells die Schritte im Artikel zum Erstellen und Bereitstellen eines Azure OpenAI Service-Ressourcenartikels aus. Für diese Schnellstartanleitung müssen Sie zwei Modelle bereitstellen: gpt-5 und text-embedding-3-small.
Navigieren Sie über ein Terminal oder eine Eingabeaufforderung zum Stammverzeichnis Des Projekts.

Führen Sie die folgenden Befehle aus, um Ihren Azure OpenAI-Endpunkt und DEN API-Schlüssel für die Beispiel-App zu konfigurieren:

dotnet user-secrets init
dotnet user-secrets set AZURE_OPENAI_ENDPOINT <your-Azure-OpenAI-endpoint>
dotnet user-secrets set AZURE_OPENAI_API_KEY <your-Azure-OpenAI-API-key>

Öffnen der App in einem Editor

Öffnen Sie die App in Visual Studio Code (oder Ihrem ausgewählten Editor).

code .

Erstellen der Beispieldaten

Kopieren Sie die sample.md Datei in einen Ordner, der in Ihrem Projektverzeichnis benannt ist data .
Konfigurieren Sie das Projekt, um diese Datei in das Ausgabeverzeichnis zu kopieren. Wenn Sie Visual Studio verwenden, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei, wählen Sie "Eigenschaften" aus, und legen Sie dann " In Ausgabeverzeichnis kopieren " auf "Kopieren" fest, wenn neuer.

Fügen Sie den App-Code hinzu

Die Datenaufnahmepipeline besteht aus mehreren Komponenten, die zusammenarbeiten, um Dokumente zu verarbeiten:

Dokumentleser: Liest Markdown-Dateien aus einem Verzeichnis.
Dokumentprozessor: Bereichert Bilder mit KI-generierten Alternativtext.
Chunker: Teilt Dokumente mithilfe von Einbettungen in semantische Blöcke auf.
Blockprozessor: Generiert KI-Zusammenfassungen für jeden Block.
Vektorspeicher-Schreiber: Speichert Blöcke samt Einbettungen in einer SQLite-Datenbank.

Löschen Sie in der Program.cs Datei den vorhandenen Code, und fügen Sie den folgenden Code hinzu, um den Dokumentleser zu konfigurieren:
```
// Configure document reader.
IngestionDocumentReader reader = new MarkdownReader();
```
Die MarkdownReader Klasse liest Markdown-Dokumente und konvertiert sie in ein einheitliches Format, das gut mit großen Sprachmodellen funktioniert.

Fügen Sie Code zum Konfigurieren der Protokollierung für die Pipeline hinzu:

using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder => builder.AddSimpleConsole());

Fügen Sie Code hinzu, um den KI-Client für Anreicherung und Chat zu konfigurieren:

// Configure IChatClient to use Azure OpenAI.
IConfigurationRoot config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

string endpoint = config["AZURE_OPENAI_ENDPOINT"];
string apiKey = config["AZURE_OPENAI_API_KEY"];
string chatModel = "gpt-5";
string embeddingModel = "text-embedding-3-small";

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(apiKey));

IChatClient chatClient =
    azureClient.GetChatClient(chatModel).AsIChatClient();

Fügen Sie Code hinzu, um den Dokumentprozessor zu konfigurieren, der Bilder mit KI-generierten Beschreibungen anreichert:

// Configure document processor.
EnricherOptions enricherOptions = new(chatClient)
{
    // Enricher failures should not fail the whole ingestion pipeline,
    // as they are best-effort enhancements.
    // This logger factory can create loggers to log such failures.
    LoggerFactory = loggerFactory
};

IngestionDocumentProcessor imageAlternativeTextEnricher =
    new ImageAlternativeTextEnricher(enricherOptions);

Der ImageAlternativeTextEnricher verwendet große Sprachmodelle, um beschreibenden Alternativtext für Bilder in Dokumenten zu generieren. Dieser Text macht sie barrierefreier und verbessert ihre semantische Bedeutung.

Fügen Sie Code zum Konfigurieren des Einbettungsgenerators zum Erstellen von Vektordarstellungen hinzu:
```
// Configure embedding generator.
IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator =
    azureClient.GetEmbeddingClient(embeddingModel).AsIEmbeddingGenerator();
```
Einbettungen sind numerische Darstellungen der semantischen Bedeutung von Text, wodurch die Vektorähnlichkeitssuche ermöglicht wird.
Fügen Sie Code hinzu, um den Chunker zu konfigurieren, der Dokumente in semantische Blöcke aufteilt:
```
// Configure chunker to split text into semantic chunks.
IngestionChunkerOptions chunkerOptions = new(TiktokenTokenizer.CreateForModel(chatModel))
{
    MaxTokensPerChunk = 2000,
    OverlapTokens = 0
};

IngestionChunker<string> chunker =
    new SemanticSimilarityChunker(embeddingGenerator, chunkerOptions);
```
Die SemanticSimilarityChunker dokumente werden intelligent aufgeteilt, indem die semantische Ähnlichkeit zwischen Sätzen analysiert wird und sichergestellt wird, dass verwandte Inhalte zusammen bleiben. Dieser Prozess erzeugt Blöcke, die Bedeutung und Kontext besser erhalten als einfache Zeichen oder tokenbasierte Blöcke.
Fügen Sie Code zum Konfigurieren des Blockprozessors hinzu, der Zusammenfassungen generiert:
```
// Configure chunk processor to generate summaries for each chunk.
IngestionChunkProcessor<string> summaryEnricher = new SummaryEnricher(enricherOptions);
```
Die SummaryEnricher generiert automatisch präzise Zusammenfassungen für jeden Abschnitt. Dadurch kann die Abrufgenauigkeit verbessert werden, indem eine zusammenfassende Übersicht über den Inhalt bereitgestellt wird.

Fügen Sie Code zum Konfigurieren des SQLite-Vektorspeichers zum Speichern von Einbettungen hinzu:

// Configure SQLite Vector Store.
using SqliteVectorStore vectorStore = new(
    "Data Source=vectors.db;Pooling=false",
    new()
    {
        EmbeddingGenerator = embeddingGenerator
    });

// The writer requires the embedding dimension count to be specified.
using VectorStoreWriter<string> writer = new(
    vectorStore,
    dimensionCount: 1536,
    new VectorStoreWriterOptions { CollectionName = "data" });

Der Vektorspeicher speichert Blöcke zusammen mit ihren Einbettungen, wodurch schnelle semantische Suchfunktionen ermöglicht werden.

Fügen Sie Code hinzu, um alle Komponenten zu einer vollständigen Pipeline zusammenzustellen.

// Compose data ingestion pipeline
using IngestionPipeline<string> pipeline =
    new(reader, chunker, writer, loggerFactory: loggerFactory)
{
    DocumentProcessors = { imageAlternativeTextEnricher },
    ChunkProcessors = { summaryEnricher }
};

Der IngestionPipeline<T> kombiniert alle Komponenten zu einem zusammenhängenden Workflow, der Dokumente von Anfang bis Ende verarbeitet.

Hinzufügen von Code zum Verarbeiten von Dokumenten aus einem Verzeichnis:

await foreach (IngestionResult result in pipeline.ProcessAsync(
    new DirectoryInfo("./data"),
    searchPattern: "*.md"))
{
    Console.WriteLine($"Completed processing '{result.DocumentId}'. " +
        $"Succeeded: '{result.Succeeded}'.");
}

Die Pipeline verarbeitet alle Markdown-Dateien im ./data Verzeichnis und meldet den Status jedes Dokuments.

Fügen Sie Code hinzu, um die interaktive Suche der verarbeiteten Dokumente zu ermöglichen:

// Search the vector store collection and display results
VectorStoreCollection<object, Dictionary<string, object?>> collection =
    writer.VectorStoreCollection;

while (true)
{
    Console.Write("Enter your question (or 'exit' to quit): ");
    string? searchValue = Console.ReadLine();
    if (string.IsNullOrEmpty(searchValue) || searchValue == "exit")
    {
        break;
    }

    Console.WriteLine("Searching...\n");
    await foreach (VectorSearchResult<Dictionary<string, object?>> result in
        collection.SearchAsync(searchValue, top: 3))
    {
        Console.WriteLine($"Score: {result.Score}\n\tContent: {result.Record["content"]}");
    }
}

Die Suchfunktion konvertiert Benutzerabfragen in Einbettungen und findet die semantisch ähnlichsten Blöcke im Vektorspeicher.

App starten

Verwenden Sie den Befehl dotnet run, um die App auszuführen:
```
dotnet run
```
Die App verarbeitet alle Markdown-Dateien im ./data Verzeichnis und zeigt den Verarbeitungsstatus für jedes Dokument an. Sobald die Verarbeitung abgeschlossen ist, können Sie Fragen in natürlicher Sprache eingeben, um den verarbeiteten Inhalt zu durchsuchen.
Geben Sie an der Eingabeaufforderung eine Frage ein, um die Daten zu durchsuchen:
```
Enter your question (or 'exit' to quit): What is data ingestion?
```
Die App gibt die relevantesten Blöcke aus Ihren Dokumenten zusammen mit ihren Ähnlichkeitsergebnissen zurück.
Geben Sie exit ein, um die Anwendung zu beenden.

Bereinigen von Ressourcen

Wenn Sie sie nicht mehr benötigen, löschen Sie die Azure OpenAI-Ressource und die Modellbereitstellung.

Navigieren Sie im Azure-Portalzur Azure OpenAI-Ressource.
Wählen Sie die Azure OpenAI-Ressource aus und wählen Sie dann Löschen.

Nächste Schritte

Feedback

War diese Seite hilfreich?

Last updated on 2026-03-12