The .NET SDK for local AI

The complete local AI runtime for .NET.

Seven capability pillars on one adaptive inference engine. Agents, document intelligence, vision, RAG, text analysis, speech, generation. One NuGet, zero cloud calls, full control of your data and your latency.

Quickstart Free Download

NuGet: LM-Kit.NET Targets: .NET Standard 2.0 · .NET 8 / 9 / 10 Platforms: Windows · Linux · macOS

Agent.cs

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

var model = LM.LoadFromModelID("qwen3.5:9b");
var agent = Agent.CreateBuilder(model)
    .WithTools(t =>
    {
        t.Register(BuiltInTools.WebSearch);
        t.Register(BuiltInTools.CalcArithmetic);
    })
    .Build();

var result = await agent.RunAsync(
    "Current BTC price in EUR, rounded to the nearest euro?");

Console.WriteLine(result.Text);
// Plans, calls tools, answers. The whole agent loop.

ExtractInvoice.cs

using LMKit.Data;
using LMKit.Extraction;
using LMKit.Model;

var model     = LM.LoadFromModelID("qwen3.5:4b");
var extractor = new TextExtraction(model);

extractor.Elements = new List<TextExtractionElement>
{
    new("invoice_number", ElementType.String),
    new("invoice_date",   ElementType.Date),
    new("total_amount",   ElementType.Double),
};

extractor.SetContent(new Attachment("invoice.pdf"));
var data = extractor.Parse();

Console.WriteLine(data.Json);
// { "invoice_number": "...", "invoice_date": "...", ... }

VisionChat.cs

using LMKit.Data;
using LMKit.Model;
using LMKit.TextGeneration;
using LMKit.TextGeneration.Chat;

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

var message = new ChatHistory.Message(
    "Identify the missing capacitor.",
    new Attachment("schematic.png"));

var reply = await chat.SubmitAsync(message);
Console.WriteLine(reply.Text);
// Multimodal, multi-turn, local VLM. Same conversation surface as LLMs.

PdfChat.cs

using LMKit.Model;
using LMKit.Retrieval;

var chatModel  = LM.LoadFromModelID("qwen3.5:9b");
var embedModel = LM.LoadFromModelID("embeddinggemma-300m");

using var chat = new PdfChat(chatModel, embedModel);

// Load several documents into the same conversation context.
await chat.LoadDocumentAsync("policies.pdf");
await chat.LoadDocumentAsync("pricing.pdf");
await chat.LoadDocumentAsync("sla-enterprise.pdf");

var answer = await chat.SubmitAsync(
    "What is our enterprise refund window?");

Console.WriteLine(answer.Response.Completion);
// Grounded answer with passage retrieval and page citations.

RAG.cs

using LMKit.Data;
using LMKit.Data.Storage.Qdrant;
using LMKit.Retrieval;

// Connect to a production vector database. Same code works with
// any IVectorStore implementation.
var store  = new QdrantEmbeddingStore(qdrantClient);
var engine = new RagEngine(embedModel);

// Mount existing collections as data sources. Millions of
// pre-embedded passages, no ingestion happening here.
engine.AddDataSource(await DataSource.LoadFromStoreAsync(store, "knowledge-base",    embedModel));
engine.AddDataSource(await DataSource.LoadFromStoreAsync(store, "support-tickets",   embedModel));
engine.AddDataSource(await DataSource.LoadFromStoreAsync(store, "engineering-wiki", embedModel));

// Query across every source at once.
var matches = await engine.FindMatchingPartitionsAsync(
    "What is our enterprise refund window?", topK: 8);

foreach (var m in matches)
    Console.WriteLine($"[{m.Score:P0}] {m.Section}: {m.Partition.Text}");

Ner.cs

using LMKit.Model;
using LMKit.TextAnalysis;

var model = LM.LoadFromModelID("lmkit-tasks:4b-preview");
var ner   = new NamedEntityRecognition(model);

