AI chatbot & agent SDK

Build intelligent chatbots that remember, reason and act.

The complete .NET SDK for chatbot agents. Multi-turn conversations with persistent memory, agentic reasoning, function calling, MCP integration, vision, and agent skills. Run Qwen, Gemma, DeepSeek, GLM, GPT-OSS and more 100% on-device with zero cloud dependency.

Start building free Documentation

3 memory types ReAct planning MCP & tools Agent Skills 100% on-device

Persistent memory · New

Semantic, episodic and procedural memory with auto-extraction and consolidation.

Agentic reasoning · New

ReAct, Chain-of-Thought, and Tree-of-Thought planning strategies.

Function calling & MCP · Core

4 execution modes, built-in tools, and Model Context Protocol servers.

Agent skills · New

Drop-in SKILL.md files for zero-code domain expertise.

Vision & multimodal · Core

Process images in any turn with VLM-capable models.

Enterprise security · New

Tool permission policies, risk levels, and approval workflows.

100%
On-device

18
Agent templates

70+
Built-in tools

4
Orchestrators

Why LM-Kit

From simple chat to agentic assistants.

Building chatbots that maintain context, remember users, reason through problems, and take action has traditionally required stitching together multiple cloud services. LM-Kit unifies all of this into a single, on-device .NET SDK.

Conversation

MultiTurnConversation

Full conversation context with history, tools, memory, vision, MCP, and skills in a single API.

Memory

AgentMemory

Three memory types with automatic extraction, consolidation, and multi-user isolation.

Framework

Agent framework

Planning strategies, orchestrators, skills, resilience policies, and observability built in.

Getting started API reference Samples repository Changelog

Capabilities

Everything you need to build chatbot agents.

A complete SDK covering conversations, memory, reasoning, tools, skills, vision, and enterprise security.

Context

Multi-turn context

Maintain conversation history across exchanges. The model references past turns for coherent, contextual responses.

Memory Enhanced

RAG-backed memory

Semantic, episodic, and procedural memory with automatic extraction, consolidation, and multi-user isolation.

Tools

Function calling & MCP

4 execution modes, [LMFunction] attributes, ITool interface, built-in tools, and Model Context Protocol servers.

Skills New

Agent skills

Drop-in SKILL.md files for zero-code domain expertise. Manual slash commands or model-driven activation.

Reasoning New

Agentic reasoning

ReAct, Chain-of-Thought, Tree-of-Thought, and Plan-and-Execute planning strategies for complex tasks.

Vision

Vision & multimodal

Process images alongside text at any turn with VLM-capable models. Build visual assistants that analyze and describe.

Streaming & structured output

Real-time token streaming for responsive UX. Constrain responses to valid JSON schemas with grammar enforcement.

Security Enhanced

On-device & secure

All inference runs locally. Tool permission policies with risk levels, approval workflows, and category-based access control.

MultiTurnConversation class documentation →

Conversation APIs

Choose the right pattern for your use case.

From fast Q&A to extended dialogues with memory, tools, and agentic reasoning.

SingleTurnConversation

Single-turn conversation

Fast question-answer interactions without history retention. Optimized for stateless queries, classification tasks, and one-shot completions.

Stateless Low latency System prompts JSON output

SingleTurnConversation API

MultiTurnConversation

Multi-turn conversation

Extended dialogues with full history tracking, memory, function calling, vision, and agent skills. The foundation for chatbot agents.

History Tools Memory Vision MCP Skills Persistence

MultiTurnConversation API

Smart memories

Agents that remember what matters.

Capability

Serialize & restore

Persist memory to disk and reload across sessions. Share memory states between agents.

Introducing AgentMemory blog post → AgentMemory class documentation

Agentic reasoning & orchestration

Go beyond simple Q&A.

Equip chatbots with planning strategies that decompose complex tasks, and orchestration patterns that coordinate multiple specialized agents.

Reasoning New

Planning strategies

Give chatbots the ability to think step-by-step before acting. Select the planning strategy that fits your task complexity.

ReAct Chain-of-Thought Tree-of-Thought Plan-and-Execute Reflection 18 agent templates

Production New

Enterprise resilience

Production-grade reliability with built-in resilience policies and full observability via OpenTelemetry.

Retry policies Circuit breaker Rate limiting Timeout & fallback OpenTelemetry tracing Agent metrics

Multi-agent orchestration

Coordinate multiple specialized agents for complex workflows. Each orchestrator handles a different collaboration pattern with real-time streaming output.

