LM-Kit One

The Private AI Application Server.

Run models, agents, RAG, search and document intelligence on infrastructure you control. Point OpenAI-, Anthropic-, Ollama- and MCP-compatible clients at it without rebuilding your application stack.

Download LM-Kit One

Signed packages, September 15

See the quickstart

Prepare before launch

Windows · Linux · macOS Loopback by default Air-gap capable One machine to production

Compatible

Point existing clients at it

OpenAI, Anthropic and Ollama APIs, MCP and native REST: one engine behind them all.

Complete

The private AI backend stack

Models, agents, search, RAG, documents and extraction, with nothing separate to assemble.

Built to scale

Workloads, not just requests

Horizontal scaling for inference and sustained document volume, KEDA-ready on Kubernetes.

Controlled

Governed at every boundary

Identity, network, policy, isolation and audit; external access is explicit and controlled.

Twelve components, or one server.

Every component is its own login, upgrade cycle and supply chain. LM-Kit One is not that stack glued together: one engine does twelve jobs, built, versioned and improved as one.

The stack you assemble

Model runner
API gateway
Authentication
Vector database
RAG framework
OCR and document stack
Agent runtime
MCP host
Admin console
Observability
Fine-tuning stack
Workload queue

LM-Kit One

One engine behind OpenAI, Anthropic, Ollama, MCP and native REST
Models, inference, embeddings and reranking
Search, RAG and answers with citations
Document processing, OCR and structured extraction
Agents with tools, skills and memory
Keys, policies, audit and an admin console
Fine-tuning as tracked jobs, telemetry and request history
Horizontal scaling: any node serves any request, KEDA-ready

Day one

One installer

The assembled stack goes live when its twelfth integration does. LM-Kit One goes live when the installer finishes.

Every month

One upgrade

Twelve upgrade cycles and a compatibility matrix collapse into one versioned release, tested as a whole before it ships.

Over the years

One team keeps pace

Models and techniques churn, and glue code decays. The engine absorbs the churn: kernels, algorithms and neural layers keep improving, 150+ releases since 2024.

Compatibility matrixevery endpoint, served or not Security architecturethe boundaries, named Trust Centerdata flows and network behaviour

Nothing locks you in: storage runs fully local, 100% on PostgreSQL, or on MySQL or SQL Server paired with Qdrant; the models can be your own, and any OpenAI-compatible or Ollama front-end plugs in.

Four interfaces, one private engine.

The work happens on your side of the boundary. Calling it should not be a migration project.

Native

The full REST surface

Every capability above is an endpoint, including the document, extraction, search, agent, training and model-management operations that no general chat API models. This is the server at its widest.

Compatible

Three dialects, not three shims

Deep enough that real tooling drives it unmodified, including model lifecycle rather than chat alone. See the breakdown below.

MCP

Private tools for AI assistants

A curated catalog of document and knowledge tools over the Model Context Protocol. The assistant asks for an extraction, a search or a redaction; the server opens the file, works locally, and returns only the result of the tool you allowed.

How the MCP integration works

Console

A surface for people

A workbench for trying capabilities against real documents, a training view, collection administration, and an admin console covering models, inference shape, access tokens, skills, request history, telemetry and logs.

Your existing clients, pointed somewhere private.

Compatibility is usually a chat endpoint and a promise. These dialects go deep enough that the real command-line tools drive the server unmodified, including pulling, creating and pushing models, which is the part shims normally skip.

OpenAI

Beyond chat completions

Chat completions, completions, embeddings and models, plus files, vector stores with their file operations, and the Responses API including input items. That means OpenAI-shaped retrieval and agentic flows work against a private deployment, not only single turns.

Ollama

The whole surface, lifecycle included

Chat, generate, embed, tags, show, ps and version, and the model management verbs too: pull, push, create, copy, delete and blob upload. The stock CLI and anything written against it work as they are, and a multi-gigabyte model upload is a tested path.

Anthropic

Messages, with thinking

The Messages endpoint in the Anthropic shape, so SDKs and coding agents built on it keep working while inference stays inside your network.

In practice

Tested against real clients

Compatibility that is only unit-tested tends to break on contact with an actual tool. These paths are exercised end to end with the stock command-line clients, including an agentic run that called a shell tool and verified the file it produced.

The dialects are the on-ramp, not the ceiling. Once a client is pointed at LM-Kit One, the native REST surface adds the document, extraction, search, agent and training operations none of these APIs can express. The coverage matrix states every endpoint served, and every one that is not.

Closed first, opened deliberately.

A private AI product that is reachable by default is not private. LM-Kit One starts shut and expects you to make each decision to open it.

Network

Loopback until you say otherwise

A fresh install listens on the local machine only. Exposing it to a network is an explicit change, and anonymous access over a network is refused rather than warned about.

Access

Tokens hashed at rest

API tokens are stored hashed, not in plain text. Sessions and the files they can reach are bound to the authenticated owner, so one session cannot read another owner documents.

