Building an enterprise chatbot with Semantic Kernel and .NET

This enterprise chatbot semantic kernel .net tutorial walks through building a production-grade assistant on .NET 8 with Microsoft’s Semantic Kernel. We’ll stand up a minimal API, plug into an OpenAI-compatible inference gateway, and layer in conversation memory and guardrails that survive a real compliance review.

Step 1: Scaffold the project and pin dependencies

Create a fresh Web API project. Target .NET 8 for native AOT compatibility and long-term support.

dotnet new webapi -n EnterpriseChatbot -f net8.0
cd EnterpriseChatbot
dotnet add package Microsoft.SemanticKernel --version 1.20.0
dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI --version 1.20.0
dotnet add package Swashbuckle.AspNetCore

Pin versions explicitly. Semantic Kernel ships fast; an unpinned float breaks your build when a connector changes a signature. I’ve been burned by transitive updates in CI that silently swapped InvokeAsync overloads. Lock it down and upgrade on your terms.

This enterprise chatbot semantic kernel .net tutorial assumes you already have a valid LLM API key. Store it in dotnet user-secrets set "LLM:ApiKey" "sk-..." rather than committing config.

Step 2: Point the kernel at an OpenAI-compatible endpoint

Semantic Kernel’s OpenAI connector speaks the standard /v1/chat/completions shape. If you want one endpoint that fronts 240+ models with automatic fallback when a provider is degraded, configure the base address accordingly.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;

var builder = WebApplication.CreateBuilder(args);

var gatewayUrl = builder.Configuration["LLM:Endpoint"] 
    ?? "https://api.n4n.ai/v1"; // OpenAI-compatible gateway
var apiKey = builder.Configuration["LLM:ApiKey"]!;

builder.Services.AddSingleton<Kernel>(sp =>
{
    var kernelBuilder = Kernel.CreateBuilder();
    kernelBuilder.AddOpenAIChatCompletion(
        modelId: "gpt-4o-mini",
        apiKey: apiKey,
        endpoint: new Uri(gatewayUrl)
    );
    return kernelBuilder.Build();
});

The modelId is just a routing hint. A gateway that honors client routing directives will forward it to the right backend and apply provider cache-control hints if you pass them. Keep the key in user-secrets or Key Vault, never in appsettings.json.

Step 3: Define a domain plugin with native and semantic functions

Enterprise chatbots need more than free-form text. Wrap your line-of-business logic in a plugin. Below is a native function for ticket creation plus a semantic function for summarization.

public class HelpdeskPlugin
{
    [KernelFunction("create_ticket")]
    public string CreateTicket(string summary, string severity)
    {
        // Call your ITSM system here. Stubbed for clarity.
        var id = Guid.NewGuid().ToString("N")[..8];
        return $"Ticket {id} opened with severity {severity}: {summary}";
    }
}

var promptTemplate = """
    Summarize the user's request in one line. 
    If it mentions a outage, prefix with [P1].
    Request: {{$input}}
    """;

kernelBuilder.Plugins.AddFromType<HelpdeskPlugin>();
kernelBuilder.Plugins.AddFromPromptTemplate("Summarizer", "Summarize", promptTemplate);

Semantic Kernel treats both as first-class tools the planner can call. Don’t over-engineer the planner early; invoke functions explicitly until you trust the model’s tool selection. In my experience, explicit invocation reduces hallucinated tool calls by 90% in the first month.

Step 4: Manage conversation state with a scoped chat history

Stateless APIs are easier to scale, but a chatbot needs context. Use a per-session ChatHistory stored in a distributed cache. For a tutorial, MemoryCache is fine.

builder.Services.AddSingleton<IMemoryCache, MemoryCache>();

public record ChatRequest(string SessionId, string Message);

