Microsoft announced on the .NET Blog in May 2025 that Microsoft.Extensions.AI and the Vector Data extensions were generally available, turning the preview abstractions it introduced in October 2024 into supported, stable APIs. The GA packages give .NET a common, provider-neutral contract for chat models, embeddings and vector stores, in the same spirit as ILogger did for logging. For library authors and enterprise teams that had been waiting for a stable foundation before committing to an AI architecture, this was the green light.

Key Facts#

  • Announcement: Microsoft published the GA announcement on the .NET Blog on May 21, 2025.
  • Stable packages: Microsoft.Extensions.AI.Abstractions and Microsoft.Extensions.AI version 9.5.0, published to NuGet on May 16, 2025.
  • Evaluation: the core Microsoft.Extensions.AI.Evaluation, Evaluation.Quality and Evaluation.Reporting libraries also went stable at 9.5.0, while new content safety evaluators shipped as a preview.
  • Vector data: Microsoft.Extensions.VectorData.Abstractions 9.5.0 was published as a stable release on May 19, 2025.
  • Still in preview: provider adapters such as the OpenAI, Azure AI Inference and Ollama integrations. The OpenAI adapter did not ship a stable version until 10.3.0 in February 2026.
  • History: the first preview of Microsoft.Extensions.AI appeared on NuGet on October 8, 2024.

What Happened#

The GA milestone landed in the dotnet/extensions 9.5.0 release, whose notes include the change that marked Microsoft.Extensions.AI and its abstractions package as stable. That release also cleaned house before the compatibility promise took effect. Obsolete preview APIs were removed, including older AsChatClient and AsEmbeddingGenerator extension methods, and the conversation identifier on chat options was renamed to ConversationId. Anyone who had built against early previews needed a small migration, but the result was a surface Microsoft could commit to.

At the center of the stable API are two interfaces. IChatClient represents any chat-capable model through GetResponseAsync and GetStreamingResponseAsync, with ChatMessage, ChatOptions and ChatResponse as the exchange types. IEmbeddingGenerator<TInput, TEmbedding> does the same for embedding models. Around them, the main package provides composable middleware through ChatClientBuilder: automatic function invocation, OpenTelemetry instrumentation, distributed caching and logging, all registered with familiar dependency injection helpers such as AddChatClient.

The Vector Data half of the announcement covered Microsoft.Extensions.VectorData.Abstractions, a set of exchange types for vector databases that grew out of Semantic Kernel. Shortly before GA, the Semantic Kernel team reshaped these APIs: interfaces became the abstract base classes VectorStore and VectorStoreCollection, record attributes got shorter names such as VectorStoreKey and VectorStoreVector, and search was unified into a single SearchAsync method that can call an IEmbeddingGenerator on your behalf. Individual database connectors continued to ship on their own schedules.

The evaluation libraries round out the release. The quality package includes evaluators for relevance, truth, completeness, fluency, coherence, retrieval, equivalence and groundedness, and the reporting package caches model responses, stores results and generates reports, which makes it practical to run LLM quality checks inside ordinary test suites.

Background#

Before these abstractions existed, every AI provider shipped its own .NET client with its own message types, streaming model and tool-calling conventions. Libraries that wanted to support several providers had to write adapters for each, and applications that switched models often rewrote large parts of their code. Microsoft introduced Microsoft.Extensions.AI in preview in October 2024 to fix that, borrowing the pattern that made Microsoft.Extensions.Logging and Microsoft.Extensions.DependencyInjection successful: a small abstractions package that everyone can depend on, plus optional implementations and middleware.

Semantic Kernel became one of the biggest consumers of that design. Its vector store work moved onto the new embedding abstractions, and the shared exchange types meant that code written for Semantic Kernel, for the Microsoft.Extensions.AI pipeline and for third-party libraries could interoperate. The GA announcement was the point at which that ecosystem could stop tracking previews.

Why It Matters for Developers#

For application developers, the main benefit is decoupling. You write business logic against IChatClient, register a concrete provider at startup and add cross-cutting behavior as middleware:

C#
using Microsoft.Extensions.AI;
using OpenAI.Chat;

var builder = WebApplication.CreateBuilder(args);

var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
IChatClient provider = new ChatClient("gpt-4o-mini", apiKey).AsIChatClient();

builder.Services.AddChatClient(provider)
    .UseFunctionInvocation()
    .UseOpenTelemetry()
    .UseLogging();

var app = builder.Build();

app.MapPost("/summaries", async (SummaryRequest request, IChatClient chat, CancellationToken ct) =>
{
    ChatResponse response = await chat.GetResponseAsync(
        $"Summarize this in two sentences:\n{request.Text}", cancellationToken: ct);
    return Results.Ok(response.Text);
});

app.Run();

record SummaryRequest(string Text);

Swapping providers means changing the registration, not the endpoint. The same structure makes testing easier, because a fake IChatClient can stand in for a real model in unit tests.

For library authors, the stable abstractions package is the more important change. A NuGet package that accepts an IChatClient or IEmbeddingGenerator no longer has to pin itself to a preview dependency, which removes a common objection from enterprise dependency reviews.

A few cautions applied at GA and still apply today:

  • Separate stable from preview. The abstractions were stable, but the adapters were not. Pin adapter versions and read their release notes before upgrading.
  • Instrument from day one. UseOpenTelemetry() costs one line and gives you token usage and latency data. Our guide to observability and cost control for LLM apps shows what to do with it.
  • Test quality, not just code paths. The stable evaluation libraries make it realistic to gate releases on groundedness or relevance scores. See evaluating AI applications in .NET.

If you are new to the stack, start with our Microsoft.Extensions.AI guide, then move on to embeddings and vector databases in .NET and end-to-end RAG in .NET to see the Vector Data abstractions in context.

What's Next#

From today's perspective, the GA release was the start of a steady cadence rather than an endpoint. Version 10.0.0 of the abstractions shipped on November 11, 2025, alongside .NET 10. The OpenAI adapter reached its first stable release, 10.3.0, on February 10, 2026, closing the most visible gap left at GA. By September 2026, the packages had moved to 10.10.0, still on a roughly monthly schedule.

The abstractions also became the foundation for Microsoft's higher-level agent tooling. Semantic Kernel continues to build on them, and Microsoft Agent Framework's ChatClientAgent wraps any IChatClient, so an investment in Microsoft.Extensions.AI carries forward into agent development. Our Semantic Kernel guide explains how the two layers fit together.

Sources#