Artificial Intelligence and Agents in .NET

Design applications with Microsoft Extensions AI to stay model-agnostic, avoiding hard dependencies on a single AI, so you can switch from OpenAI to cloud or Gemini without rewriting business logic.

Design systems with provider abstraction to decouple AI models from specific providers using Microsoft Extensions AI, enabling seamless provider switches and consistent interactions across OpenAI, Anthropic, and Google.

Centralize iChatClient creation with dependency injection in a console app using Microsoft.Extensions.Hosting and NuGet, configuring services to select OpenAI, Anthropic, or Cloud providers and models via command-line arguments.

Create a middleware for iChatClient in .NET to intercept prompts before and after sending them to the model, enabling visibility into messages and an optional cache layer within the pipeline.

Use chat options to centralize model behavior in .NET, set max output tokens, and distinguish input from output tokens. Adjust temperature to 0.7 for OpenAI and cloud models.

Explore the Microsoft Extensions AI library to create abstractions for AI models from providers, like OpenAI, and expose a client interface for sending messages to LLM and receiving responses.

Discover tooling to let ai perform actions, like querying databases and sending emails, beyond answering questions. Learn to invoke multiple functions in sequence, handle user confirmations, and reduce errors.

Expose a weather fetch function to the AI model, using a fake weather service and getWeather tool, with function invocation enabled for city queries like santo domingo and madrid.

Demonstrates how a prompt makes an AI call multiple tools in sequence, using a weather-evaluation service and AIFunctionFactory to assess conditions and guide outdoor decisions.

Define a special tool that requires user approval before actions like sending emails. Implement an approval flow in a .NET chatbot with fake email services and actionable tool descriptions.

Master how to handle tool errors in a chatbot by reading exception messages and proposing fixes to retry tool invocations.

Explore tooling and tool calling, where an ai model invokes user-defined functions with parameters, uses results to proceed, and applies human-in-the-loop oversight and error handling for exceptions.

Migrate the chatbot to a Blazor web app, enable consecutive tools with human intervention, add a data query tool, and support canceling during AI responses.

Add a tools class to the Blazor application and configure the chat client to use tools, fetching weather API key via IConfiguration and environment variables, then test Santo Domingo weather.

Install Entity Framework Core with SQLite, define a person entity and dbContext, seed data, apply migrations, and build a getAll service to query the people table.

Add a typing indicator with three animated dots when the AI chat text is empty, signaling thinking with CSS in the chat component.

Implement cancellation of a running AI prompt in .NET using a cancellation token source, link tokens, and catch and finally blocks to safely handle operation cancelled exception.

Migrate the chatbot to the web, tackle front-end and back-end synchronization, enable operation cancellation, and offer a chat service with database access, plus an iChat client factory for AI models.

Understand how retrieval augmented generation (rach) enables llms to fetch up-to-date information from data sources, reducing hallucinations by providing relevant context through embeddings and retrieved fragments.

Explore how embeddings convert words into real-valued vectors that capture semantic relationships. Store chunked documents as embeddings in a vector database and retrieve nearest matches by vector similarity.

Store embeddings in vector databases to enable semantic search by retrieving vectors closest in multidimensional space, while indexing metadata such as source, date, author, and tags for LLM responses.

Build a chatbot with a rack service to retrieve relevant context from internal documents, generate embeddings, and feed the AI with document-based context.

Implement a real RAG pipeline by uploading markdown files to Azure AI Search as a cloud vector database, storing embeddings and fragments for semantic search.

Implement a semantic search workflow in Azure using the Azure Search rack service, embedding generation, and vector search to retrieve and rank relevant documents from a vector database.

Display source documents for chatbot answers by updating the chat UI to show cited files, add a RAC search result DTO with document title and text, and render clickable citations.

Explore retrieval augmented generation (RAG) that blends information retrieval with generative models to answer using external data, leveraging embeddings and vector databases for fast semantic searches and JSON-style responses.