var entities = ner.Recognize(
    "Satya Nadella heads Microsoft from Redmond.");

foreach (var e in entities)
    Console.WriteLine($"[{e.Type}] {e.Value}");

// [Person]       Satya Nadella
// [Organization] Microsoft
// [Location]     Redmond

Transcribe.cs

using LMKit.Media.Audio;
using LMKit.Model;
using LMKit.Speech;

var model = LM.LoadFromModelID("whisper-large-turbo3");
var stt   = new SpeechToText(model)
{
    EnableVoiceActivityDetection = true,
    SuppressHallucinations       = true,
};

stt.OnNewSegment += (_, e) =>
    Console.WriteLine($"[{e.Segment.Start:mm\\:ss}] {e.Segment.Text}");

await stt.TranscribeAsync(new WaveFile("meeting.wav"));

StreamingChat.cs

using LMKit.Model;
using LMKit.TextGeneration;

var model = LM.LoadFromModelID("gemma4:e4b");
var chat  = new MultiTurnConversation(model)
{
    SystemPrompt = "You answer in one sentence.",
};

chat.AfterTokenSampling += (_, e) =>
    Console.Write(e.Token.Text);

await chat.SubmitAsync(
    "What ports does Kestrel bind by default?");
// Streaming tokens, multi-turn state, system prompt. .NET-native.

The shape of the SDK

A runtime, not a wrapper.

Most "local LLM" tools are inference engines. LM-Kit.NET is the runtime that sits on top: agents that reason and call tools, RAG with page-level citations, OCR that holds its own against commercial engines, structured extraction that emits typed C# objects, multilingual speech-to-text, image understanding, embeddings, and a growing catalog of built-in tools. Every capability ships in the same NuGet, runs on the same model graph, and respects the same adaptive sampling layer underneath.

What ships in the box

Seven pillars, one foundation.

LM-Kit.NET ships seven pillars and the local runtime they all sit on. Use the parts you need, ignore the rest.

01 · AI Agents

Orchestration patterns

ReAct planning, supervisors, parallel and pipeline orchestrators, persistent memory, MCP clients, custom tools.

AI Agents

02 · Document Intelligence

Parse PDFs, images, EML

PDF text and table extraction, on-device OCR reaching SOTA benchmark scores, structured field extraction with grammar-constrained generation.

Document Intelligence

03 · Vision & Multimodal

VLMs, image classification, chat with image

Image understanding, classification, labeling, multimodal chat, image embeddings, VLM-OCR, background removal. Same conversation surface as LLMs.

Vision & Multimodal

04 · RAG & Knowledge

Vector search and retrieval

Built-in vector store, Qdrant connector, embeddings, hybrid retrieval, document chunking, source citations.

RAG & Knowledge

05 · Text Analysis

Classification, NER, PII, sentiment

Built-in classifiers and an extractor that emits typed C# objects via grammar-constrained sampling. Sentiment, keywords, language detection.

Text Analysis

06 · Speech & Audio

Audio transcription, STT

A growing local speech-to-text stack: hallucination suppression, Voice Activity Detection, real-time translation, streaming output, 100+ languages.

Speech & Audio

07 · Text Generation

Conversations, rewriting, summaries

Single-turn, multi-turn, and stateless conversation primitives. Translate, correct, rewrite, summarise. Prompt templates, streaming, grammar-constrained outputs.

Text Generation

The foundation

Every capability above runs on this runtime.

Foundation

Local Inference

The runtime all seven pillars sit on. The LM-Kit.NET NuGet ships the complete inference system: open-weight LLMs, vision-language models, embeddings, on-device speech-to-text, OCR and classifiers, accelerated on CPU, AVX2, CUDA 12/13, Vulkan or Metal. One package, zero cloud calls, predictable latency, full data and technology sovereignty.

Explore the foundation

Core technology

Dynamic Sampling, the symbolic layer.

