--- title: ".NET 9 y Microsoft.Extensions.AI: la nueva forma de integrar IA en tus aplicaciones" description: "Descubrí cómo Microsoft.Extensions.AI unifica la integración de IA en aplicaciones .NET con abstracciones limpias, soporte para OpenAI y Azure, y un diseño pensado para escalar. Por Devlights." url: "https://www.devlights.com/es/blog/net9-microsoft-extensions-ai" language: es published: 2026-10-17T13:00:00.000Z updated: 2026-10-28T22:29:52.219Z type: devtalk authors: ["Fernando Luján"] category: "DevTalks" tags: [".NET 9", "Microsoft.Extensions.AI", "IA generativa", "C#", "LLM", "OpenAI", "Azure AI", "Arquitectura de software"] --- # .NET 9 y Microsoft.Extensions.AI: la nueva forma de integrar IA en tus aplicaciones > Microsoft.Extensions.AI es la librería que estabas esperando para integrar IA en tus aplicaciones .NET sin atarte a un proveedor específico. Con .NET 9, tenés una API unificada, abstracciones limpias y un ecosistema que ya conocés. [YouTube](https://www.youtube.com/watch?v=nGFoG0nEopQ) > **TL;DR** > > Microsoft.Extensions.AI es la librería que estabas esperando para integrar IA en tus aplicaciones .NET sin atarte a un proveedor específico. > > Con .NET 9, tenés una API unificada, abstracciones limpias y un ecosistema que ya conocés. ## ¿Por qué .NET 9 marca un antes y un después en el desarrollo con IA? La IA generativa dejó de ser una tecnología experimental para convertirse en un componente central de muchas aplicaciones modernas. El problema hasta ahora era siempre el mismo: integrar un modelo de lenguaje (LLM) en tu aplicación .NET implicaba lidiar con SDKs específicos de cada proveedor, lógica acoplada y código difícil de testear o reemplazar. Con el lanzamiento de **.NET 9 en noviembre de 2024**, Microsoft dio una respuesta clara a ese problema: **Microsoft.Extensions.AI**. ## ¿Qué es Microsoft.Extensions.AI? Microsoft.Extensions.AI es un conjunto de librerías .NET que proveen **abstracciones unificadas** para integrar servicios de IA, tanto modelos de chat como generación de embeddings, en aplicaciones y librerías .NET. Si ya trabajaste con `Microsoft.Extensions.Logging` o `Microsoft.Extensions.DependencyInjection`, el concepto te va a resultar familiar de inmediato: | Extensión | Abstracción principal | | --- | --- | | `Microsoft.Extensions.Logging` | `ILogger` | | `Microsoft.Extensions.Caching.*` | `IMemoryCache`, `IDistributedCache` | | `Microsoft.Extensions.DependencyInjection` | `IServiceCollection` | | `Microsoft.Extensions.AI` | `IChatClient`**,** `IEmbeddingGenerator` | La librería se instala fácilmente vía NuGet y se incorpora al pipeline de dependencias que ya conocés. ## Las dos abstracciones clave ``` IChatClient ``` Es la interfaz central para interactuar con modelos de lenguaje. Permite construir clientes de chat que funcionen con cualquier backend, OpenAI, Azure OpenAI, modelos locales, sin cambiar el código de tu aplicación. Implementar `IChatClient` te da: - Intercambio de mensajes estructurados - Soporte para streaming de respuestas - Invocación de herramientas (tool calling) - Compatibilidad con middleware de logging y telemetría ``` IEmbeddingGenerator ``` Abstrae la generación de embeddings: representaciones vectoriales de texto o imágenes que capturan conceptos semánticos. Son el bloque fundamental para casos de uso como búsqueda semántica, similitud de documentos y sistemas RAG (Retrieval-Augmented Generation). ## ¿Por qué importa la abstracción? La clave de esta librería no está solo en simplificar el código, está en el modelo de diseño que propone. Al igual que con logging o DI, **el código de tu aplicación no depende de un proveedor específico**. Esto significa que podés: - **Desarrollar con un modelo local** y hacer deploy con Azure OpenAI sin tocar el código de negocio. - **Testear con mocks** de `IChatClient` sin necesidad de llamadas reales a la API. - **Cambiar de proveedor** cuando aparezca uno mejor, sin refactorizar toda la aplicación. - **Agregar middleware** (caché, telemetría, rate limiting) de forma declarativa y reutilizable. ## Casos de uso soportados Microsoft.Extensions.AI está diseñado para cubrir los patrones de uso más comunes en aplicaciones de IA modernas: **Chat y conversación: Desde** chatbots simples hasta asistentes con historial de conversación y personalidad definida. **Retrieval-Augmented Generation (RAG):** Conectá tus sistemas de IA con datos propios del negocio. La combinación de `IEmbeddingGenerator` + búsqueda vectorial permite que el modelo responda con contexto específico de tu organización. **Procesamiento de imágenes:** Las aplicaciones de IA pueden ir más allá del texto. La librería soporta entradas visuales para extraer información estructurada desde datos visuales. **Funciones e integración con sistemas externos:** Las funciones (tool calling) le dan al sistema de IA la capacidad de ejecutar acciones concretas: consultar una base de datos, llamar a una API, ejecutar lógica de negocio. ## Beneficios en resumen **API Unificada:** Un conjunto consistente de convenciones para integrar cualquier servicio de IA. Aprendés una vez, aplicás en todos lados. **Flexibilidad de proveedor:** Escribís código contra la abstracción, no contra OpenAI ni Azure. El proveedor es un detalle de configuración. **Facilidad para experimentar:** Probá diferentes modelos y proveedores usando las mismas abstracciones subyacentes. La experimentación no implica reescritura. **Componentización y testeo:** Middlewares estándar para caché, telemetría e invocación de herramientas. Componentes fáciles de aislar, testear y reutilizar. ## Ejemplos de implementación ### Uso básico de IChatClient Primero instalás los paquetes necesarios: ``` dotnet add package Microsoft.Extensions.AI dotnet add package Microsoft.Extensions.AI.OpenAI ``` Luego registrás el cliente en el contenedor de DI, igual que cualquier otro servicio: ``` // Program.cs builder.Services.AddChatClient(new OpenAIClient("tu-api-key") .AsChatClient(modelId: "gpt-4o-mini")); ``` Y lo usás en cualquier clase inyectando `IChatClient`, sin saber nada de OpenAI: ``` public class AssistantService(IChatClient chatClient) { public async Task AskAsync(string question) { var response = await chatClient.CompleteAsync(question); return response.Message.Text ?? string.Empty; } } ``` Para cambiar de OpenAI a Azure OpenAI, **solo cambiás el registro**. El resto del código no se toca: ``` // Cambio de proveedor: solo esta línea cambia builder.Services.AddChatClient(new AzureOpenAIClient( new Uri("https://tu-recurso.openai.azure.com/"), new DefaultAzureCredential()) .AsChatClient(deploymentName: "gpt-4o-mini")); ``` ### Agregar middleware de telemetría y caché Una de las ventajas más concretas es poder encadenar comportamientos sin modificar la lógica: ``` builder.Services.AddChatClient(inner => inner .UseLogging() // loga todas las llamadas automáticamente .UseOpenTelemetry() // métricas y trazas listas para exportar .UseDistributedCache() // caché de respuestas para prompts repetidos .Use(new OpenAIClient("tu-api-key").AsChatClient("gpt-4o-mini"))); ``` ### Generación de embeddings con `IEmbeddingGenerator` ``` builder.Services.AddEmbeddingGenerator( new OpenAIClient("tu-api-key") .AsEmbeddingGenerator(modelId: "text-embedding-3-small")); // En tu servicio: public class SemanticSearchService(IEmbeddingGenerator> embedder) { public async Task GetVectorAsync(string text) { var result = await embedder.GenerateAsync(text); return result[0].Vector.ToArray(); } } ``` Estos vectores son la base para implementar búsqueda semántica o sistemas RAG sobre tu propia base de datos. ## ¿Por dónde empezar? Si querés explorar Microsoft.Extensions.AI en tu propio entorno, el punto de partida oficial es: 📦 **Descargá .NET 9:** [aka.ms/get-dotnet-9](https://aka.ms/get-dotnet-9) La documentación oficial de Microsoft y los paquetes NuGet de `Microsoft.Extensions.AI` y `Microsoft.Extensions.AI.Abstractions` son el punto de entrada natural desde ahí. ## Conclusión Microsoft.Extensions.AI no es solo otra librería para llamar a GPT. Es una apuesta de diseño: que la IA en aplicaciones .NET debería seguir los mismos principios de abstracción, composición y testabilidad que ya rigen el resto del ecosistema. Para los equipos que trabajan con .NET, esto significa poder adoptar IA de manera incremental, sin dependencias duras y con la confianza de que el código va a ser mantenible a largo plazo. En Devlights llevamos este tipo de decisiones de arquitectura al trabajo diario con nuestros clientes. Si estás pensando cómo incorporar IA en tus aplicaciones .NET de forma sostenible, [hablemos](https://www.devlights.com/es/contact).