10 Key Insights from Building a .NET AI Conference Assistant with Composable AI Blocks

When you set out to inject AI into a .NET application, the road is often paved with mismatched SDKs, breaking updates, and the constant struggle to glue together models, vector stores, and agent frameworks from different ecosystems. That frustration inspired a set of composable, extensible building blocks that offer stable abstractions across the entire AI stack. Recently, we put those blocks to the test by building ConferencePulse — an interactive conference assistant for MVP Summit. This app runs live polls, answers audience questions in real time, generates insights from engagement data, and produces a session summary when the presenter wraps up. Everything was built using the very technologies we were there to present: Microsoft.Extensions.AI, Microsoft.Extensions.DataIngestion, Microsoft.Extensions.VectorData, Model Context Protocol (MCP), and Microsoft Agent Framework. Below are 10 essential things you need to know about how we made it all work together.

1. The Vision: Composable AI Building Blocks for .NET

The core idea is simple: provide a set of well-defined, interchangeable components that handle the most common AI tasks — calling language models, ingesting data, storing vectors, and orchestrating agents — without locking you into a single vendor. By standardizing the interfaces (like IChatClient), we eliminate the pain of switching providers or dealing with breaking changes. This means you can start with OpenAI, move to Azure OpenAI, or test locally with Ollama, all without rewriting your business logic. The building blocks are designed to be composed together, allowing you to create powerful AI pipelines that are both flexible and maintainable.

2. ConferencePulse: A Real-World Test of the Stack

ConferencePulse is a Blazor Server app that runs during live conference sessions. Attendees scan a QR code to join, then interact through polls and Q&A. On the backend, AI powers everything from generating polls based on session content to answering questions using a RAG pipeline, surfacing real-time insights, and producing a post-session summary. The app uses .NET 10, Blazor Server, and Aspire for orchestration. Its five projects — Web, Core, Ingestion, Agents, and MCP — each demonstrate a different piece of the composable stack. This real-world scenario proves that these abstractions work together smoothly in production-like conditions.

3. Architecture: Blazor Server + Aspire + Five Modular Projects

The solution is organized into five projects under a single src/ folder. ConferenceAssistant.Web is the Blazor Server front-end that handles UI and orchestration. ConferenceAssistant.Core holds models, interfaces, and session state. ConferenceAssistant.Ingestion runs the data ingestion pipeline and vector search. ConferenceAssistant.Agents implements AI agents, workflows, and tools. ConferenceAssistant.Mcp exposes MCP server tools and a client. All are wired together by ConferenceAssistant.AppHost using .NET Aspire, which manages services like Qdrant (vector database), PostgreSQL, and Azure OpenAI. This modular structure makes each concern independent and testable, while Aspire simplifies configuration and deployment.

4. Microsoft.Extensions.AI: One Interface to Rule Them All

At the heart of every AI call is IChatClient, a unified abstraction that works with OpenAI, Azure OpenAI, Ollama, Foundry Local, and many other providers. This eliminates the need to learn separate client libraries or handle different error patterns. In ConferencePulse, we use IChatClient for generating poll questions, answering audience queries, and summarizing sessions. Swapping the underlying model is as simple as changing a configuration value. This abstraction also supports streaming, function calling, and tool use, making it fully capable for complex scenarios.

5. RAG Pipeline: Microsoft.Extensions.DataIngestion + VectorData

To ground answers in session content, we built a RAG pipeline using Microsoft.Extensions.DataIngestion for loading documents and Microsoft.Extensions.VectorData for storing and searching embeddings. The pipeline ingests markdown from a GitHub repo (talking points, docs, wikis), chunks them, computes embeddings, and stores them in Qdrant. When an attendee asks a question, we retrieve the most relevant chunks, feed them as context to the LLM, and get an answer sourced from the knowledge base. This approach ensures answers are accurate and up-to-date, and the pipeline is fully customizable.

6. Live Polls: AI-Generated Questions Based on Session Content

One of the most engaging features is the live poll system. Before the session, the presenter points the app at a GitHub repo containing their content. The ingestion pipeline processes the documents, and the AI generates poll questions based on key topics. During the session, attendees vote in real time, and results appear instantly. The polling logic uses IChatClient with a carefully crafted prompt that asks the model to create multiple-choice questions grounded in the ingested material. This automation saves hours of manual preparation and makes each session dynamic.

7. Audience Q&A: Real-Time Answers Powered by RAG

Attendees can submit questions through the app at any time. The Q&A system uses the same RAG pipeline described earlier: it retrieves relevant document chunks from Qdrant, then sends them alongside the question to the LLM. The answer is displayed in the UI, often within seconds. We also added a feedback mechanism (thumbs up/down) to improve future answers. The RAG pipeline pulls from multiple sources — session knowledge base, Microsoft Learn docs, and GitHub wiki content — ensuring broad coverage. This feature turns the app into an interactive assistant that never gets tired.

8. Auto-Generated Insights: Surfacing Patterns in Engagement Data

As polls and questions roll in, the background agent runs analytics to detect patterns. For example, if many attendees ask similar questions, the agent highlights that topic. If poll results show a clear preference, the presenter can pivot the discussion accordingly. These insights are generated asynchronously using the Microsoft Agent Framework, which orchestrates multiple agents that process the stream of engagement data. The presenter sees a dashboard of real-time trends, making the session more responsive to audience needs.

9. Session Summary: Multi-Agent Collaboration for a Cohesive Recap

When the presenter ends the session, the app automatically generates a summary. This involves multiple AI agents working concurrently: one analyzes poll results, another digs into question patterns, a third looks at engagement metrics, and a final agent merges their findings into a cohesive report. The agents communicate through the Microsoft Agent Framework, sharing intermediate outputs and resolving conflicts. The result is a comprehensive recap that includes key insights, sentiment trends, and suggestions for follow-up. This summary can be pushed to the session page or emailed to attendees.

10. MCP Integration: Extending the App with Model Context Protocol

The Model Context Protocol (MCP) is used to expose certain app capabilities as standardized tools that large language models can call. In ConferencePulse, we created MCP server endpoints for actions like retrieving session metadata, fetching poll results, and triggering the summary generation. The MCP client then connects to these tools from the agent workflows. This decoupling allows the agents to interact with the app without tight coupling, and it makes it easy to add new tools or integrate with external MCP servers in the future.

Conclusion: Building ConferencePulse demonstrated that the composable AI stack for .NET is not just a theoretical concept — it works in practice. By abstracting away provider differences, standardizing data ingestion and vector storage, and enabling multi-agent orchestration with MCP, we created a conference assistant that is both powerful and adaptable. The same building blocks can be used for countless other applications, from customer support bots to internal knowledge bases. The key takeaway: with the right abstractions, you can focus on your application’s unique logic rather than wrestling with AI plumbing.