Pipeline
Sequential agent chain. Each agent refines the output of the previous one.

Parallel
Run multiple agents concurrently and merge results.

Router
Intelligent routing to the best-fit specialist agent.

Supervisor
Supervisor delegates tasks to workers and synthesizes output.

Agent framework documentation →

Function calling & tool use

Let chatbots call your code.

Connect to external services via MCP, and use 70+ built-in tools across 8 categories. See the dedicated Tools & Function Calling page and MCP page for complete coverage.

Attribute

[LMFunction] attribute

Decorate C# methods with [LMFunction] to expose them as callable tools. The SDK generates JSON Schema automatically from method signatures and XML documentation.

Auto schema Type-safe Async support Descriptions

Interface & MCP

ITool, built-in tools & MCP

Use 70+ atomic built-in tools (file system, HTTP, web search, database, PDF), implement ITool for custom tools, or connect MCP servers for external tool catalogs.

8 tool categories MCP protocol Permission policies Risk levels

Execution modes

Simple
One function call per turn with sequential execution.

Multiple
Chain multiple calls in sequence within a single turn.

Parallel
Execute independent calls concurrently for speed.

Parallel + Multiple
Combine parallel and sequential chaining.

Understanding function calling in LM-Kit.NET MCP & tools page

Agent skills

Zero-code domain expertise.

Give chatbots domain expertise without writing code. Drop a SKILL.md file and your agent gains new capabilities instantly.

Agent Skills are reusable instruction files that teach your chatbot how to handle specific domains or tasks. Define a skill once, share it across agents and projects.

Manual mode

Users activate skills via slash commands like /explain or /pros-cons.

Model-driven mode

The model autonomously discovers and activates the right skill via function calling.

Skills support progressive loading, keyword and semantic matching, and multiple sources (filesystem, URLs, GitHub repositories).

Agent skills documentation →

email-writer.SKILL.md

---
name: Email Writer
command: /email
description: Draft professional emails
activation: manual
keywords: [email, compose, draft, write]
---

# Instructions
You are a professional email writer.
Analyze the user's intent and draft a
clear, concise email with:
- Appropriate greeting and sign-off
- Action items highlighted
- Professional tone matching context

Built for developer velocity

A single, unified API. No boilerplate.

No rework when switching models. Five lines to a working chatbot agent. Four examples cover the common patterns: multi-turn chat, memory, tool calling, agent + ReAct.

MultiTurnChat.cs

using LMKit.Model;
using LMKit.TextGeneration;

// Instantiate a model by ID from the catalog
var model = LM.LoadFromModelID("qwen3.5:9b");

// Multi-turn conversation with system prompt
var chat = new MultiTurnConversation(model) {
    SystemPrompt = "You are a helpful customer support agent."
};

// First turn
var r1 = chat.Submit("What's your return policy?");
Console.WriteLine(r1.Completion);

// Second turn - context auto-maintained
var r2 = chat.Submit("How long do I have?");
Console.WriteLine(r2.Completion);

WithMemory.cs

using LMKit.Model;
using LMKit.Agents;
using LMKit.TextGeneration;

// Load chat and embedding models
var chatModel  = LM.LoadFromModelID("qwen3.5:9b");
var embedModel = LM.LoadFromModelID("qwen3-embedding:0.6b");

// Memory with automatic extraction
var memory = new AgentMemory(embedModel) {
    ExtractionMode = MemoryExtractionMode.LlmBased,
    ExtractionModel = chatModel
};

// Memory auto-learns from every turn
var chat = new MultiTurnConversation(chatModel) {
    Memory = memory
};

chat.Submit("I prefer concise answers. My name is Sarah.");
chat.Submit("Explain dependency injection.");
// Agent recalls Sarah's name and brevity preference

ToolCalling.cs

using LMKit.Model;
using LMKit.TextGeneration;
using LMKit.FunctionCalling;

public class WeatherTools {
    [LMFunction("Get current weather for a city")]
    public static string GetWeather(string city) {
        return $"Weather in {city}: 72°F, sunny";
    }
}

var model = LM.LoadFromModelID("qwen3.5:9b");
var chat  = new MultiTurnConversation(model);

// Register tools from a class
chat.Tools.ImportFunctions(typeof(WeatherTools));

// Model calls GetWeather when appropriate
var r = chat.Submit("What's the weather in Tokyo?");

AgentReAct.cs

