Private Document Intelligence

Private AI for documents and internal knowledge.

Extract structured data from any document, get cited answers from your company knowledge, and automate what happens next, all on infrastructure you control.

Request LM-Kit One Preview Start free with LM-Kit.NET

See the privacy architecture →

Fully local deployment Governed AI assistant access Windows, Linux & macOS No per-token fees

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;

// Mount pre-embedded collections from a production vector store.
var store  = new QdrantEmbeddingStore(qdrantClient);
var engine = new RagEngine(embedModel);

engine.AddDataSource(await DataSource.LoadFromStoreAsync(
    store, "knowledge-base", embedModel));
engine.AddDataSource(await DataSource.LoadFromStoreAsync(
    store, "support-tickets", 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.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);
// "C7 is missing: the 100nF decoupling capacitor next to U3."
// Multimodal, multi-turn, local VLM. Same conversation surface as LLMs.

4.9 / 5

rating on SourceForge

360,000+

downloads on NuGet

150+

releases since 2024

You should not have to trust a black box.

LM-Kit is built the other way: control where it runs, verify what it produces, and govern what it is allowed to do.

The old way

Send the documents to the intelligence, and trust what comes back.

The new standard

Bring the intelligence to the documents, and verify what comes back.

You control

Private by architecture

Source documents, indexes and processing stay inside the environment you control; outbound access is a governed decision.

You verify

Verifiable by output

Structured data carries per-field confidence, answers carry citations, and document changes can be checked against the original.

You govern

Governed in operation

Models, tools, access and disclosure are yours to set, with human review in front of the actions that matter.

Structured data, cited answers, governed operations.

Everything comes back in a form the next system can trust: schema-valid JSON, an answer with its page, or a reviewed change to the file.

Extract

Structured data from any document

Define the fields. LM-Kit reads PDFs, scans and photographs and returns JSON matching your schema, with a confidence figure per field.

Structured data extraction

Answer

Answers with a page number attached

Ask policies, contracts and manuals in natural language. Every answer carries the document, the page and the passage that supports it.

Private company knowledge

Operate

Changes a reviewer approved

Convert, split, merge, archive and redact the file itself, with a human checkpoint in front of the changes that matter.

PII review and redaction

What Private Document Intelligence means →

The documents worth automating are the ones you cannot send.

The documents that would pay for automation are exactly the ones a hosted service is blocked from touching: contracts, claims, invoices, personnel files.

Policy. Internal rules forbid uploading customer or personnel material to a third party.
Contract. A customer agreement or DPA names who may process the data, and it is not a hosted model.
Regulation. Residency, sector rules or disclosure obligations decide where processing may happen.
Cost. Document work is high volume, so per-page or per-token billing scales with the thing you were automating.
Connectivity. The site is air-gapped, intermittent, or simply cannot depend on an external service being up.

A server you deploy, or a runtime you embed.

One engine, two shapes. Software vendors embed the runtime inside their product; enterprise teams deploy the server as a shared private service.

For enterprise AI and document teams

Deploy LM-Kit One

Run extraction, private knowledge and governed document tools as a shared private service, with an admin surface and an MCP endpoint. Currently in Business Preview.

See LM-Kit One

For .NET software vendors

Embed LM-Kit.NET

Add the same capabilities directly to your product, without adding a Python sidecar or a cloud document dependency. One NuGet, in process.

See LM-Kit.NET

Both are reached from any stack: governed MCP tools, HTTP APIs, or in-process .NET.

Fully local, or selective disclosure.

Both keep source material inside your infrastructure. They differ in which model does the reasoning, and that difference deserves an exact answer.

Mode A

Fully local

A local model does the reasoning as well as the processing. Documents, OCR, indexes, embeddings and output stay inside the perimeter.

application
  → LM-Kit One or LM-Kit.NET
  → local model
  → local files and indexes

Mode B

Local processing, external reasoning

An external assistant holds the conversation; the sensitive work runs locally through governed MCP tools. Only the result of an allowed tool leaves.

external assistant
  → governed MCP tool
  → LM-Kit One
  → local files and processing
  ← selected result only

In Mode B, anything a tool returns is disclosed to the external model. The claim is that source documents stay local and administrators choose which derived results are shared. Security posture and data-flow detail live in the Trust Center.

A full agent stack, inside the perimeter.

LM-Kit ships the whole agent stack: planning, tools, orchestration and memory, running against your documents inside your infrastructure.

Explore AI Agents →

Tools. A growing catalog of built-in, atomic tools, each behind a permission policy.
Orchestration. ReAct planning, supervisors, parallel and pipeline patterns for multi-agent workflows.
Memory. Persistent agent memory grounded in retrieval, so assistants keep context between sessions.
MCP. Agents consume MCP servers, and LM-Kit One exposes governed MCP tools to outside assistants.
Governance. Allow and deny rules, risk levels and approval checkpoints on every tool call.

What customers say 4.9 / 5 on SourceForge

See all reviews on SourceForge

Seven pillars, one foundation.

The complete runtime surface under both products. Use the parts you need, ignore the rest.

AI Agents Planning, orchestration, memory, tools, MCP Document Intelligence OCR, parsing, extraction, classification, conversion Vision & Multimodal Image understanding, VLM chat, image embeddings RAG & Knowledge Vector search, hybrid retrieval, citations Text Analysis NER, PII, sentiment, classification Speech & Audio Local transcription, 100+ languages Text Generation Chat, translation, rewriting, summaries

Local Inference The local runtime they all share: CPU, CUDA, Vulkan, Metal

Straight answers, before the call.

The questions every evaluation asks, answered the way we answer them on calls.

What can leave our network?

In fully local mode, nothing. When an external assistant uses LM-Kit through MCP, source documents stay local and only the result of an allowed tool is returned; administrators choose the available tools and so control the disclosure boundary.

What does it run on?

Windows, Linux x64 and ARM64, and macOS. CPU works out of the box; CUDA, Vulkan and Metal are used when present.

Which models can we use?

Curated open-weight models across chat, vision, OCR, embeddings and speech, downloaded once and cached locally. Your own fine-tunes load the same way.

How do AI assistants connect?

Through governed MCP tools on LM-Kit One. The assistant calls a tool, the work happens locally, and only the allowed result is returned.

How is it licensed?

Free for small teams, commercial licensing above that line, and LM-Kit One is in Business Preview. The licensing section below has the exact terms.

Do we need Python or a GPU cluster?

Neither. LM-Kit is one NuGet in .NET or one server deployment, and a single machine with a modern CPU or GPU is enough to start.

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

Get started

Run it on your own documents.

Deploy LM-Kit One Start free with LM-Kit.NET