Egress

Outbound access is a policy

Tools that reach the internet are governed by an allowlist rather than assumed. Once models are present, documents, indexing, retrieval, training and inference need no outbound connection at all, and air-gapped operation is a supported mode.

The security architecture page names all seven boundaries, and what you can verify about each without our word for it.

What comes up when you start it.

A private AI application server with production-grade document intelligence built in: the document, retrieval, inference and operations layers arrive integrated, with nothing separate to deploy.

Read

Getting the content out

OCR for scans and photographs
Layout and reading-order recovery
Markdown conversion, splitting, thumbnails
Audio transcription, video frames

Understand

Turning it into fields

Schema-constrained extraction with confidence scores
Entities, personal data, categories
Sentiment, keywords, language
Summarize, translate, correct, rewrite

A real retrieval engine

BM25 full text with language analyzers
Vector and hybrid with rank fusion
Filters, facets, sorting, pagination
Reranking, grounded answers with citations

Act

Changing the artifact

Reviewed, permanent redaction
PDF edit, merge, split, unlock, forms
Digital signatures, archival PDF/A, rendering
Agents driving any of it as tools

Adapt

Owning the model

Catalog pulls, import, quantization
Load and switch, hardware fit shown first
Fine-tuning as submit, poll, cancel jobs
Artifacts you download and keep

Operate

Running it in production

Admin console, request history, telemetry
Access tokens, skills, collections
Windows service or desktop session
Horizontal scaling across nodes, KEDA-ready
Linux, macOS, air-gapped supported

Fields your systems can consume, not prose.

Define the schema. The server reads the file, including scans and photographs, and returns JSON that matches it, with a confidence figure per field and null where the source does not say. The result is shaped for the next system, not for a reader.

Whatever arrives

PDFs, Office files, email, images and scans. OCR and layout recovery for documents that were never digital. Batched scans are classified and split into their constituent documents before anything else runs.

Out

Typed and confidence-scored

Grammar-constrained decoding means the response parses every time, so a malformed answer cannot reach your pipeline. A per-field confidence score lets you route the uncertain cases to a person instead of accepting them silently.

Also

The analysis around it

Named entities, personal data detection, categorization, sentiment, keywords and language identification, plus summarization, translation, correction and rewriting when the task is about the text rather than its fields.

Answers arrive with evidence you can check.

Build collections from your policies, manuals, specifications, contracts and support archives. Query them by wording, by meaning, or both together. When the evidence is insufficient, the system abstains instead of manufacturing an answer.

Retrieval

Lexical, semantic, hybrid

Exact wording matters for a part number, meaning matters for a policy question. Run either or both, with reranking to sharpen the shortlist, and see which strategy produced each result.

Storage

Nothing to provision

Full-text and vector search are built into the server itself, with nothing separate to install or provision. Prefer infrastructure you already operate? Full text runs on PostgreSQL, MySQL, or SQL Server, with vectors in pgvector or Qdrant.

Evidence

Checkable, not asserted

Answers carry the document, the page, the passage and the retrieval score, so a reviewer can verify a claim against the original rather than trusting it. Collections are administered from the console.

Search-cluster capabilities, without a separate cluster.

Teams reach for OpenSearch or Elasticsearch because they need real retrieval: BM25 with proper analyzers, filters, facets, pagination, multi-tenancy, reindexing. LM-Kit One has those, and the vector, hybrid and reranking layers on top, without a cluster to size, secure and keep alive.

Lexical

BM25 that respects language

Tunable BM25 with per-tenant text normalization and language-aware analysis, including Snowball stemming and bigram handling for CJK. Exact wording still wins when a part number or a clause reference is what the user typed.

Hybrid

Two fusion strategies, weighted

Run the lexical and vector arms together and fuse them by reciprocal rank, which ignores incomparable score magnitudes, or by a convex combination of normalized scores when you trust them. Per-arm weights are yours to set.

Shaping

The knobs a real system needs

Filters and a JSON filter grammar, facet counts, sort, offset paging, minimum score, per-document collapse, MMR diversity, recency decay with a half-life you choose, context expansion to the chunk or the page, and cross-encoder reranking blended into the final order.

Query

Understanding before retrieval

Rewrite a follow-up question against the conversation so pronouns resolve, and fan a query into several variants to widen recall before fusion. Both are switches on the request, not a separate service to run.

Tenancy

Clusters, tenants, collections

Multi-tenant by construction, with tenant promotion and demotion, per-collection configuration, queries that span several collections, more-like-this lookups, and reindexing as a tracked operation rather than a maintenance window.

Evidence

Measured, not asserted

Build golden sets, generate candidates for them, and score retrieval and answers against them in tracked evaluation runs. A slow-query log and top-query statistics show what production is actually asking.

