Partilhar via

Processar dados personalizados para aplicações de IA

Neste quickstart, aprende a criar um pipeline de ingestão de dados para processar e preparar dados personalizados para aplicações de IA. A aplicação utiliza a Microsoft.Extensions.DataIngestion biblioteca para ler documentos, enriquecer conteúdos com IA, fragmentar texto semanticamente e armazenar embeddings numa base de dados vetorial para pesquisa semântica.

A ingestão de dados é essencial para cenários de geração aumentada por recuperação (RAG), onde é necessário processar grandes quantidades de dados não estruturados e torná-los pesquisáveis para aplicações de IA.

Pré-requisitos

Criar a aplicação

Conclua as etapas a seguir para criar um aplicativo de console .NET.

  1. Em um diretório vazio no computador, use o comando dotnet new para criar um novo aplicativo de console:

    dotnet new console -o ProcessDataAI

  2. Altere o diretório para a pasta do aplicativo:

    cd ProcessDataAI

  3. Instale os pacotes necessários:

    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

Criar o serviço de IA

  1. Para provisionar um serviço e um modelo do Azure OpenAI, conclua as etapas no artigo Criar e implantar um recurso do Serviço OpenAI do Azure . Para este quickstart, precisa de provisionar dois modelos: gpt-5 e text-embedding-3-small.

  2. Em um terminal ou prompt de comando, navegue até a raiz do diretório do projeto.

  3. Execute os seguintes comandos para configurar o seu endpoint Azure OpenAI e a chave API para a aplicação de exemplo:

    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>

Abra a aplicação num editor

Abra o aplicativo no Visual Studio Code (ou seu editor de escolha).

code .

Crie os dados de exemplo

  1. Copie o ficheiro sample.md para uma pasta nomeada data no diretório do seu projeto.
  2. Configure o projeto para copiar esse arquivo para o diretório de saída. Se você estiver usando o Visual Studio, clique com o botão direito do mouse no arquivo no Gerenciador de Soluções, selecione Propriedades e defina Copiar para Diretório de Saída como Copiar se for mais recente.

Adicionar o código do aplicativo

O pipeline de ingestão de dados consiste em vários componentes que trabalham em conjunto para processar documentos:

  • Leitor de documentos: Lê ficheiros Markdown a partir de um diretório.
  • Processador de documentos: Enriquece imagens com texto alternativo gerado por IA.
  • Chunker: Divide documentos em blocos semânticos usando embeddings.
  • Processador de fragmentos: Gera resumos de IA para cada fragmento.
  • Vector store writer: Armazena blocos com embeddings numa base de dados SQLite.

  1. No Program.cs ficheiro, elimine qualquer código existente e adicione o seguinte código para configurar o leitor de documentos:

    // Configure document reader.
IngestionDocumentReader reader = new MarkdownReader();

    A MarkdownReader classe lê documentos Markdown e converte-os para um formato unificado que funciona bem com grandes modelos de linguagem.

  2. Adicione código para configurar o log para o pipeline:

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

  3. Adicione código para configurar o cliente de IA para enriquecimento e chat:

    // 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();

  4. Adicione código para configurar o processador de documentos que enriquece imagens com descrições geradas por IA:

    // 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);

    O ImageAlternativeTextEnricher utiliza grandes modelos de linguagem para gerar texto alternativo descritivo para imagens em documentos. Esse texto torna-as mais acessíveis e melhora o seu significado semântico.

  5. Adicione código para configurar o gerador de embedding para criar representações vetoriais:

    // Configure embedding generator.
IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator =
    azureClient.GetEmbeddingClient(embeddingModel).AsIEmbeddingGenerator();

    Os embeddings são representações numéricas do significado semântico do texto, que permitem a pesquisa por similaridade vetorial.

  6. Adicione código para configurar o chunker que divide documentos em blocos semânticos:

    // 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);

    O SemanticSimilarityChunker divide inteligentemente os documentos ao analisar a semelhança semântica entre frases, garantindo que o conteúdo relacionado permaneça junto. Este processo produz chunks que preservam o significado e o contexto melhor do que a simples fragmentação baseada em caracteres ou tokens.

  7. Adicione código para configurar o processador de blocos que gera resumos:

    // Configure chunk processor to generate summaries for each chunk.
IngestionChunkProcessor<string> summaryEnricher = new SummaryEnricher(enricherOptions);

    Gera SummaryEnricher automaticamente resumos concisos para cada bloco, o que pode melhorar a precisão da recuperação ao fornecer uma visão geral de alto nível do conteúdo.

  8. Adicionar código para configurar o armazenamento vetorial SQLite para armazenar embeddings:

    // 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" });

    A loja vetorial armazena blocos juntamente com os seus embeddings, permitindo funcionalidades de pesquisa semântica rápida.

  9. Adicione código para compor todos os componentes num pipeline completo:

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

    O IngestionPipeline<T> combina todos os componentes num fluxo de trabalho coeso que processa documentos do início ao fim.

  10. Adicionar código para processar documentos a partir de um diretório:

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

    O pipeline processa todos os ficheiros Markdown no ./data diretório e reporta o estado de cada documento.

  11. Adicione código para permitir a pesquisa interativa dos documentos processados:

    // 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"]}");
    }
}

    A funcionalidade de pesquisa converte as consultas dos utilizadores em embeddings e encontra os blocos semanticamente mais semelhantes na loja vetorial.

Executar o aplicativo

  1. Use o dotnet run comando para executar o aplicativo:

    dotnet run

    A aplicação processa todos os ficheiros Markdown no ./data diretório e mostra o estado de processamento de cada documento. Quando o processamento estiver concluído, pode inserir perguntas em linguagem natural para pesquisar o conteúdo processado.

  2. Introduza uma pergunta no prompt para pesquisar os dados:

    Enter your question (or 'exit' to quit): What is data ingestion?

    A aplicação devolve as partes mais relevantes dos seus documentos juntamente com as suas pontuações de similaridade.

  3. Escreve exit para sair da aplicação.

Limpeza de recursos

Se você não precisar mais deles, exclua o recurso e a implantação do modelo do Azure OpenAI.

  1. No Portal Azure, acesse o recurso OpenAI do Azure.
  2. Selecione o recurso Azure OpenAI e, em seguida, selecione Excluir.

Passos seguintes

  • Last updated on