
Understand the topics covered in this foundational section.
Understand what large language models are and how they are used in applications.
Distinguish generative AI from broader AI concepts and understand common usage patterns.
Explain Semantic Kernel as an orchestration layer for AI-enabled applications.
Understand abstraction, extensibility, portability, and structured orchestration benefits.
Understand the difference between SDK-level orchestration and fuller agentic orchestration, and why this course centers Semantic Kernel.
Understand what AI agents are and where they fit in modern business solutions.
Reinforce the relationship between LLMs, generative AI, Semantic Kernel, and agents.
Understand the development tools, dependencies, and project structure.
Set up the required SDKs, IDE support, and local tooling.
Understand what Azure resources are needed and how model deployments fit into the solution.
Build the initial .NET 10 solution structure that will evolve through the course.
Store endpoints, keys, and environment settings securely.
Confirm the baseline environment is ready for development.
Understand what the kernel is and how it fits inside the app.
Explain the kernel as the central orchestrator in Semantic Kernel.
Install and reference the core packages correctly.
Connect the project to Azure OpenAI through Semantic Kernel.
Send a prompt, receive a response, and understand the execution flow.
Maintain short conversational context correctly.
Move from one-off code to maintainable application architecture.
Confirm the baseline environment is ready for development.
Understand how plugins and prompts extend the capabilities of a kernel.
Understand what a plugin is and how the kernel invokes plugin functionality.
Learn how to use built-in plugin features, such as time and summarization.
Learn how to write application-grade prompts instead of ad hoc chat prompts.
Shape assistant tone, domain behavior, and response constraints.
Organize prompt behavior into a reusable semantic plugin.
Confirm the learner can create and organize prompt-based plugins effectively.
Understand how plugins extend AI behavior.
Learn what makes a function usable by the model and by the kernel.
Create a plugin that exposes business logic to the kernel.
Make plugin methods easier for the model to choose and call correctly.
Blend instructions and executable functions in one flow.
Enable the kernel to choose and invoke registered functions automatically.
Understand when logic should live in prompts, functions, or application code.
Confirm the learner can build and register useful plugins.
Understand how the console logic moves into a web app.
Move kernel configuration into the ASP.NET Core composition root.
Separate kernel orchestration from controllers and UI code.
Introduce a business-facing area where users can interact with managed content.
Add another business context where AI assistance can provide value.
Add a contextual assistant panel to the website.
Understand what makes an embedded copilot context-aware and useful.
Store user and assistant interactions per portal context.
Rehydrate prior conversations for follow-up questions.
Confirm the assistant now works inside ASP.NET Core.
Allow users to submit PDFs into the application workflow.
Pull machine-readable text from uploaded documents.
Process image-based PDFs that do not already contain readable text.
Move from raw PDF text extraction into structured ingestion.
Understand chunking, embeddings, retrieval, and grounded response generation.
Convert extracted document text into retrieval-ready chunks.
Build the knowledge layer behind the copilot.
Select the right document context at runtime.
Improve factuality and business relevance in responses.
Increase trust and traceability for end users.
Confirm the portal now supports contextual, document-aware, grounded assistance.
Build practical AI-powered .NET applications using Microsoft Semantic Kernel, Azure OpenAI, plugins, agents, ASP.NET Core, and retrieval-augmented generation.
Semantic Kernel is Microsoft’s open-source SDK for integrating large language models into real applications. In this course, you will learn how to use Semantic Kernel in C# and .NET to build intelligent application features that can chat, call functions, use plugins, maintain context, process documents, and retrieve grounded answers from your own data.
This is not just a prompt engineering course. You will build a practical AI-enabled business portal using .NET, ASP.NET Core, Azure OpenAI, Semantic Kernel, plugins, chat history, document processing, embeddings, and RAG.
You will start with the fundamentals of generative AI, large language models, and Semantic Kernel. From there, you will configure your .NET development environment, connect to Azure OpenAI, and build your first Semantic Kernel chat flow. You will then refactor your code into reusable services that can be used inside real ASP.NET Core applications.
As the course progresses, you will create prompt-based plugins, native C# plugins, and business functions that Semantic Kernel can invoke automatically. You will learn how plugins help expose existing application logic to AI workflows and how function invocation allows your application to move beyond simple chat responses.
You will then build a context-aware assistant inside an ASP.NET Core application. This assistant will work with portal data, user context, chat history, and persistent conversations. You will also add document upload and processing features, prepare document chunks, generate embeddings, retrieve relevant knowledge, and ground AI responses using retrieval-augmented generation.
By the end of the course, you will understand how Semantic Kernel fits into modern AI application development and how it compares with Microsoft’s broader agent ecosystem. You will also have hands-on experience building AI features that are useful in real business applications.
What you will learn
Build AI-powered .NET applications using Semantic Kernel
Connect the Semantic Kernel to Azure OpenAI chat completion services
Use Semantic Kernel in C# and ASP.NET Core applications
Create prompt-based plugins and native C# plugins
Use automatic function invocation to connect AI prompts to application logic
Build context-aware chat assistants for business portals
Persist chat history and reload previous conversation context
Add authenticated user context to AI-assisted workflows
Process uploaded documents for AI-powered application features
Prepare document chunks and metadata for retrieval
Generate embeddings and store searchable knowledge
Implement retrieval-augmented generation in a .NET application
Ground AI responses with retrieved content
Display source references for document-aware answers
Understand the relationship between the Semantic Kernel, plugins, agents, and the Microsoft Agent Framework
Why take this course?
Many AI demos stop at calling a chat completion API. Real applications need more. They need reusable services, application context, user history, plugins, function calling, document processing, retrieval, and grounded responses.
This course helps .NET developers move beyond simple prompts and start building AI features that fit into real software systems.
You will learn how to connect AI models to your existing C# code, business logic, documents, and ASP.NET Core applications using Semantic Kernel.
Technologies covered
C#
.NET 10
ASP.NET Core
Semantic Kernel
Azure OpenAI
Prompt engineering
Native plugins
Prompt-based plugins
Function invocation
AI agents
Chat history
EF Core
SQLite
Document processing
PDF text extraction
Embeddings
Retrieval-augmented generation
Grounded AI responses
By the end of this course, you will have built a practical Semantic Kernel-powered .NET application that integrates Azure OpenAI, plugins, function invocation, ASP.NET Core, chat history, document processing, embeddings, and retrieval-augmented generation.