Integrating AI into .NET applications often involves piecing together models, vector databases, data pipelines, and agent frameworks from disparate ecosystems. Each component introduces its own patterns, client libraries, and version-specific breaking changes. To address this, we've developed a set of composable, extensible building blocks that provide stable abstractions across these concerns.
For a session at MVP Summit, we built ConferencePulse—an interactive conference assistant that demonstrates these technologies in action. The app runs live polls, answers audience questions in real time, generates insights from engagement data, and automatically summarizes the session when it concludes. It was built entirely with the technologies we were showcasing: Microsoft.Extensions.AI, Microsoft.Extensions.DataIngestion, Microsoft.Extensions.VectorData, Model Context Protocol (MCP), and Microsoft Agent Framework. This article walks through the application and explains how each building block fits together.
What We Built: ConferencePulse
ConferencePulse is a Blazor Server application designed for live conference sessions. Attendees scan a QR code to join a session and engage with the presenter through polls and Q&A. Behind the scenes, AI powers several key features:
- Live polls that are automatically generated based on the session's content. Attendees vote, and results update in real time.
- Audience Q&A where the AI answers questions using a RAG (Retrieval-Augmented Generation) pipeline that pulls from the session knowledge base, Microsoft Learn documentation, and GitHub wiki content.
- Auto-generated insights that surface patterns in poll results and audience questions as they come in.
- Session summary that runs when the presenter ends the session. Multiple AI agents analyze polls, questions, and insights concurrently, then merge their findings into a concise summary.
We wanted an interactive experience—not a static slide deck. We wanted to include polls and audience insights. And we wanted to automate preparation: point the app at a GitHub repository, and it downloads the markdown, processes it through a pipeline, and builds a searchable knowledge base. Polls, talking points, and Q&A answers all remain grounded in that content.
Architecture Overview
The app runs on .NET 10, Blazor Server, and Aspire. The solution is split into five projects:
src/
├── ConferenceAssistant.Web/ ← Blazor Server (UI + orchestration)
├── ConferenceAssistant.Core/ ← Models, interfaces, session state
├── ConferenceAssistant.Ingestion/ ← Data ingestion pipeline + vector search
├── ConferenceAssistant.Agents/ ← AI agents, workflows, tools
├── ConferenceAssistant.Mcp/ ← MCP server tools + MCP client
└── ConferenceAssistant.AppHost/ ← .NET Aspire (Qdrant, PostgreSQL, Azure OpenAI)
Each project relies on the composable building blocks described below.
Key Building Blocks
Microsoft.Extensions.AI: Unified AI Abstraction
Microsoft.Extensions.AI provides IChatClient, a unified interface that works with OpenAI, Azure OpenAI, Ollama, Foundry Local, and other providers. Every AI call in ConferencePulse—whether generating a poll, answering a Q&A query, or producing a summary—goes through this abstraction. This means you can switch AI backends without changing the rest of your code. The library also supports middleware for common tasks like retry logic, logging, and telemetry.
Microsoft.Extensions.DataIngestion: Pipeline Automation
Data ingestion is handled by Microsoft.Extensions.DataIngestion. When a presenter provides a GitHub repo URL, the ingestion pipeline downloads markdown files, splits them into chunks, and stores them in a vector database. The pipeline is composed of small, reusable steps—extraction, transformation, loading—that can be customized or replaced. This allowed us to easily integrate with Microsoft.Extensions.VectorData for embedding and indexing.
Microsoft.Extensions.VectorData: Semantic Search
For the Q&A feature, we use Microsoft.Extensions.VectorData to perform semantic search over the session knowledge base. The library provides a consistent API for working with vector stores like Qdrant (used here), Azure Cognitive Search, or others. When an attendee asks a question, the app retrieves relevant chunks from the vector store, then passes them to the AI model as context for generating an answer—a classic RAG pattern.
Model Context Protocol (MCP): Tool Integration
We exposed tools via the Model Context Protocol (MCP) so that AI agents can interact with session state, poll results, and the data pipeline. The ConferenceAssistant.Mcp project hosts an MCP server that registers tools like GetPollResults or FetchInsights. The MCP client in the agents project connects to this server, allowing agents to use these tools dynamically during conversations.
Microsoft Agent Framework: Orchestration
The session summary feature uses the Microsoft Agent Framework to coordinate multiple AI agents. Each agent specializes in a different aspect—polls, questions, insights—and works concurrently. The framework merges their outputs into a coherent summary. Agents communicate through structured messages and can call MCP tools as needed.
Real-Time Polls and Q&A
When a presenter starts a session, ConferencePulse automatically generates a set of polls based on the ingested knowledge base. It uses IChatClient to ask the AI model to propose poll questions and answer choices, then displays them to attendees. Votes are collected via Blazor Server's real-time SignalR connections and aggregated instantly.
For Q&A, the app uses a RAG pipeline: the attendee's question is embedded, a similarity search is performed against the vector store, and the top results are sent to the AI model along with the question. The model then generates a natural-language answer that cites the relevant sources. This ensures answers are grounded in the session material.
Automated Session Summary
When the presenter ends the session, the app triggers a multi-agent workflow via Microsoft Agent Framework. Three agents analyze poll data, Q&A transcripts, and real-time insights respectively. Each agent produces a report. A fourth agent merges these reports into a single summary, which is then saved to the session record. The entire process completes in under a minute, giving presenters an instant wrap-up document.
Conclusion
ConferencePulse demonstrates how .NET's composable AI stack simplifies building intelligent applications. By using stable abstractions for AI, data ingestion, vector search, and agent orchestration, we avoided vendor lock-in and reduced boilerplate. The same building blocks can power a wide range of scenarios—from interactive presentations to enterprise knowledge management. Check back for more details on each component in upcoming posts.