using LMKit.Model;
using LMKit.Agents;
using LMKit.Agents.Planning;
using LMKit.Agents.Tools.BuiltIn;

var model = LM.LoadFromModelID("qwen3.5:9b");

// ReAct planning + web search
var agent = Agent.CreateBuilder(model)
    .WithPlanning(PlanningStrategy.ReAct)
    .WithTools(tools => {
        tools.Register(BuiltInTools.WebSearch);
        tools.Register(BuiltInTools.Calculator);
    })
    .Build();

// Reasons step-by-step, searches, computes
var result = await agent.ExecuteAsync(
  "Research the population of the 3 largest cities in France and calculate the total.");

Explore usage examples

Microsoft

Semantic Kernel

Use LM-Kit models as the LLM backend for Semantic Kernel plugins, planners, and agents.

Learn more

Microsoft

Microsoft.Extensions.AI

Drop-in IChatClient and IEmbeddingGenerator implementation. Compatible with the middleware pipeline.

Learn more

Open standard

Model Context Protocol

Connect to any MCP server (stdio and SSE transports). Full spec support with sampling, roots, elicitation, and subscriptions.

Learn more

Common use cases

Where chatbot agents ship value.

Customer support

Deploy chatbots that handle complex queries, remember customer history, call your ticketing APIs, and route to specialists when needed.

Healthcare

Healthcare companions

Build virtual assistants for patient triage, scheduling, and follow-ups with HIPAA-compliant on-device processing.

Education

Educational tutors

Create intelligent tutoring systems that adapt to student level, remember progress, and use skills for different subjects.

E-commerce

E-commerce assistants

Power product discovery, order tracking, and personalized recommendations with memory and function calling.

Legal

Legal & compliance

Build document Q&A systems for contracts, policies, and regulations. RAG over your knowledge base, on-premises.

Knowledge

Enterprise knowledge

Deploy agentic chatbots that answer questions from internal wikis, search the web, and orchestrate multi-step research tasks.

Related capabilities

Take chatbots to production.

Each chatbot capability has a dedicated deep-dive page. Pick what fits your build.

Agent templates

Eighteen specialised templates ship in the SDK: Chat, Assistant, QA, Tutor, ReAct, Research, Code, Debugger, Reviewer, and more.

Templates page

Tools & function calling

70+ atomic built-in tools, custom ITool, [LMFunction] attribute binding, grammar-constrained decoding.

Tools page

Real-time streaming

Channel-based, typed token kinds. Render content, thinking, and tool-call signals in your UI as they happen.

Streaming page

Permissions & guardrails

Allow / deny / require-approval policies driven by typed tool metadata. Build a safe-chat profile in five lines.

Permissions page

Resilience

Retry, circuit breaker, timeout, fallback, bulkhead, rate limit. Polly-style policies built for agent execution.

Resilience page

Observability

OpenTelemetry GenAI semantic conventions. Trace every tool call, plan step, and delegation in your existing OTel backend.

Observability page

Demos & docs

Build it. Read it. Try it.

Working console demos on GitHub, step-by-step how-to guides on the docs site, and the API reference for the classes used on this page.

Demo

Install the SDK

Start building chatbot agents today.

From simple multi-turn chat to agentic assistants with memory, reasoning, and tools. Get started in minutes with our SDK.

Download View pricing

Build intelligent chatbots that remember, reason and act.

MultiTurnConversation

AgentMemory

Agent framework

Multi-turn context

RAG-backed memory

Function calling & MCP

Agent skills

Agentic reasoning

Vision & multimodal

Streaming & structured output

On-device & secure

Single-turn conversation

Multi-turn conversation

Semantic memory

Episodic memory

Procedural memory

Auto-extraction

Consolidation

Multi-user isolation

KV-cache aware recall

Time-decay scoring

Serialize & restore

Planning strategies

Enterprise resilience

[LMFunction] attribute

ITool, built-in tools & MCP

Zero-code domain expertise.

Multi-turn chat

Persistent session

Chat with tools

Chat with vision

Research assistant

Persistent memory

Skill-based assistant

RAG chatbot

Chat playground

Semantic Kernel

Microsoft.Extensions.AI

Model Context Protocol

Customer support

Healthcare companions

Educational tutors

E-commerce assistants

Legal & compliance

Enterprise knowledge

Agent templates

Tools & function calling

Real-time streaming

Permissions & guardrails

Resilience

Observability

Multi-turn chat

Multi-turn chat with persistent session

Build a conversational assistant with memory