dotnet-semantic-kernel

name	dotnet-semantic-kernel
description	Integrates AI/LLM via Semantic Kernel. Plugins, prompt templates, memory stores, agents.
metadata	{"short-description":".NET skill guidance for foundation tasks"}

dotnet-semantic-kernel

Microsoft Semantic Kernel for AI and LLM orchestration in .NET applications. Covers kernel setup and configuration, plugin/function calling, prompt templates with Handlebars and Liquid syntax, memory and vector store integration, planners, the agents framework, and integration with Azure OpenAI, OpenAI, and local models.

Scope

• Kernel setup and DI integration for AI services (Azure OpenAI, OpenAI, Ollama)
• Plugin/function calling with automatic invocation and filters
• Prompt templates (inline, Handlebars, YAML)
• Vector store abstractions and RAG patterns
• Agents framework (ChatCompletionAgent, group chat, OpenAI Assistant)
• Streaming responses

Out of scope

• General async/await patterns and cancellation token propagation -- see [skill:dotnet-csharp-async-patterns]
• DI container mechanics and service lifetime management -- see [skill:dotnet-csharp-dependency-injection]
• HTTP client resilience and retry policies -- see [skill:dotnet-resilience]
• Configuration binding (options pattern, secrets) -- see [skill:dotnet-csharp-configuration]

Cross-references: [skill:dotnet-csharp-async-patterns] for async streaming patterns used with chat completions, [skill:dotnet-csharp-dependency-injection] for kernel service registration in ASP.NET Core, [skill:dotnet-resilience] for retry policies on AI service calls, [skill:dotnet-csharp-configuration] for managing API keys and model configuration.

---

Kernel Setup

The Kernel is the central object in Semantic Kernel. It manages AI service connections, plugins, and function invocation.

Package Landscape

Package	Purpose
Microsoft.SemanticKernel	Core kernel, function calling, prompt templates
Microsoft.SemanticKernel.Connectors.AzureOpenAI	Azure OpenAI chat/embedding/image services
Microsoft.SemanticKernel.Connectors.OpenAI	OpenAI chat/embedding/image services
Microsoft.SemanticKernel.Connectors.Ollama	Ollama local model integration
Microsoft.SemanticKernel.Plugins.Core	Built-in plugins (time, math, text)
Microsoft.SemanticKernel.Agents.Core	Agent framework (chat agents, group chat)
Microsoft.Extensions.VectorData.Abstractions	Vector store abstraction layer
Microsoft.SemanticKernel.Connectors.Qdrant	Qdrant vector store connector
Microsoft.SemanticKernel.Connectors.AzureAISearch	Azure AI Search vector store connector

Basic Kernel Configuration

using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder();

// Azure OpenAI
builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")!,
    apiKey: Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!);

var kernel = builder.Build();

```text

### DI Integration with ASP.NET Core

```csharp

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddKernel();

builder.Services.AddAzureOpenAIChatCompletion(
    deploymentName: builder.Configuration["AI:DeploymentName"]!,
    endpoint: builder.Configuration["AI:Endpoint"]!,
    apiKey: builder.Configuration["AI:ApiKey"]!);

// Register plugins
builder.Services.AddSingleton<OrderPlugin>();
builder.Services.AddSingleton(sp =>
{
    var kernel = sp.GetRequiredService<Kernel>();
    kernel.Plugins.AddFromObject(sp.GetRequiredService<OrderPlugin>());
    return kernel;
});

```text

### Multiple AI Services

Register multiple AI services and select by service ID:

```csharp

var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: endpoint,
    apiKey: apiKey,
    serviceId: "gpt4o");

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o-mini",
    endpoint: endpoint,
    apiKey: apiKey,
    serviceId: "gpt4o-mini");

var kernel = builder.Build();

// Select service at invocation time
var settings = new PromptExecutionSettings { ServiceId = "gpt4o-mini" };
var result = await kernel.InvokePromptAsync("Summarize: {{$input}}", (settings)
{
    [] = longDocument
});

```text



```csharp



 builder = Kernel.CreateBuilder();