The reason a 4B local model can match fine-tuned cloud behaviour on extraction, classification, and structured generation. Dynamic Sampling is an adaptive inference engine that sits underneath every LM-Kit call, steering each token with structural awareness, contextual signals, and grammar-aligned validation. Always on, model-agnostic, no retraining.

Pillar A

Constrained output

Dynamic grammar guarantees JSON, schemas, and tool-call shapes always parse. A novel hybrid path runs roughly twice as fast as classical grammar sampling.

Pillar B

Adaptive guidance

Per-token contextual perplexity, semantic memory for codes and identifiers, structural rejection of malformed runs. Hallucinations drop, recoveries happen in place.

Pillar C

Model-agnostic

No architecture coupling, no fine-tuning, no per-model adapter. Drop in a new open-weight release and the layer keeps working from day one.

Open the Dynamic Sampling deep dive →

The decision

Pick the right tradeoff for your stack.

LM-Kit.NET is the answer when the alternatives don't fit. Three honest comparisons, no straw men.

Compare

vs. wrapping cloud APIs

No per-token bill. No data leaving your network. Latency you can predict. Inference cost equals the cost of compute you already own. Works offline by design.

Local vs Cloud, in depth

Compare

vs. a Python service

No FastAPI sidecar, no HTTP shim, no two-runtime tax. LM-Kit links into your .NET process, picks up the right native acceleration, and stays out of the way. Async/await all the way down.

LM-Kit vs LangChain

Compare

vs. other .NET local stacks

Most ship inference only. LM-Kit ships the full runtime: agents, RAG, OCR, structured extraction, speech, vision, classifiers, embeddings, plus the symbolic layer that makes small models behave.

LM-Kit vs LlamaSharp

Integrations

Drop into the Microsoft AI plumbing you already use.

Existing IChatClient pipelines work unchanged. LM-Kit becomes the local backend behind code you already wrote.

Bridge

Microsoft.Extensions.AI

Stream tokens, call functions, embed text. Every IChatClient, IEmbeddingGenerator, and middleware-aware abstraction you wrote against the official package keeps working with a local model behind it.

Open the Extensions.AI bridge

Bridge

Semantic Kernel

Use LM-Kit.NET as a Semantic Kernel connector. Plug local chat completion, embeddings, and function-calling into existing SK plans, planners, and skills without rewriting the orchestration layer.

Open the Semantic Kernel bridge

Runs where your code already runs

Same process, same threads, same deploy.

No sidecar service, no special runtime. LM-Kit links into your application, picks up the right native acceleration for the host, and gets out of the way.

Runtime: .NET Standard 2.0 · .NET 8 · 9 · 10
OS: Windows, Linux x64 & ARM64, macOS
Acceleration: CPU, AVX/AVX2, CUDA 12/13, Vulkan, Metal
Models: Gemma 3, Qwen 3, Llama, Phi-4, GLM 4.7, GPT OSS, Whisper, embeddings
Storage: In-memory, built-in vector DB, Qdrant, bring-your-own
Bridges: Microsoft.Extensions.AI, Semantic Kernel, MCP clients

Licensing

Free for builders. Commercial when you ship.

Run the full SDK on your own hardware at no cost. Buy a commercial license when LM-Kit is part of a product you sell to customers.

Community

Freeforever

Full SDK access for any company or individual. Build and deploy non-commercial applications, or evaluate LM-Kit before shipping.

Eligibility: any company or individual
Deployment: development, internal tools, OSS
Platforms: Windows, Linux, macOS
Community support on GitHub

Get the free license

Professional

Customper project

For products that ship LM-Kit to customers. Pricing is scaled to deployment size and value. Includes dedicated support and roadmap input.

Commercial redistribution rights
Dedicated technical support
Unlimited developers and end users
Direct relationship with the team

Talk to us

What customers say 4.9 / 5 on SourceForge

See all reviews on SourceForge

Get started

Ship local AI in your next build.

Quickstart Read the docs