Building AI features into .NET applications often means stitching together different models, vector databases, ingestion pipelines, and agent frameworks—each with its own patterns and client libraries. To simplify this, a set of composable, extensible building blocks has been developed, providing stable abstractions across all these concerns. At the MVP Summit, a team demonstrated this by creating an interactive conference assistant called ConferencePulse. The app runs live polls, answers audience questions in real time, generates insights from engagement data, and summarizes sessions when they end—all built using the same technologies being presented: Microsoft.Extensions.AI, Microsoft.Extensions.DataIngestion, Microsoft.Extensions.VectorData, Model Context Protocol (MCP), and Microsoft Agent Framework. This article breaks down the seven essential components that make such an app possible.
1. Unified AI Abstractions with Microsoft.Extensions.AI
At the core of any AI application is the ability to call language models without being tied to a specific provider. Microsoft.Extensions.AI provides the IChatClient interface—a unified abstraction that works with OpenAI, Azure OpenAI, Ollama, Foundry Local, and many others. This means every AI call in ConferencePulse—from generating polls to answering questions—goes through a single client, making it easy to switch providers or add new ones without changing the rest of the code. The library also includes built-in support for function calling, streaming, and metadata, which simplifies tool integration. For the MVP Summit app, Azure OpenAI was used, but the same code could run on a local model for debugging or offline scenarios. This layer eliminates provider lock-in and reduces breaking changes when provider libraries update.
2. Streamlined Data Ingestion with Microsoft.Extensions.DataIngestion
Before any AI feature can work, the system needs knowledge. ConferencePulse automates preparation by pointing at a GitHub repository—it downloads Markdown files, processes them through a pipeline, and builds a searchable knowledge base. Microsoft.Extensions.DataIngestion provides a stable abstraction for this pipeline. It defines a standard pattern for extracting, transforming, and loading (ETL) content into a vector store. The pipeline handles chunking, cleaning, and embedding generation, outputting consistently formatted data. This component is crucial because it grounds all AI responses—polls, talking points, and Q&A answers—in actual session content rather than relying on generic model knowledge. The extensibility of the pipeline allows custom steps, such as filtering or summarizing, to be added per project.
3. Vector Search for RAG with Microsoft.Extensions.VectorData
Retrieval-Augmented Generation (RAG) powers the audience Q&A feature. When an attendee asks a question, the system first searches a vector database for relevant documents. Microsoft.Extensions.VectorData offers a unified abstraction for vector stores like Qdrant, Chroma, or Azure Cognitive Search. This means the application can switch between storage backends without rewriting search logic. ConferencePulse uses this to query the session knowledge base, Microsoft Learn docs, and GitHub wiki content. The retrieved passages are then fed to the LLM to generate a grounded answer. The abstraction also simplifies hybrid search (combining vector and keyword) and handles metadata filtering. The result is fast, accurate answers that stay on-topic.
4. Tool Integration via Model Context Protocol (MCP)
ConferencePulse needs to interact with external tools—like querying live poll results or fetching attendee counts. The Model Context Protocol (MCP) standardizes how AI agents declare and invoke tools. Instead of writing custom function-calling code for each tool, developers define MCP servers that expose capabilities (e.g., "get current poll data") through a uniform protocol. The app includes an MCP server that wraps internal APIs, and an MCP client that the agents use to call these tools. This decoupling means agents can be developed independently of the tool implementations. As the conference evolves, new tools can be added without modifying agent logic. MCP also handles authentication, retries, and error messaging, making the system robust and extensible.
5. Multi-Agent Workflows with Microsoft Agent Framework
When the presenter ends a session, ConferencePulse generates a comprehensive summary by analyzing polls, questions, and insights concurrently. The Microsoft Agent Framework orchestrates multiple AI agents, each with a specific role: one evaluates poll trends, another reviews audience questions, and a third analyzes overall engagement. These agents work in parallel, then merge their findings into a coherent report. The framework provides abstractions for agent lifecycle, communication, and state management. It supports both single-turn and multi-turn interactions. For the summary, agents use MCP tools to access data and then collaborate via a coordinator agent that synthesizes outputs. This component demonstrates how complex AI workflows can be built from simple, reusable building blocks.
6. Real-Time Interaction with Blazor Server
The user-facing side of ConferencePulse is a Blazor Server application. Attendees scan a QR code to join a session, then interact via polls and Q&A in real time. Blazor Server provides a persistent SignalR connection between server and client, enabling live updates without page refreshes. When AI generates a new poll or an answer appears, the UI updates instantly. The server-side rendering also keeps the AI orchestration logic secure and centralized. The app uses .NET 10 and leverages ASP.NET Core features for resilience. Blazor Server was chosen over WebAssembly because the app requires constant server communication for AI calls and real-time data. The result is a smooth, interactive experience that feels like a native app.
7. Orchestration and Hosting with .NET Aspire
Running a multi-component app like ConferencePulse locally or in production requires careful orchestration. .NET Aspire provides the hosting infrastructure, managing dependencies like Qdrant (vector database), PostgreSQL (relational store), and Azure OpenAI (LLM service). Aspire's dashboard gives developers a unified view of logs, metrics, and health checks. It handles service discovery, environment configuration, and automatic containerization. For ConferencePulse, the AppHost project wires together the Blazor app, ingestion pipeline, and agent services. Aspire also simplifies deployment to Azure Container Apps or other environments, making it easier to move from development to production. This component ties all the others together, ensuring they run reliably and scale as needed.
Conclusion
ConferencePulse exemplifies how Microsoft's composable AI stack simplifies building sophisticated AI-powered applications in .NET. By providing stable abstractions for AI calls, data ingestion, vector search, tool integration, and agent orchestration, these building blocks reduce boilerplate and provider lock-in. Developers can focus on application logic rather than plumbing. Whether you're building a conference app, a customer support bot, or an internal knowledge base, the same composable components apply. The stack is open-source and designed to evolve without breaking existing code—making it a solid foundation for future AI projects.