Procesamiento de datos personalizados para aplicaciones de inteligencia artificial

En este inicio rápido, aprenderá a crear una canalización de ingesta de datos para procesar y preparar datos personalizados para aplicaciones de inteligencia artificial. La aplicación utiliza la biblioteca Microsoft.Extensions.DataIngestion para leer documentos, enriquecer el contenido con IA, segmentar el texto semánticamente y almacenar representaciones en una base de datos vectorial para la búsqueda semántica.

La ingesta de datos es esencial para escenarios de generación aumentada de recuperación (RAG) en los que es necesario procesar grandes cantidades de datos no estructurados y hacer que se puedan buscar aplicaciones de INTELIGENCIA ARTIFICIAL.

Prerrequisitos

SDK de .NET 8.0 o superior: Instale el SDK de .NET 8.
Una suscripción de Azure: cree una gratuitamente.
CLI para desarrolladores de Azure (opcional): Instalar o actualizar la CLI para desarrolladores de Azure.

Creación de la aplicación

Complete los pasos siguientes para crear una aplicación de consola de .NET.

En un directorio vacío de su ordenador, utilice el comando dotnet new para crear una nueva aplicación de consola:
```
dotnet new console -o ProcessDataAI
```
Cambia el directorio a la carpeta app:
```
cd ProcessDataAI
```

Instale los paquetes necesarios:

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

Crear el servicio de IA

Para aprovisionar un servicio y un modelo de Azure OpenAI, complete los pasos descritos en el artículo Creación e implementación de un recurso de azure OpenAI Service . Para este inicio rápido, debe aprovisionar dos modelos: gpt-5 y text-embedding-3-small.
Desde un terminal o línea de comandos, dirígete a la raíz del directorio de tu proyecto.

Ejecute los siguientes comandos para configurar el punto de conexión y la clave de API de Azure OpenAI para la aplicación de ejemplo:

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>

Abrir la aplicación en un editor

Abra la aplicación en Visual Studio Code (o en el editor que prefiera).

code .

Creación de los datos de ejemplo

Copie el archivo sample.md en una carpeta denominada data en el directorio del proyecto.
Configure el proyecto para copiar este archivo en el directorio de salida. Si usa Visual Studio, haga clic con el botón derecho en el archivo en el Explorador de soluciones, seleccione Propiedades y, a continuación, establezca Copiar en directorio de salida en Copiar si es más reciente.

Adición del código de la aplicación

La canalización de ingesta de datos consta de varios componentes que funcionan conjuntamente para procesar documentos:

Lector de documentos: lee los archivos Markdown de un directorio.
Procesador de documentos: enriquece las imágenes con texto alternativo generado por IA.
Fragmentador: divide documentos en fragmentos semánticos mediante incrustaciones.
Procesador de fragmentos: genera resúmenes de IA para cada fragmento.
Escritor de almacén vectorial: almacena fragmentos con incrustaciones en una base de datos de SQLite.

En el Program.cs archivo, elimine cualquier código existente y agregue el código siguiente para configurar el lector de documentos:
```
// Configure document reader.
IngestionDocumentReader reader = new MarkdownReader();
```
La MarkdownReader clase lee los documentos de Markdown y los convierte en un formato unificado que funciona bien con modelos de lenguaje grandes.

Agregue código para configurar el registro de la canalización:

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

Agregue código para configurar el cliente de IA para el enriquecimiento y el 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();

Agregue código para configurar el procesador de documentos que enriquece las imágenes con descripciones generadas 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);

El ImageAlternativeTextEnricher usa modelos de lenguaje grandes para generar texto alternativo descriptivo para imágenes dentro de documentos. Ese texto hace que sean más accesibles y mejora su significado semántico.

Agregue código para configurar el generador de inserción para crear representaciones vectoriales:
```
// Configure embedding generator.
IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator =
    azureClient.GetEmbeddingClient(embeddingModel).AsIEmbeddingGenerator();
```
Las incrustaciones son representaciones numéricas del significado semántico del texto, lo que permite la búsqueda de similitud vectorial.
Agregue código para configurar el fragmentador que divide los documentos en fragmentos 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);
```
El SemanticSimilarityChunker elemento divide los documentos de forma inteligente mediante el análisis de la similitud semántica entre oraciones, lo que garantiza que el contenido relacionado permanezca juntos. Este proceso genera fragmentos que conservan el significado y el contexto mejor que el carácter simple o la fragmentación basada en tokens.
Agregue código para configurar el procesador de fragmentos que genera resúmenes:
```
// Configure chunk processor to generate summaries for each chunk.
IngestionChunkProcessor<string> summaryEnricher = new SummaryEnricher(enricherOptions);
```
El SummaryEnricher genera automáticamente resúmenes concisos para cada fragmento, lo que puede mejorar la precisión de la recuperación proporcionando una visión general de alto nivel del contenido.

Agregue código para configurar el almacén de vectores de SQLite para almacenar incrustaciones:

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

El almacén de vectores almacena fragmentos junto con sus incrustaciones, lo que permite funcionalidades de búsqueda semántica rápidas.

Agregue código para componer todos los componentes en una canalización completa:

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

IngestionPipeline<T> combina todos los componentes en un flujo de trabajo cohesivo que procesa los documentos de principio a fin.

Agregue código para procesar documentos desde un directorio:

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

La canalización procesa todos los archivos Markdown del ./data directorio e informa del estado de cada documento.

Agregue código para habilitar la búsqueda interactiva de los documentos procesados:

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

La funcionalidad de búsqueda convierte las consultas de usuario en incrustaciones y busca los fragmentos más semánticamente similares en el almacén de vectores.

Ejecuta la aplicación

Use el comando dotnet run para ejecutar la aplicación:
```
dotnet run
```
La aplicación procesa todos los archivos Markdown del ./data directorio y muestra el estado de procesamiento de cada documento. Una vez completado el procesamiento, puede escribir preguntas de lenguaje natural para buscar en el contenido procesado.
Escriba una pregunta en el campo de texto para buscar los datos.
```
Enter your question (or 'exit' to quit): What is data ingestion?
```
La aplicación devuelve los fragmentos más relevantes de los documentos junto con sus puntuaciones de similitud.
Escriba exit para salir de la aplicación.

Limpieza de recursos

Si ya no los necesita, elimine el recurso y la implementación del modelo de Azure OpenAI.

En Azure Portal, vaya al recurso de Azure OpenAI.
Seleccione el recurso Azure OpenAI y, a continuación, seleccione Eliminar.

Pasos siguientes

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-03-11