Microsoft.Extensions.AI<\/code>, Microsoft.Extensions.DataIngestion<\/code>, Microsoft.Extensions.VectorData<\/code>, Model Context Protocol (MCP), and Microsoft Agent Framework.<\/p>\nThis post walks through the app and shows how each building block fits.<\/p>\n
What we built<\/h2>\n
ConferencePulse is a Blazor Server app for live conference sessions. Attendees scan a QR code, join the session, and interact with the presenter through polls and Q&A. On the backend, AI powers several features:<\/p>\n
\n- Live polls<\/strong> that the AI generates based on session content. Attendees vote and results appear in real time.<\/li>\n
- Audience Q&A<\/strong> where AI answers questions using a RAG pipeline that pulls from the session knowledge base, Microsoft Learn docs, and GitHub wiki content.<\/li>\n
- Auto-generated insights<\/strong> that surface patterns in poll results and audience questions as they come in.<\/li>\n
- Session summary<\/strong> that runs when the presenter ends the session. Multiple AI agents analyze polls, questions, and insights concurrently, then merge their findings.<\/li>\n<\/ul>\n
![\"ConferencePulse](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2026\/04\/ai-assistant-presenter-view-scaled.webp\")
<\/p>\n
We wanted an interactive session, not a slide deck. We wanted polls and audience insights. And we wanted to automate the preparation: point the app at a GitHub repo, and it downloads the markdown, processes it through a pipeline, and builds a searchable knowledge base. Polls, talking points, and Q&A answers are all grounded in that content.<\/p>\n
The app runs on .NET 10, Blazor Server, and Aspire. Five projects cover the stack:<\/p>\n
src\/\r\n\u251c\u2500\u2500 ConferenceAssistant.Web\/ \u2190 Blazor Server (UI + orchestration)\r\n\u251c\u2500\u2500 ConferenceAssistant.Core\/ \u2190 Models, interfaces, session state\r\n\u251c\u2500\u2500 ConferenceAssistant.Ingestion\/ \u2190 Data ingestion pipeline + vector search\r\n\u251c\u2500\u2500 ConferenceAssistant.Agents\/ \u2190 AI agents, workflows, tools\r\n\u251c\u2500\u2500 ConferenceAssistant.Mcp\/ \u2190 MCP server tools + MCP client\r\n\u2514\u2500\u2500 ConferenceAssistant.AppHost\/ \u2190 .NET Aspire (Qdrant, PostgreSQL, Azure OpenAI)<\/code><\/pre>\nNow let\u2019s walk through the building blocks.<\/p>\n
Microsoft.Extensions.AI: one interface, any provider<\/h2>\n
Microsoft.Extensions.AI<\/code> gives you IChatClient<\/code>, a unified abstraction that works with OpenAI, Azure OpenAI, Ollama, Foundry Local, and other providers. Every AI call in ConferencePulse goes through a single middleware pipeline.<\/p>\nvar openaiBuilder = builder.AddAzureOpenAIClient(\"openai\");\r\n\r\nopenaiBuilder.AddChatClient(\"chat\")\r\n .UseFunctionInvocation()\r\n .UseOpenTelemetry()\r\n .UseLogging();\r\n\r\nopenaiBuilder.AddEmbeddingGenerator(\"embedding\");<\/code><\/pre>\nThat\u2019s it. Six lines. If you\u2019ve worked with ASP.NET Core middleware, this pattern will feel familiar. Each .Use*()<\/code> call wraps the inner client with additional behavior. UseFunctionInvocation()<\/code> handles tool-call loops. UseOpenTelemetry()<\/code> traces every call. UseLogging()<\/code> captures request\/response pairs.<\/p>\nWant to swap Azure OpenAI for Ollama? Change the inner client. The middleware stays the same.<\/p>\n
This matters because IChatClient<\/code> shows up everywhere in the app. Poll generation, Q&A, insights, ingestion enrichment, and multi-agent workflows all share this pipeline. You register it once and use it throughout.<\/p>\nDataIngestion + VectorData: the knowledge layer<\/h2>\n
AI models need context to give useful answers. Microsoft.Extensions.DataIngestion<\/code> provides a pipeline for processing documents into searchable chunks. Microsoft.Extensions.VectorData<\/code> provides a provider-agnostic abstraction over vector stores.<\/p>\nWhen ConferencePulse imports content from a GitHub repo, it runs the files through an ingestion pipeline:<\/p>\n
IngestionDocumentReader reader = new MarkdownReader();\r\n\r\nvar tokenizer = TiktokenTokenizer.CreateForModel(\"gpt-4o\");\r\nvar chunkerOptions = new IngestionChunkerOptions(tokenizer)\r\n{\r\n MaxTokensPerChunk = 500,\r\n OverlapTokens = 50\r\n};\r\nIngestionChunker<string> chunker = new HeaderChunker(chunkerOptions);\r\n\r\nvar enricherOptions = new EnricherOptions(_chatClient) { LoggerFactory = _loggerFactory };\r\n\r\nusing var writer = new VectorStoreWriter<string>(\r\n _searchService.VectorStore,\r\n dimensionCount: 1536,\r\n new VectorStoreWriterOptions\r\n {\r\n CollectionName = \"conference_knowledge\",\r\n IncrementalIngestion = true\r\n });\r\n\r\nusing IngestionPipeline<string> pipeline = new(\r\n reader, chunker, writer, new IngestionPipelineOptions(), _loggerFactory)\r\n{\r\n ChunkProcessors =\r\n {\r\n new SummaryEnricher(enricherOptions),\r\n new KeywordEnricher(enricherOptions, ReadOnlySpan<string>.Empty),\r\n frontMatterProcessor\r\n }\r\n};<\/code><\/pre>\nThe pipeline reads markdown, chunks it by headers, enriches each chunk with AI-generated summaries and keywords, then embeds and stores the results in Qdrant. Each step is a pluggable component. You can swap MarkdownReader<\/code> for a PDF reader, HeaderChunker<\/code> for a fixed-size chunker, or Qdrant for Azure AI Search. The pipeline composition stays the same.<\/p>\nNotice that SummaryEnricher<\/code> and KeywordEnricher<\/code> both take EnricherOptions(_chatClient)<\/code>. They use the same IChatClient<\/code> from the previous section. AI enriching its own context. The summary enricher generates a concise description of each chunk, and the keyword enricher extracts searchable terms. Both improve retrieval quality later.<\/p>\nOn the query side, Microsoft.Extensions.VectorData<\/code> gives you VectorStoreCollection<\/code> for semantic search over any backend:<\/p>\nvar results = collection.SearchAsync(query, topK);\r\n\r\nawait foreach (var result in results)\r\n{\r\n var content = result.Record[\"content\"] as string;\r\n \/\/ Use the content...\r\n}<\/code><\/pre>\nSimilar to how you can swap database providers in EF Core, you can swap vector store providers here. Qdrant today, Azure AI Search tomorrow. Same API.<\/p>\n
ConferencePulse also ingests data in real time as the session progresses. Poll responses, audience questions, Q&A pairs, and AI-generated insights all go into the knowledge base:<\/p>\n
public async Task<int> IngestResponseAsync(\r\n string pollId, string topicId, string question,\r\n Dictionary<string, int> results, List<string>? otherResponses = null)\r\n{\r\n var sb = new StringBuilder();\r\n sb.AppendLine($\"Poll: {question}\");\r\n sb.AppendLine(\"Results:\");\r\n var total = results.Values.Sum();\r\n foreach (var (option, count) in results)\r\n {\r\n var percentage = total > 0 ? (count * 100.0 \/ total).ToString(\"F1\") : \"0\";\r\n sb.AppendLine($\" - {option}: {count} votes ({percentage}%)\");\r\n }\r\n\r\n await _searchService.UpsertAsync(sb.ToString(), source: \"response\", documentId: $\"response-{pollId}\");\r\n return 1;\r\n}<\/code><\/pre>\nBy the end of a session, the knowledge base contains the original imported content, every poll result, every audience question, and every AI-generated insight.<\/p>\n
![\"AI](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2026\/04\/ai-assistant-insights.webp\")
<\/p>\n
IChatClient with tools: choosing the right level of complexity<\/h2>\n
One of the design principles we followed: use the simplest approach that gets the job done. IChatClient<\/code> with tools handles a lot of scenarios before you need a dedicated agent framework. At the same time, when orchestration gets complex, a framework earns its place. The key is choosing the right tool.<\/p>\nConferencePulse has three AI-powered features at different levels of complexity. All three use the same IChatClient<\/code>.<\/p>\nInsight generation: a single call<\/h3>\n
When a poll closes, ConferencePulse generates an insight. The implementation is a single GetResponseAsync<\/code> call:<\/p>\nvar response = await chatClient.GetResponseAsync(\r\n[\r\n new(ChatRole.System,\r\n \"You are a conference analytics assistant generating real-time insights from audience data.\"),\r\n new(ChatRole.User, prompt) \/\/ prompt contains the poll results\r\n]);\r\n\r\nvar content = response.Text?.Trim();\r\nif (!string.IsNullOrWhiteSpace(content))\r\n{\r\n ctx.AddInsight(new Insight\r\n {\r\n TopicId = poll.TopicId,\r\n PollId = pollId,\r\n Content = content,\r\n Type = InsightType.PollAnalysis\r\n });\r\n}<\/code><\/pre>\nNo tools, no framework. A prompt with poll results as context, and the middleware pipeline handles telemetry and logging.<\/p>\n
Poll generation: IChatClient with tools<\/h3>\n
Generating a poll needs more context. The AI checks the current topic, looks at what\u2019s been covered, and creates something relevant. That means tools:<\/p>\n
public class PollGenerationWorkflow(IChatClient chatClient, AgentTools tools)\r\n{\r\n public async Task<string> ExecuteAsync(string topicId)\r\n {\r\n var options = new ChatOptions\r\n {\r\n Tools = [tools.GetCurrentTopic, tools.SearchKnowledge,\r\n tools.GetAudienceQuestions, tools.GetAllPollResults,\r\n tools.GetAllInsights, tools.CreatePoll]\r\n };\r\n\r\n var messages = new List<ChatMessage>\r\n {\r\n new(ChatRole.System, AgentDefinitions.SurveyArchitectInstructions),\r\n new(ChatRole.User, $\"Generate an engaging poll for topic: {topicId}...\")\r\n };\r\n\r\n var response = await chatClient.GetResponseAsync(messages, options);\r\n return response.Text ?? \"Unable to generate poll.\";\r\n }\r\n}<\/code><\/pre>\nEach tool is a strongly-typed AITool<\/code> property created from a C# method:<\/p>\npublic class AgentTools\r\n{\r\n public AITool SearchKnowledge { get; }\r\n public AITool GetCurrentTopic { get; }\r\n public AITool CreatePoll { get; }\r\n \/\/ ...\r\n\r\n public AgentTools(IPollService pollService, ISemanticSearchService searchService, ...)\r\n {\r\n SearchKnowledge = AIFunctionFactory.Create(SearchKnowledgeCore,\r\n new AIFunctionFactoryOptions\r\n {\r\n Name = nameof(SearchKnowledge),\r\n Description = \"Search the session knowledge base for content related to the query\"\r\n });\r\n \/\/ ...\r\n }\r\n}<\/code><\/pre>\nThe model decides it needs context, calls GetCurrentTopic<\/code> and SearchKnowledge<\/code>, then generates a poll and calls CreatePoll<\/code> to save it. The UseFunctionInvocation()<\/code> middleware handles the tool loop automatically.<\/p>\n![\"AI](\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\")
<\/p>\n
Q&A answering: RAG across multiple sources<\/h3>\n
The Q&A service brings multiple building blocks together. When an audience member asks a question, the app searches the local knowledge base, queries Microsoft Learn docs via MCP, and asks DeepWiki about relevant GitHub repos via MCP. Then it synthesizes an answer:<\/p>\n
\/\/ 1. Search local knowledge base\r\nvar searchResults = await searchService.SearchAsync(questionText, topK: 5);\r\nvar localContext = string.Join(\"nn---nn\",\r\n searchResults.Select(r => r.Content).Where(c => !string.IsNullOrWhiteSpace(c)));\r\n\r\n\/\/ 2. Search Microsoft Learn for documentation context (via MCP)\r\nvar docsContext = await mcpClient.SearchDocsAsync(questionText);\r\n\r\n\/\/ 3. Ask DeepWiki about relevant .NET repos (via MCP)\r\nvar deepWikiContext = await mcpClient.AskDeepWikiAsync(\"dotnet\/extensions\", questionText);<\/code><\/pre>\nVectorData for local search, MCP for external context, IChatClient<\/code> for generation.<\/p>\n<\/p>\n
<\/p>\n
Now let\u2019s look at how MCP works.<\/p>\n
MCP: consuming and providing context<\/h2>\n
Model Context Protocol is a standard for AI applications to discover and use external tools and context. Similar to how HTTP lets any client talk to any server, MCP lets any AI app connect to any context provider using the same protocol.<\/p>\n
ConferencePulse uses MCP in both directions.<\/p>\n
As a consumer<\/h3>\n
The McpContentClient<\/code> connects to two MCP servers at startup: Microsoft Learn and DeepWiki.<\/p>\npublic async Task InitializeAsync(CancellationToken ct = default)\r\n{\r\n var learnTransport = new HttpClientTransport(new HttpClientTransportOptions\r\n {\r\n Endpoint = new Uri(\"https:\/\/learn.microsoft.com\/api\/mcp\"),\r\n TransportMode = HttpTransportMode.StreamableHttp\r\n }, loggerFactory);\r\n _learnClient = await McpClient.CreateAsync(learnTransport, null, loggerFactory, ct);\r\n\r\n var deepWikiTransport = new HttpClientTransport(new HttpClientTransportOptions\r\n {\r\n Endpoint = new Uri(\"https:\/\/mcp.deepwiki.com\/mcp\"),\r\n TransportMode = HttpTransportMode.StreamableHttp\r\n }, loggerFactory);\r\n _deepWikiClient = await McpClient.CreateAsync(deepWikiTransport, null, loggerFactory, ct);\r\n}<\/code><\/pre>\nOnce connected, calling a tool on any MCP server uses the same pattern:<\/p>\n
var result = await _learnClient.CallToolAsync(\r\n \"microsoft_docs_search\",\r\n new Dictionary<string, object?> { [\"query\"] = query },\r\n cancellationToken: ct);<\/code><\/pre>\nAny server that speaks MCP works with this client code.<\/p>\n
As a provider<\/h3>\n
ConferencePulse is also an MCP server. Any MCP-compatible client (GitHub Copilot, Claude, a custom tool) can connect and query session data.<\/p>\n
[McpServerToolType]\r\npublic class ConferenceTools\r\n{\r\n [McpServerTool(Name = \"get_session_status\", ReadOnly = true),\r\n Description(\"Returns the current conference session status.\")]\r\n public static string GetSessionStatus(ISessionService sessionService)\r\n {\r\n var session = sessionService.CurrentSession;\r\n if (session is null) return \"No active conference session.\";\r\n \/\/ ... build status string\r\n }\r\n\r\n [McpServerTool(Name = \"search_session_knowledge\", ReadOnly = true),\r\n Description(\"Searches the session knowledge base for relevant content.\")]\r\n public static async Task<string> SearchSessionKnowledge(\r\n ISemanticSearchService searchService,\r\n [Description(\"The search query.\")] string query,\r\n [Description(\"Max results. Defaults to 5.\")] int maxResults = 5)\r\n {\r\n var results = await searchService.SearchAsync(query, maxResults);\r\n \/\/ ... format results\r\n }\r\n}<\/code><\/pre>\nRegistration takes a few lines in Program.cs<\/code>:<\/p>\nbuilder.Services\r\n .AddMcpServer(options => { options.ServerInfo = new() { Name = \"ConferencePulse\", Version = \"1.0.0\" }; })\r\n .WithToolsFromAssembly(typeof(ConferenceTools).Assembly)\r\n .WithHttpTransport();\r\n\r\napp.MapMcp(\"\/mcp\");<\/code><\/pre>\nThe app consumes external knowledge to answer questions and provides its own data for external tools. Same protocol in both directions.<\/p>\n
Microsoft Agent Framework: multi-agent orchestration<\/h2>\n
For most of ConferencePulse\u2019s features, IChatClient<\/code> with tools was the right choice. But the session summary needed something more: three specialized agents running concurrently, each with scoped tools, feeding their results into a synthesis step. That\u2019s where Microsoft Agent Framework comes in.<\/p>\npublic class SessionSummaryWorkflow(IChatClient chatClient, AgentTools tools)\r\n{\r\n public async Task<string> ExecuteAsync()\r\n {\r\n ChatClientAgent pollAnalyst = new(chatClient,\r\n name: \"PollAnalyst\",\r\n description: \"Analyzes poll results and trends\",\r\n instructions: \"You are a poll analyst. Use GetAllPollResults to retrieve every poll...\",\r\n tools: [tools.GetAllPollResults]);\r\n\r\n ChatClientAgent questionAnalyst = new(chatClient,\r\n name: \"QuestionAnalyst\",\r\n description: \"Analyzes audience questions and themes\",\r\n instructions: \"You are an audience question analyst...\",\r\n tools: [tools.GetAudienceQuestions]);\r\n\r\n ChatClientAgent insightAnalyst = new(chatClient,\r\n name: \"InsightAnalyst\",\r\n description: \"Analyzes generated insights and knowledge patterns\",\r\n instructions: \"You are an insight analyst...\",\r\n tools: [tools.GetAllInsights, tools.SearchKnowledge]);<\/code><\/pre>\nEach ChatClientAgent<\/code> wraps the same IChatClient<\/code>. The agents get scoped tools (PollAnalyst only sees poll data, QuestionAnalyst only sees questions) and specialized instructions.<\/p>\nThe orchestration uses AgentWorkflowBuilder.BuildConcurrent<\/code> for the fan-out, then WorkflowBuilder<\/code> to compose the full pipeline:<\/p>\n \/\/ Fan-out: three analysts run concurrently\r\n var analysisWorkflow = AgentWorkflowBuilder.BuildConcurrent(\r\n [pollAnalyst, questionAnalyst, insightAnalyst],\r\n MergeAgentOutputs);\r\n\r\n \/\/ Fan-in: synthesizer merges all findings\r\n ChatClientAgent synthesizer = new(chatClient,\r\n name: \"Synthesizer\",\r\n instructions: \"Synthesize the analyses into one cohesive session summary...\");\r\n\r\n \/\/ Compose: concurrent analysis \u2192 sequential synthesis\r\n var analysisExec = new SubworkflowBinding(analysisWorkflow, \"Analysis\");\r\n ExecutorBinding synthExec = synthesizer;\r\n\r\n var composedWorkflow = new WorkflowBuilder(analysisExec)\r\n .WithName(\"SessionSummaryPipeline\")\r\n .BindExecutor(synthExec)\r\n .AddEdge(analysisExec, synthExec)\r\n .WithOutputFrom([synthExec])\r\n .Build();\r\n\r\n var run = await InProcessExecution.Default.RunAsync(\r\n composedWorkflow,\r\n \"Analyze the conference session data and provide your specialized findings.\");<\/code><\/pre>\nCompare this with the poll generation workflow from earlier, which is about 10 lines using IChatClient<\/code> and tools. The session summary is about 40 lines because it genuinely needs concurrent agents with scoped tools and a synthesis step.<\/p>\nIn ConferencePulse, the Agent Framework was the right choice for exactly one workflow. Everything else worked well with IChatClient<\/code> directly. Both approaches use the same underlying abstraction.<\/p>\nHow the building blocks fit together<\/h2>\n
<\/p>\n
During the MVP Summit session, attendees interacted with features powered by different layers of the stack:<\/p>\n
![\"AI](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2026\/04\/ai-assistant-poll-room-view-scaled.webp\")
<\/p>\n![\"AI](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2026\/04\/ai-assistant-qa.webp\")
<\/p>\n![\"Aspire](\"https:\/\/devblogs.microsoft.com\/dotnet\/wp-content\/uploads\/sites\/10\/2026\/04\/ai-assistant-aspire-dashboard-scaled.webp\")
<\/p>\n