Worth being precise: this replaces what teams run a search cluster for, but it is not wire-compatible with the OpenSearch or Elasticsearch APIs. Moving over means reindexing your corpus and porting queries to this one, not repointing a client. Storage can stay fully local, run 100% on PostgreSQL, or pair PostgreSQL, MySQL, or SQL Server with Qdrant.

Define the agent once. Compatible clients adopt it by name.

Most stacks make every application rebuild the same prompt, the same tool wiring and the same memory handling. Here an agent is a server-side definition, and a request adopts it with one field. Change the agent and every caller follows, with no redeploy on their side.

Definition

What an agent carries

A system prompt, a pinned skill, the tools it may call, whether it remembers across conversations and where that memory lives, the model it answers with, its thinking mode, an opening greeting, and a ceiling on tool calls so a loop cannot run away.

Adoption

One field on a chat request

Name the agent and the bundle fills in wherever the request stays silent, while anything the request states explicitly wins. Clients discover what is available from the agents endpoint rather than being told out of band.

Skills

Reusable behaviour, installable

Ships with skills for summarizing, extracting data, proofreading, translating, writing email, taking meeting minutes, reviewing code and explaining simply. Author your own, install from a URL, and edit them from the console.

Tools

Executed by the server, under policy

Tools run on the server, not in the client, so what an agent can touch is an operator decision. Web search across several providers, page reading, HTTP reads, file ingestion and listing, the document operations, calculation, unit conversion and date maths. Outbound access is governed by an allowlist rather than assumed.

Change the document. Change the model.

Detection is only useful if something happens next, and a general model is only useful until your vocabulary matters. Both of those are operations the server runs.

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 rather than drawn over. Reopen the output and verify.

Operate

The unglamorous PDF work

Inspect, search, render, edit, merge, split, unlock, fill forms, extract attachments, digitally sign and verify signatures, timestamp, convert images to PDF and documents to archival PDF/A. Transcribe audio and pull frames from video while you are there.

Train

Fine-tuning as a managed job

Submit a training run, poll it, cancel it, collect the artifact. Adapting a model to your vocabulary becomes an operation the server tracks rather than a script someone runs on a spare workstation. You fine-tune without uploading training data to a hosted AI service.

The questions we expect, answered first.

Is LM-Kit One open source?

The server itself is not, and we publish complete open-source solutions over time on the LM-Kit repository. What you can verify today: the free tier has no activation, no account and no runtime license check; telemetry export stays off until an operator enables it; deny-all air-gapped operation is supported; and releases ship signed, with SHA-256 checksums and an SBOM available per release. The security page lists what to check.

Is it a wrapper around open-source libraries?

No. Where LM-Kit builds on a library, we fork it, maintain our own patch series and continuously improve it; those improvements ship inside the engine, release after release. Above that sit the layers we build outright: the inference and neural layers, the document and extraction stack, the search engine with cited answers, the agent runtime, four API dialects and the control plane. Every layer is engineered together and improved together, by the same team.

Isn't this just a bundle of components?

It replaces twelve components, but it is not a bundle of independently versioned services: extraction, search, OCR, agents and the API dialects are developed and released as one product, one version number, by one team. Retrieval does not call out to a separate OCR product and the agent runtime is not a wrapped third party, so nothing drifts apart between releases, and each release moves the whole surface at once: the engine has shipped 150+ of them since 2024.

Does it scale horizontally?

Yes. Nodes share state, so any node serves any request: start on one machine and add nodes as load grows, behind your load balancer or on Kubernetes with KEDA-driven autoscaling. The engine is built for sustained volume: OCR, extraction, indexing and embedding throughput are continuously improved along with the models it runs. Scaling out is a documented, reproducible procedure, not a consulting engagement.

Why not Ollama plus Open WebUI?

That pair covers running models and chatting with them, and both keep working here: LM-Kit One serves the Ollama dialect and connects to Open WebUI. What it adds is the rest of the stack applications need around a runner: authentication and isolation, document processing, a search engine with citations, governed agents, audit, and a path to horizontal scale.

Can I bring my own models?

Yes. Import GGUF models through the console, or push them with the stock Ollama CLI; the catalog is a convenience, not a boundary. The console prices any model against your hardware before you commit.

What hardware does it need?

It runs on CPU alone, and interactive work is best with a GPU. There is no fixed minimum: the console shows whether a given model fits the machine before downloading it, so the honest answer is measured on your hardware rather than promised here.

What is the catch on the free tier?

There is none hidden: free below the published company thresholds, including commercial use, with no activation and nothing checked at runtime. Above the thresholds, production use needs a Professional licence; the exact terms live on the pricing page.

Claude Code, Continue, Cline and Zed against your own server.

The endpoint swap for each

Verify

Coverage matrix

Every endpoint served, every parameter honored, every gap stated.

Check the matrix

Free below the thresholds. Commercial above them.

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

The Private AI Application Server

Start on one machine. Scale to production. Keep the same stack.

Download LM-Kit One Embed LM-Kit.NET