Private Document Intelligence

Private AI for documents and internal knowledge.

Turn documents into structured data and internal knowledge into cited answers, on an engine that also runs agents, vision, speech, text analysis and generation. One platform, on your hardware. The files, the indexes and the inference never leave your network.

Deploy LM-Kit One Build with LM-Kit.NET

LM-Kit One: Business Preview LM-Kit.NET: .NET 8 / 9 / 10 Platforms: Windows · Linux · macOS

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": "...", ... }

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}");

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.

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.

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.

Two ways to run it

A server you deploy, or a runtime you embed.

The same document processing, retrieval and inference engine, delivered in the shape your team needs. Start with the server when you want a private AI service. Embed the runtime when the AI has to live inside your own application.

Deploy

LM-Kit One

A private AI server for document processing, structured extraction, internal knowledge search and agent tools. Familiar APIs, an admin surface, and an MCP endpoint so AI assistants can use your document capabilities without reaching your files. Currently in Business Preview.

See LM-Kit One

Embed

LM-Kit.NET

The local AI runtime for .NET. One NuGet, in-process, no sidecar and no Python service. Agents, RAG, OCR, structured extraction, vision, speech and embeddings on an adaptive inference engine that runs on the hardware you already own.

See LM-Kit.NET

Documents to data

Turn documents into structured data.

Define the fields you need. LM-Kit reads the document, including scans and photographs, and returns JSON matching your schema, with a confidence figure per field and null where the source does not say. Results are shaped for the system downstream, not for a person to read.

Extract

Schema-constrained fields

Invoices, contracts, claims, forms and correspondence. Grammar-constrained decoding means the output parses every time, so a malformed response cannot reach your pipeline.

Structured data extraction

Read

Scans and photographs

Local OCR and vision-language reading for documents that were never digital. Layout, tables and reading order are preserved rather than flattened into a wall of text.

OCR and document reading

Sort

Classify and split batches

Scanned batches arrive as one file containing many documents. Classify each one, find the boundaries, and route the pieces before extraction runs.

Classification and splitting

Documents to knowledge

Answers with a page number attached.

Point LM-Kit at a corpus of policies, manuals, specifications, contracts or support archives. Ask in natural language and get the passage that supports the answer, with the document and the page. When the corpus does not support an answer, that is what it reports.

Retrieve

Lexical, semantic or hybrid

Exact wording matters for a part number, meaning matters for a policy question. Run either, or both together, and see which strategy produced each result.

RAG and grounded chat

Cite

Evidence, not assertions

Every answer carries its sources: document, page, passage and retrieval score. A reviewer can check the claim against the original in one click.

Document search

Store

Indexes that stay put

Built-in local vector storage with nothing to provision, or bring Qdrant or PostgreSQL with pgvector. Embeddings are computed locally and never leave with a request.

Vector storage options

Documents to action

Operate on the file, not just read it.

Detection is only useful if something happens next. LM-Kit converts, splits, merges, searches, archives and redacts the document itself, and puts a human checkpoint in front of the changes that matter.

Redact

Reviewed, then permanent

Find personal data across every page, group repeated values, and present each finding with its evidence for a person to keep or remove. Approved regions are deleted from the file, not drawn over. Reopen the output and check.

Smart redaction

Convert

Into something workable

PDF, Office, email and images to clean Markdown with structure intact. The step that makes everything downstream, from indexing to extraction, behave predictably.

Document conversion

Handle

The unglamorous PDF work

Inspect, search, render, split, merge, unlock and convert to PDF/A for archival. The operations a document workflow needs constantly and nobody wants to build twice.

PDF toolkit

What Private Document Intelligence means →

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 and pgvector connectors, 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

How it reaches your stack

Three ways in, one engine behind them.

Give an AI assistant private document tools, call the server from any language over HTTP, or compile the whole thing into your .NET application. The processing happens in the same place regardless.

Path 01

AI assistants, through MCP

Expose a curated set of document tools over the Model Context Protocol. The assistant asks for an extraction or a search; LM-Kit does the work locally and returns only the result. You choose which tools are reachable and what they may return.

MCP tools and clients

Path 02

Any application, over HTTP

LM-Kit One speaks the API dialects your existing clients already use, so pointing a working integration at a private deployment is usually a base URL change rather than a rewrite.

LM-Kit One

Path 03

.NET, in process

No network hop, no serialization boundary, no second runtime to deploy and monitor. Typed C# objects in, typed C# objects out, on the threads your application already owns.

LM-Kit.NET

Core technology

Dynamic Sampling, the symbolic layer.

The reason a small local model can hold its own 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. It works on any model as it ships, and it keeps working on one you have fine-tuned yourself.

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 and no per-model adapter required. Drop in a new open-weight release, or your own fine-tune, and the layer keeps working from day one.

Open the Dynamic Sampling deep dive →

Train on your own data

Adapt the model itself, without shipping your data out.

Prompting only goes so far. When a task depends on your vocabulary, your document shapes or your house style, the model has to learn them. That is the one thing a hosted provider cannot offer on sensitive material, because training on it means handing it over. LM-Kit trains on your machine, against your corpus, and the weights that come out are yours.

Train

Fine-tuning, in process

Fine-tune an open-weight model from your own .NET code, with training steps running on the GPU rather than falling back to CPU. No Python toolchain, no notebook, no upload step, and no separate machine to babysit.

LLM fine-tuning

Adapt

LoRA adapters

Train a small adapter instead of a whole model, keep several for different tasks, load them against a shared base, and merge one down when it has earned its place in production.

LoRA integration

Compress

Quantization

Bring a trained model down to a size the target hardware can actually hold, and choose the precision trade-off yourself rather than accepting whatever a vendor published.

Model quantization

Explore model optimization →

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

Fits the AI stack you already run.

Bridges for the .NET AI abstractions, connectors for production vector databases, and a provider-agnostic embedding layer. Keep your orchestration, storage, and models; move inference local where it counts.

Bridge

Microsoft.Extensions.AI

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.

Open the Semantic Kernel bridge

Connectors

Vector databases

Persist RAG embeddings in production stores. Official connectors for Qdrant and PostgreSQL/pgvector implement the same IVectorStore as the built-in memory path.

Vector database connectors

Embeddings

Amazon Bedrock

Bring a managed embedding provider to your RAG pipeline. Amazon Titan and Cohere models on Bedrock plug in through the same IEmbedder contract as local models.

Open the Amazon Bedrock 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, pgvector, bring-your-own
Bridges: Microsoft.Extensions.AI, Semantic Kernel, MCP clients

Licensing

Free for small teams. Commercial above the line.

One license, both products, no activation key. Nothing checks a license at runtime. Evaluation and development are free at any company size, with no time limit.

Free

$0no key, no expiry

The complete SDK and the complete server, including commercial use and redistribution, for small companies. Evaluation and development stay free at any size.

Under $1M USD annual gross revenue
10 or fewer employees
No more than $3M USD raised from outside investors
Always free: personal, education, nonprofits, open source

Download

Professional

Customannual, scaled to scope

Required above the thresholds. Scaled to deployment size, never metered by tokens, seats or end users. Carries the assurance a production deployment needs.

Commercial use and redistribution at any scale
Long-term support builds and security patches
Support with response-time commitments
Unlimited developers and end users

Get a quote

What customers say 4.9 / 5 on SourceForge

See all reviews on SourceForge

Get started

Run it on your own documents.

Deploy LM-Kit One Build with LM-Kit.NET