builder.AddOllamaChatCompletion(
    modelId: ,
    endpoint:  Uri());

 kernel = builder.Build();

```text

---



Plugins expose .NET methods  functions that the AI model can invoke. This  the primary mechanism  grounding LLM responses  real data  actions.



```csharp

 Microsoft.SemanticKernel;
 System.ComponentModel;

   
{
      IOrderRepository _repository;

     => _repository = repository;

    []
    []
      Task<OrderSummary?> GetOrderAsync(
        []  orderId,
        CancellationToken ct = )
    {
         order =  _repository.GetByIdAsync(orderId, ct);
         order   ?  :  OrderSummary(order);
    }

    []
    []
      Task<IReadOnlyList<OrderSummary>> ListRecentOrdersAsync(
        []  customerId,
        []  limit = ,
        CancellationToken ct = )
    {
         orders =  _repository.GetRecentAsync(customerId, limit, ct);
         orders.Select(o =>  OrderSummary(o)).ToList();
    }
}

```text



```csharp

 kernel = builder.Build();


kernel.Plugins.AddFromObject( OrderPlugin(orderRepo), );


kernel.Plugins.AddFromType<TimePlugin>();


kernel.Plugins.AddFromFunctions(,
[
    KernelFunctionFactory.CreateFromMethod(
        ([Description()]  a, [Description()]  b) => a + b,
        ,
        )
]);

```text



Enable the model to call functions automatically during chat:

```csharp

 settings =  AzureOpenAIPromptExecutionSettings
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

 chatHistory =  ChatHistory();
chatHistory.AddUserMessage();

 result =  kernel.GetRequiredService<IChatCompletionService>()
    .GetChatMessageContentAsync(chatHistory, settings, kernel);


Console.WriteLine(result.Content);

```text



Intercept function calls  logging, authorization,  modification:

```csharp

    : 
{
    
    {
        
         (context.Function.Name == )
        {
             orderId = context.Arguments[]?.ToString();
            
        }

         next(context);

        
    }
}


builder.Services.AddSingleton<IFunctionInvocationFilter, AuthorizationFilter>();

```text

---



Prompt templates support variable substitution  function calling within structured prompts.



```csharp

 result =  kernel.InvokePromptAsync(
    ,
     KernelArguments
    {
        [] = articleText,
        [] = 
    });

```text



Handlebars templates support conditionals, loops,  function calls:

```csharp

 templateString = ;

 factory =  HandlebarsPromptTemplateFactory();
 template = factory.Create( PromptTemplateConfig(templateString)
{
    TemplateFormat = HandlebarsPromptTemplateFactory.HandlebarsTemplateFormat
});

 result =  template.RenderAsync(kernel,  KernelArguments
{
    [] = ,
    [] = ,
    [] = ,
    [] = recentOrders
});

```text



Define prompts  YAML files  separation of concerns:

```yaml


name: Summarize
description: Summarizes text to a specified length
template_format: handlebars
template: |
  <message role=>
  Summarize the following text  approximately {{maxWords}} words.
  Focus  key facts  actionable items.
  </message>
  <message role=>{{input}}</message>
input_variables:
  - name: input
    description: The text to summarize
    is_required: 
  - name: maxWords
    description: Target word count
    : 
execution_settings:
  :
    temperature: 
    max_tokens: 

```text

```csharp

 yamlContent = File.ReadAllText();
 function = kernel.CreateFunctionFromPromptYaml(yamlContent);

 result =  kernel.InvokeAsync(function,  KernelArguments
{
    [] = longText,
    [] = 
});

```text

---



Semantic Kernel provides abstractions  vector storage, enabling retrieval-;

   
{
    []
      Id { ; ; } = .Empty;

    []
      Source { ; ; } = .Empty;

    []
      Content { ; ; } = .Empty;

    []
     ReadOnlyMemory<> Embedding { ; ; }
}

```text



```csharp

 Microsoft.SemanticKernel.Connectors.Qdrant;

 builder = Kernel.CreateBuilder();


builder.AddAzureOpenAITextEmbeddingGeneration(
    deploymentName: ,
    endpoint: endpoint,
    apiKey: apiKey);


builder.Services.AddQdrantVectorStore(, );

```text