app.MapPost("/chat", async (ChatRequest req, Kernel kernel, IMemoryCache cache) =>
{
    var history = cache.GetOrCreate(req.SessionId, e =>
    {
        e.SlidingExpiration = TimeSpan.FromMinutes(30);
        return new ChatHistory();
    })!;

    history.AddUserMessage(req.Message);
    var result = await kernel.InvokePromptAsync(
        "{{$history}}\nAgent:", 
        new KernelArguments { ["history"] = string.Join("\n", history.Select(m => $"{m.Role}: {m.Content}")) }
    );
    history.AddAssistantMessage(result.GetValue<string>()!);
    cache.Set(req.SessionId, history);
    return Results.Ok(new { reply = result.GetValue<string>() });
});

This is deliberately crude. In production, serialize ChatHistory to Redis and cap message count to control token spend. I trim history to the last 20 turns and inject a rolling summary to stay under context limits.

Step 5: Stream tokens to the client

Users expect typing indicators. Swap InvokePromptAsync for the streaming variant and push Server-Sent Events.

app.MapGet("/chat/stream", async (string sessionId, string message, Kernel kernel, IMemoryCache cache, HttpResponse response) =>
{
    response.Headers.Append("Content-Type", "text/event-stream");
    var history = cache.Get<ChatHistory>(sessionId) ?? new ChatHistory();
    history.AddUserMessage(message);

    await foreach (var chunk in kernel.InvokePromptStreamingAsync(
        "{{$history}}\nAgent:", 
        new KernelArguments { ["history"] = string.Join("\n", history.Select(m => $"{m.Role}: {m.Content}")) }))
    {
        await response.WriteAsync($"data: {chunk}\n\n");
        await response.Body.FlushAsync();
    }
});

Test with curl -N. If you see incremental lines, the pipeline works. Note that SSE requires await response.Body.FlushAsync() per chunk; skipping it buffers everything until completion, defeating the purpose.

Step 6: Enforce enterprise guardrails

Three things auditors ask about: authentication, data residency, and cost attribution.

Add JWT validation:

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer();
app.UseAuthentication();
app.UseAuthorization();
app.MapPost("/chat", ...).RequireAuthorization();

Log token usage from the completion result. The OpenAI connector exposes ChatCompletionUsage via the Usage metadata:

var usage = result.Metadata?["Usage"] as ChatCompletionUsage;
logger.LogInformation("Session {Session} used {Tokens} tokens", req.SessionId, usage?.TotalTokenCount);

Pipe these logs to your FinOps dashboard. That turns a vague “AI is expensive” into chargebacks per team. For data residency, set the gateway region via configuration and reject requests with sessionId patterns that violate your retention policy.

Step 7: Write a test that proves the bot responds

Use the Microsoft.SemanticKernel testing pattern with a mocked IChatCompletionService. Register a fake that returns a fixed string.

var kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.Services.AddSingleton<IChatCompletionService>(new FakeChatCompletion("OK"));
var kernel = kernelBuilder.Build();
var res = await kernel.InvokePromptAsync("hi");
Assert.Equal("OK", res.GetValue<string>());

Run dotnet test. For end-to-end verification, start the API and send a request:

dotnet run &
curl -X POST https://localhost:5001/chat -H "Authorization: Bearer $TOKEN" \
  -d '{"sessionId":"s1","message":"My VPN is down"}'

Expect a JSON reply containing a coherent answer or a tool call result. If you wired the HelpdeskPlugin, the model may return a ticket ID. Following this enterprise chatbot semantic kernel .net tutorial end to end gives you a testable baseline.

Step 8: Containerize with realistic limits

Ship it as a scoped container. Set memory limits so a token spike doesn’t take down the node.

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY bin/Release/net8.0/publish/ .
ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1
ENTRYPOINT ["dotnet", "EnterpriseChatbot.dll"]

Build with dotnet publish -c Release and run under a namespace with resources.limits.memory: 512Mi. I’ve seen unrestricted SK bots eat 2GB on a single long session because nobody capped ChatHistory.

Where to go next

Swap the in-memory cache for Redis, add a retrieval plugin over your knowledge base, and configure the gateway’s cache-control hints to reuse prompt prefixes. Semantic Kernel’s plugin model scales to dozens of integrations without changing the core loop. The hard part is never the LLM call; it’s the boring enterprise plumbing around it.