Explore the model context protocol (MCP) to enable LLMs to invoke code and access tools across servers, allowing any AI model to interact with your tools.

Explore the model context protocol, MCP, which standardizes structured context, tools, resources, and prompts to let AI models query data sources and interact with external services outside prompts.

Create a functional MCP server with Espritonet Core in .NET, configure http transport, enable stateless mode, allow-any-origin policy, map the MCP endpoint, and test connectivity with the model-context-protocol inspector.

Add prompts to the MCP server by creating a prompts class and exposing four prompts: get all, get by ID, activate, and deactivate, then verify in the MCP inspector.

Expose resources to share static data and internal documents via the mcp server, then define a documents resource with a uri and read its contents.

Publish the MCP server to production by adding an api controller with a get all endpoint and enabling controllers. Test by updating Gloria's status via the MCP inspector.

Test the MCP server with a ChatGPT app, enabling developer mode and creating a demo app at the MCP endpoint to query and activate records, demonstrating read and write access.

Explore how the model context protocol enables AI to interact with external systems by defining tools, data, and prompts, separating AI logic from integrations.

Explore local models, learn to use OLAMA to manage them, download and run local models, and integrate these models into applications.

Explore how local models run on your own hardware, offering privacy, control, and potential cost savings, while noting hardware demands, performance gaps, and the technical complexity of setup.

Install olama to run artificial intelligence models locally on your PC without internet or external APIs. Use PowerShell on Windows or download executable to manage models with a common interface.

Integrate Olama in a console app by installing the Olama sharp NuGet package, configuring the Olama API client with a model, and testing with a weather service and capital questions.

Integrate a local Olama model into a Blazor AI project by installing Olamasharp, configuring models via user secrets, and wiring the chat client to the Olama endpoint.

Implement RAG with Ollama by switching the embedding generator from OpenAI to the Ollama API client, updating the embedding dimension to 1024, and reindexing Azure search indexes.

Learn how local models run on user hardware to boost privacy and data control, managing memory, storage, and performance via OLAMA for downloading and running open-source models.

Learn to build an ai-powered web api and embed a chatbot for an independent front-end. Explore front-end options like JavaScript in an MVC view, Angular, React, Blazor, and more.

Build an mvc application with separate front-end and back-end, enabling AI interactions via Angular, React, or Blazor, and support multiple conversations with separate context.

Build an esprit online core mvc application with a web api controller and a JavaScript front end, using OpenAI and individual accounts to preserve each user's AI message history.

Create a SendMessageDTO with conversationId and text and an API endpoint to send messages to the AI, returning the response. Use vanilla JavaScript to post prompts and update chat UI.

Enable loading existing conversations and managing multiple chats by introducing a conversation dto and a get-by-id endpoint, then fetch, render, and mark active conversations with histories.

Implement a delete conversation endpoint in a .NET chat controller using post, returning affected rows with 404 or 204, and update the UI to reselect or recreate a chat.

Replicate the first user message as the conversation title, replacing the default new chat label. If the first message is under 60 characters, use it; otherwise trim and add ellipsis.

Learn to implement streaming in .NET by sending text and events with a stream event protocol, enabling real-time delta updates and tool approval handling.

Implement operation cancellation in a .NET AI agent using a cancellation token and an abort controller. Update the UI to disable the send button and enable cancel during processing.

Implement human-in-the-loop tool approvals by introducing a ChatApprovalRequest entity with statuses pending, approved, rejected, completed; persist and map approvals to a pending approval dto for the front end.

Explore back-end development for a human-in-the-loop tool by implementing endpoints to fetch pending approvals, resolve approval requests via DTOs, update status, and feed results to the frontend and AI model.

Implement a front-end flow for human-in-the-loop approvals using vanilla javascript, including addApprovalRequestApproval, pending approval handling, and approve or reject actions, with API-driven resolution and UI updates.

Store chat messages and pending approval requests in a database to maintain full interaction history, support multiple concurrent conversations, and resume any conversation exactly where you left off.