```csharp

   
{
      IVectorStoreRecordCollection<, DocumentRecord> _collection;
      ITextEmbeddingGenerationService _embeddingService;
      IChatCompletionService _chatService;

    
    {
        _collection = vectorStore.GetCollection<, DocumentRecord>();
        _embeddingService = embeddingService;
        _chatService = chatService;
    }

    
    {
        
         questionEmbedding =  _embeddingService
            .GenerateEmbeddingAsync(question, cancellationToken: ct);

        
         searchResults = _collection.VectorizedSearchAsync(
            questionEmbedding,
             VectorSearchOptions { Top =  },
            ct);

        
         contextBuilder =  StringBuilder();
          ( result  searchResults)
        {
            contextBuilder.AppendLine(result.Record.Content);
            contextBuilder.AppendLine();
        }

        
         chatHistory =  ChatHistory();
        chatHistory.AddSystemMessage(
            );
        chatHistory.AddUserMessage(question);

         response =  _chatService
            .GetChatMessageContentAsync(chatHistory, cancellationToken: ct);

         response.Content ?? .Empty;
    }
}

```text



```
{
     _collection.CreateCollectionIfNotExistsAsync(ct);

     embedding =  _embeddingService
        .GenerateEmbeddingAsync(content, cancellationToken: ct);

     _collection.UpsertAsync( DocumentRecord
    {
        Id = documentId,
        Content = content,
        Source = source,
        Embedding = embedding
    }, cancellationToken: ct);
}

```text

---



The Semantic Kernel agents framework enables building multi-agent systems  specialized agents collaborate  tasks.



```csharp



 Microsoft.SemanticKernel.Agents;

 agent =  ChatCompletionAgent
{
    Name = ,
    Instructions = ,
    Kernel = kernel,
    Arguments =  KernelArguments( AzureOpenAIPromptExecutionSettings
    {
        FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
    })
};


 thread =  ChatHistoryAgentThread();
  ( message  agent.InvokeAsync(
    , thread))
{
    Console.WriteLine(message.Content);
}

```text



Multiple agents can collaborate  a  chat  termination conditions:

```csharp

 analyst =  ChatCompletionAgent
{
    Name = ,
    Instructions = ,
    Kernel = kernel
};

 writer =  ChatCompletionAgent
{
    Name = ,
    Instructions = ,
    Kernel = kernel
};

 chat =  AgentGroupChat(analyst, writer)
{
    ExecutionSettings =  AgentGroupChatSettings
    {
        TerminationStrategy =  ApprovalTerminationStrategy
        {
            MaximumIterations = 
        }
    }
};

chat.AddChatMessage(
     ChatMessageContent(AuthorRole.User, ));

  ( message  chat.InvokeAsync())
{
    Console.WriteLine();
}

```text



For stateful conversations  built- =  OpenAIAssistantAgent.CreateAsync(
    kernel,
     OpenAIAssistantDefinition()
    {
        Name = ,
        Instructions = ,
        EnableCodeInterpreter = 
    });


{
    
     thread =  agent.CreateThreadAsync();

      ( message  agent.InvokeAsync(
        , thread))
    {
        Console.WriteLine(message.Content);
    }
}

{
     agent.DeleteAsync();
}

```text

Note:  = kernel.GetRequiredService<IChatCompletionService>();
 chatHistory =  ChatHistory();
chatHistory.AddUserMessage(userInput);

 settings =  AzureOpenAIPromptExecutionSettings
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

  ( chunk  chatService.GetStreamingChatMessageContentsAsync(
    chatHistory, settings, kernel))
{
    Console.Write(chunk.Content);
}

```text

---



- **Use function calling over prompt stuffing** --  the model call plugins to retrieve real-time data rather than injecting everything  the prompt
- **Keep plugins focused** -- each plugin should represent a single domain; use `[Description]` attributes  functions  parameters so the model knows   how to call them
- **Use YAML prompts  production** -- separate prompt content  code  easier iteration  non-developer editing
- **Do  store API keys  code** -- use environment variables, Azure Key Vault,  the .