alay2shah · Nov 13, 2026 · Nov 11, 2026 · Nov 11, 2026 · Nov 11, 2026 · Nov 11, 2026
diff --git a/.mintignore b/.mintignore
@@ -1,2 +1,4 @@
 MODEL-MATRIX.md
 DESIGN.md
+CLAUDE.md
+INTERACTIVE_QUICKSTART_WIDGET.md
diff --git a/.mintlify/Assistant.md b/.mintlify/Assistant.md
@@ -0,0 +1,27 @@
+# Liquid Docs assistant instructions
+
+## Speed, memory, and hardware
+
+The docs don't list measured speed, RAM use, or download size for every model and device. When someone asks how fast a model is, how much memory it needs, how big the download is, or whether it runs on a specific device (phone, Raspberry Pi, Jetson, laptop, GPU):
+
+- Give any figure that the model's own page states, and cite that page.
+- Point them to [Pipette](https://pipette.liquid.ai), Liquid AI's benchmarking site with speed and memory measured on real devices.
+- For download size, start with the model's documentation page and follow its exact Hugging Face link for the requested format and precision (HF, GGUF, MLX, ONNX, or another listed format). Preserve the repository owner and name; conversions may be published by `mlx-community` or `onnx-community`, not only `LiquidAI`. Don't construct repository URLs from the model name.
+- Link the selected repository's Files tab. Quote a size only if it is stated in the docs or verified in that file listing. If the format or precision is unspecified, explain that download size depends on those choices and link the available formats.
+- Count the selected weights and any required shards, projectors, codecs, or other companion files described by the model's setup instructions. A repository's total size may include several alternative quantizations; it is not the download size for one choice. Download size is not runtime RAM usage.
+
+Don't estimate tokens per second or RAM use yourself.
+
+## Benchmark scores and model comparisons
+
+When someone asks for benchmark results, quality scores, or a comparison with other models:
+
+- Start with the model's documentation page and cite any published evaluation results it provides.
+- Follow the exact Hugging Face model-card links or evaluation sources linked from that page. Don't construct repository URLs from the model name.
+- Don't assume every model has a Hugging Face repository or published benchmark scores. For API-only models such as d1-ultra and d1.1, use published evaluation sources linked from their documentation when available. If no published results are available in those sources, say so.
+- Don't make up or estimate scores.
+
+## Questions about this assistant
+
+If someone asks which model powers you, say you're the Liquid Docs assistant, provided by Mintlify, and that you don't run on a Liquid Foundation Model.
+To try LFMs, point them to the [Liquid Playground](https://playground.liquid.ai) to chat with the models in the browser, the [Liquid API quickstart](/api/quickstart).
@@ -1,7 +1,6 @@
 ---
 title: "Changelog"
 description: "Release notes for the LEAP SDK, including the 0.9.x → 0.10.x Kotlin Multiplatform transition."
-noindex: true
 ---
 
 <Warning>
@@ -12,9 +11,9 @@

 This page covers user-visible changes in the LEAP SDK across releases. For per-build commit detail, see the release notes on [`Liquid4All/leap-sdk`](https://github.com/Liquid4All/leap-sdk/releases).

 ## 0.9.x → 0.10.x: Kotlin Multiplatform unification

 Starting with v0.10.0, the LEAP SDK ships from a single Kotlin Multiplatform codebase. The two previously separate distributions (the Android-only `ai.liquid.leap:*` Maven artifacts and the iOS-only `Liquid4All/leap-ios` Swift package) were collapsed into one source tree that publishes to:

 - **Swift Package Manager** — [`Liquid4All/leap-sdk`](https://github.com/Liquid4All/leap-sdk) (new repo, for iOS / macOS consumers).
 - **Maven Central** — `ai.liquid.leap:*` (Android, JVM, and Kotlin/Native targets).
@@ -30,7 +29,7 @@
 | `LeapSDK` | `ai.liquid.leap:leap-sdk` | Core inference + conversation API |
 | `LeapModelDownloader` | `ai.liquid.leap:leap-model-downloader` | Hosted / manifest-based model fetch |
 | `LeapOpenAIClient` | `ai.liquid.leap:leap-openai-client` | OpenAI-compatible cloud chat client (new in 0.10.0) |
 | `LeapUI` | `ai.liquid.leap:leap-ui` | Voice assistant widget — Compose Multiplatform (new in 0.10.0) |
 | `LeapSDKMacros` | _(Swift only)_ | `@Generatable` / `@Guide` constrained-generation macros |

 ### Breaking changes for iOS consumers
@@ -41,8 +40,8 @@

 - **SPM URL change.** Point your Swift Package Manager dependency at `https://github.com/Liquid4All/leap-sdk.git` (not the deprecated `leap-ios` repo).
 - **CocoaPods removed.** The SDK ships exclusively through SPM in v0.10.0 onward.
 - **Toolchain bump.** Xcode 16 and Swift 6.0 are required.
 - **Swift downloader name.** In current 0.10.x, Swift code instantiates `ModelDownloader` from the `LeapModelDownloader` SPM product. Android code still uses the Kotlin class `ai.liquid.leap.downloader.LeapModelDownloader`. See [Model Loading](/deployment/on-device/sdk/model-loading) for the constructor signatures.

 ## Major additions since 0.9.x

@@ -56,11 +55,11 @@

 ### Voice assistant widget

 `LeapUI` / `leap-ui` is a Compose Multiplatform module that ships a drop-in voice assistant widget — an animated orb, mic button, and status label — backed by a state machine that handles recording, generation, and audio playback. Stable on iOS, macOS, Android, and JVM; Wasm/Web is present in the source tree as preview.

 See [Voice Assistant Widget](/deployment/on-device/sdk/voice-assistant).

 ### Sideloading models from explicit paths

 `LeapDownloader.loadSimpleModel` and `LeapModelDownloader.loadSimpleModel` load a model from explicit resource paths or URLs without going through the LEAP Model Library manifest. Useful for ADB-pushed bundles, app-bundled models, or any setup where you've already placed the model files on disk.

@@ -68,16 +67,16 @@

 ### iOS background downloads

 The iOS / macOS Swift `ModelDownloader(sessionConfiguration:)` initializer accepts an optional `URLSessionConfiguration?` so downloads can continue when the app is suspended or killed. See [Model Loading → Constructing the downloader](/deployment/on-device/sdk/model-loading#constructing-the-downloader).

 ### `autoDetectCompanionFiles`

 `Leap.load(url:options:)` on iOS gained an `autoDetectCompanionFiles: Bool = true` parameter that picks up companion files sitting next to the model file (e.g. multimodal projection weights).

 ### Swift ergonomics

 - **Compatibility layer** keeps 0.9.x call sites (`Leap.load(...)`, `Conversation.generateResponse(...)`) compiling on top of the unified KMP surface.
 - **`onEnum(of:)`** — SKIE-bridged sealed-class switching for Kotlin enums and sealed hierarchies (e.g. `MessageResponse`).
 - **`ChatMessageContent` static factories** — `.text(...)`, `.image(...)`, `.audio(...)` helpers instead of constructor calls.
 - **Builder-style options** — `LiquidInferenceEngineOptions.with(cacheOptions:)`, etc.

@@ -85,11 +84,11 @@

 Starting in **v0.10.4** and on by default through the current release, the inference engine loads model weights via `mmap` (`use_mmap=true`). It's the default behavior for every loaded model. On mobile this is the most user-visible runtime change in the 0.10.x line. A public opt-out arrived in **v0.10.5** as `ModelLoadingOptions.useMmap: Boolean?` (Kotlin) / `LiquidInferenceEngineOptions(useMmap:)` (Swift) — leave it `null`/`nil` to keep the default, or set `false` for filesystems where `mmap` misbehaves (some Android scoped-storage paths, certain network mounts).

 **What changed.** Previously the engine `read(2)`-ed the entire model file into a heap-allocated buffer before running prefill. Now it memory-maps the file: the kernel maps the on-disk weights into the process's virtual address space and loads pages lazily as they're accessed.

 **Performance implications on mobile:**

 - **Lower private RSS.** mmap'd weights are file-backed pages, not "anonymous private" RSS. iOS's jetsam and Android's low-memory killer both score apps primarily by anonymous RSS, so a 1.2B-Q4 model that previously counted as ~700 MB of dirty heap now shows as backing pages the OS may evict for free. Foreground apps are significantly less likely to be terminated under memory pressure.
 - **Faster cold load.** The constructor returns as soon as the file is mapped — typically tens of milliseconds — instead of waiting for the entire model to be read into RAM. The first inference pays the page-in cost incrementally as the engine touches weights.
 - **Faster warm reloads.** After the first load, the kernel's page cache holds the model's hot pages. Re-creating a runner on the same model (e.g. after a background termination and relaunch within the same boot) is near-instant — pages stream from the page cache, not disk.
 - **Multi-model sharing.** Two processes (or two runners in one process) loading the same model file share physical pages via the page cache, with no extra RAM cost.
@@ -97,7 +96,7 @@

 **Trade-offs:**

 - **First-token latency on cold pages.** The first generation against a freshly-mapped model triggers page faults as the engine walks the weights. This adds disk-I/O latency to TTFT on the first call after process start. The KV cache reuse documented [above](#kv-cache-reuse-across-generations) compounds well here: cached prefixes skip both prefill compute *and* the page-fault cost for weights touched during prefill.
 - **Storage type matters.** On devices with slow eMMC / external SD storage, lazy page-in can be noticeably slower than the old eager-read flow that loaded the whole file once. Internal flash on every shipped iOS device and any modern Android device is fast enough that this isn't visible in practice.
 - **Opt-out available since v0.10.5.** Pass `useMmap = false` on `ModelLoadingOptions` (Kotlin) or `LiquidInferenceEngineOptions(useMmap: false)` (Swift) to force the legacy full-read loader. Use only when `mmap` misbehaves on the target filesystem; the default of `null`/`nil` keeps the engine default.

@@ -105,13 +104,13 @@

 ### KV cache reuse across generations

 `CacheOptions` (new in v0.10.4, ergonomic Swift surface in v0.10.4.3) lets the engine persist KV-cache data between `generateResponse` calls so requests that share a prompt prefix skip the prefill work for the shared tokens.

 <Warning>
 **Disabled by default.** `cacheOptions` is `nil` (Swift) / `null` (Kotlin) until you explicitly pass `LiquidCacheOptions.enabled(path:)` / `ModelLoadingOptions.cacheOptions(path:)`. Apps that don't opt in see no prefix reuse and no on-disk cache directory created — same behavior as 0.9.x and pre-0.10.4 builds.
 </Warning>

 **Why it matters.** Transformer inference has two phases: **prefill** (compute keys and values for every prompt token) and **decode** (generate one new token at a time, reusing those K/V vectors). On mobile, prefill dominates time-to-first-token for any prompt longer than a few hundred tokens. With `CacheOptions` enabled, a previously seen prefix is read from disk instead of recomputed — TTFT can drop from seconds to under a hundred milliseconds on cache hits. Per-token decode cost is unchanged.

 **When it speeds things up.** Anywhere the same tokens appear at the start of many requests:

@@ -119,7 +118,7 @@
 - **RAG / retrieval-augmented generation.** Many queries share the retrieved-document preamble.
 - **Few-shot prompting.** A fixed set of examples precedes every request.
 - **Agent loops.** Tool definitions, role instructions, and task scaffold are stable across iterations.
 - **Voice assistant continuations.** Conversation history grows; everything before the latest user turn is cacheable.

 The cache is a bounded LRU — the engine caps cache size and evicts the least-recently-used entries automatically; you do not need to manage the directory yourself. See [Model Loading → KV cache reuse](/deployment/on-device/sdk/model-loading#kv-cache-reuse) for the per-platform configuration.

@@ -158,14 +157,14 @@

 **New targets on `leap-openai-client`** ([PR #256](https://github.com/Liquid4All/leap-android-sdk/pull/256)):

 - **`jvm`** (Ktor CIO engine) — Maven Central now publishes `ai.liquid.leap:leap-openai-client-jvm:0.10.7`. Pure-JVM desktop / server apps can route OpenAI-compatible chat completions without dragging in Android or KMP targets. (The 0.10.0 — 0.10.6 SPM cascade only shipped Android + Apple + Linux/MinGW K/N + wasmJs metadata; the JVM slice was absent.)
 - **`wasmJs`** (Ktor Js engine) — browser-side chat-completions client matching what `leap-sdk` already targets.

 The Apple slice (`LeapOpenAIClient.xcframework`) ships unchanged — same SSE-stream surface, same `OpenAiClientConfig`, same OpenRouter extra-headers support. SKIE is still not applied to this module in v0.10.7, so the Kotlin/Native exports remain the same as v0.10.6: `Flow<ChatCompletionEvent>` is not bridged to Swift `AsyncSequence`, and `onEnum(of:)` is not generated for `ChatCompletionEvent`. **The next release will enable SKIE on `leap-sdk-openai-client`**, bringing `for try await` over the stream, exhaustive `onEnum(of:)` switching, and SKIE-bundled Swift convenience inits — see the [OpenAI client page](/deployment/on-device/sdk/openai-client) for the current pinning guidance.

 **Bytecode hardening:**

 - The `leap-sdk-jvm`, `leap-openai-client-jvm`, `leap-ui-jvm`, and `leap-ui-android` artifacts had been silently shipping Java 17 / Java 21 bytecode against the project's stated JVM-target-11 stance. All ten published JVM / Android slices now consistently emit class-file major version `0x37` (Java 11). Consumers running on JDK 11 — particularly long-running services and JDK-11-pinned Android Gradle builds — are no longer at risk of `UnsupportedClassVersionError`.

 **Internal: KMP build centralization** (no consumer-visible API change):

@@ -178,7 +177,7 @@

 **iOS surface (unchanged from v0.10.6):**

 The four XCFrameworks (`LeapSDK`, `LeapModelDownloader`, `LeapOpenAIClient`, `LeapUi`) ship the same Swift APIs as v0.10.6. The v0.10.6 ObjC class rename to `ModelDownloader`, the dual-import guard, the dynamic `LeapModelDownloader` framework, and the `LeapDownloaderConfig()` parameterless init all remain in place.

 ### v0.10.6 — 2026-05-12

@@ -186,9 +185,9 @@

 **New iOS API on `ModelDownloader`:**

 - **`loadModel(modelName:, quantizationType:, options:, generationTimeParameters:, forceDownload:, downloadProgress:)`** — downloads (when needed) and loads in one call. The transfer registers in `queryStatus`, is cancellable via `requestStopDownload`, and continues across backgrounding when constructed with `sessionConfiguration: .backgroundSessionConfiguration(withIdentifier:)`.
 - **`loadModel(manifestUrl:, options:, generationTimeParameters:, forceDownload:, downloadProgress:)`** — same flow keyed by a manifest URL.
 - **`loadSimpleModel(model: ModelSource, options:, generationTimeParameters:, downloadProgress:)`** — sideload from explicit paths or URLs; HTTPS sources stream through `URLSession`, local paths pass straight through.
 - **`forceDownload: Bool = false`** on all three load methods. Resolves the manifest first, then deletes the local cache, then re-downloads — a registry failure on resolve leaves the previously-working cached copy intact.
 - **Resource-lookup helpers** that previously lived only on the cross-platform `LeapDownloader`: `getModelResourceFolder(...)`, `getCachedManifest(...)`, `getCachedFilePath(...)`, `resolve(...)`, `deleteModelFile(...)`.
 - **`requestDownloadModel(manifestUrl:, forceDownload:)`** overload for symmetry with `removeModel(manifestUrl:)` / `queryStatus(manifestUrl:)`.
@@ -202,18 +201,18 @@
  ```
 - **Parameter labels renamed across the iOS `ModelDownloader` surface** — `model:` / `quantization:` → `modelName:` / `quantizationType:` on every method that already existed: `downloadModel(...)`, `requestDownloadModel(...)`, `requestStopDownload(...)`, `queryStatus(...)`, `removeModel(...)`, `getModelSize(...)`. Every loader now uses the same labels across Swift and Kotlin — `ModelDownloader` (iOS, macOS), `LeapModelDownloader` (Android), and `LeapDownloader` (cross-platform) all share `modelName:` / `quantizationType:`.
 - **`LeapModelDownloader` SPM library product is now single-target.** It no longer bundles the `LeapSDK` target. Apps depending on this product must drop any direct `LeapSDK` SPM dependency from the same target — `import LeapModelDownloader` re-exports every LeapSDK Kotlin type (`Conversation`, `ModelRunner`, `ChatMessage`, `Leap`, the convenience extensions, …). Keeping both library products on the same target double-bundles the inference engine dylibs and triggers a build-time `#error` from the LMD umbrella header (see "dual-import guard" below); the `LeapUI` library product still bundles `LeapSDK` because LeapUI does not re-emit those types in its ObjC binding.
 - **`LeapModelDownloader.xcframework` is now a dynamic framework.** It was a static archive in 0.10.5. SPM applies Embed & Sign automatically; manual integrators must add the framework with "Embed & Sign" instead of "Do Not Embed". The shipped XCFramework now also bundles the inference engine dylibs (`libinference_engine.dylib`, `libinference_engine_llamacpp_backend.dylib`, `libie_zip.dylib`) under `Frameworks/` with an `@loader_path/Frameworks` LC_RPATH — consumers using LMD on its own no longer need `LeapSDK.framework/Frameworks` on their search path.
 - **Dual-import build-time guard.** LMD's umbrella header carries a `__has_include(<LeapSDK/LeapSDK.h>) && !defined(LEAP_DUAL_IMPORT_ALLOW)` check that fires `#error` at the consumer's preprocessing time when both `LeapSDK` and `LeapModelDownloader` frameworks are reachable in the same target. To opt out for legitimate combinations (e.g. transitive linkage via `LeapUI`), add `LEAP_DUAL_IMPORT_ALLOW=1` to `OTHER_CFLAGS`.

 **New Swift conveniences:**

 - **`ModelDownloader()`**, **`ModelDownloader(sessionConfiguration:)`**, **`ModelDownloader(config:)`** — Kotlin/Native ObjC export strips default-argument metadata, so 0.10.5 forced Swift callers to pass every parameter (and `LeapDownloaderConfig` has seven). These new SKIE-bundled convenience inits restore the parameterless / single-arg forms.
 - **`LeapDownloaderConfig()`** parameterless convenience init mirroring the Kotlin defaults (`saveDir = "leap_models"`, `validateSha256 = true`, etc.). Same rationale — `LeapDownloaderConfig` is a Kotlin `data class` with seven defaulted fields that the ObjC export couldn't carry through.

 **Behavior changes:**

 - **`requestDownloadModel(forceDownload: false)`** now short-circuits when a cached manifest already exists *and* every resource referenced by that manifest is present on disk — matches both the Android downloader's idempotent-call semantics and what `queryStatus(...)` already reports. Earlier 0.10.5 builds would short-circuit on the manifest alone, leaving the caller stuck if any resource file had been removed. Pass `forceDownload: true` to re-download on top of a cache.
 - **Cached-file lookup** uses Ktor URL parsing instead of substring slicing, so URLs with fragments or query strings now produce the same filename the loader expects (`getCachedFilePath` was previously brittle for those shapes).

 **Fixes:**

@@ -233,11 +232,11 @@

 - **`ModelLoadingOptions.cacheDir: String?` → `cacheOptions: EngineOptions.CacheOptions?`** — KV cache configuration moves to a bounded-LRU `CacheOptions` value with explicit `enabled` master switch, per-tier caps (`maxEntriesDisk`, `maxEntriesMemory`, `maxBytesMemory`), and optional `diskDisabled = true` for memory-only mode. Migrate via the `ModelLoadingOptions.cacheOptions(path = ...)` factory (preserves the historical 40-entry disk budget and sets `enabled = true`). Constructing a raw `CacheOptions` requires `enabled = true` to enable the cache — a positive `maxEntries` alone is no longer sufficient.
 - **`LeapDownloader.loadModel(modelName, quantizationSlug, modelLoadingOptions, …)` → `loadModel(modelName, quantizationType, options, …)`** — parameter renames bring `LeapDownloader` in line with `LeapModelDownloader`. The same rename applies to `loadSimpleModel(model, modelLoadingOptions, …)` → `loadSimpleModel(model, options, …)` and `loadModelFromManifestUrl(…)`. Swift sites that called `downloader.loadModel(modelName:, quantizationSlug:, modelLoadingOptions:)` need to swap to `quantizationType:` / `options:` after upgrading.
 - **`progress` is now nullable** (`progress: ((ProgressData) -> Unit)? = null`) — pass `null` to opt out (was an empty-lambda default).

 **New features:**

 - **`ModelLoadingOptions.useMmap: Boolean? = null`** — exposes the engine's `use_mmap` toggle to Kotlin/Swift callers. `null` (default) defers to the engine default of `true`. Set `false` only on filesystems where `mmap` misbehaves (some Android scoped-storage paths, certain network mounts). On Swift, `LiquidInferenceEngineOptions` gained a matching `.with(useMmap:)` builder. Previously mmap could not be disabled from the SDK.
 - **Leap Model Service (Android)** — `leap-model-service` is a new optional Android service that hosts loaded models in its own process and lets multiple client apps share them. Apps using `LeapModelDownloader.loadModel(...)` route through the service transparently when it's installed on the device; otherwise they fall back to in-process loading. Per-UID session quotas, persistent foreground notification, disk-backed KV cache reuse across cold starts, and AIDL-routed `registerFunction(s)`. Pass `forceLocal = true` on `LeapModelDownloader.loadModel(...)` to bypass the service for testing. See [Model Loading](/deployment/on-device/sdk/model-loading) for the routing model.
 - **Service-side load progress** — when routing through the model service, `LeapModelDownloader.loadModel`'s `progress` callback now fires for service-side downloads too (was previously local-path-only).

@@ -266,7 +265,7 @@
 - New `with(cacheOptions:)` builders on `LiquidInferenceEngineOptions` and `LiquidInferenceEngineManifestOptions`.
 - New `LiquidCacheOptions.enabled(path:)` static factory — Swift analog of `ModelLoadingOptions.cacheOptions(path:)`.

 (v0.10.4.2 was staged to Sonatype but never released; superseded by 0.10.4.3.)

 ### v0.10.4.1 — 2026-05-07

@@ -274,10 +273,10 @@

 ### v0.10.4 — 2026-05-06

 - **Bounded-LRU `CacheOptions` API** across JVM, Android, Kotlin/Native, Apple, and wasmJs.
 - **`use_mmap=true` is now the engine default** (via vendored IE pin `v26.02.1-79+`). Model weights are memory-mapped instead of `read(2)`-ed into a heap buffer. See [Memory-mapped model loading by default](#memory-mapped-model-loading-by-default) above for the mobile performance impact.
 - K/N Linux link fix (`--allow-shlib-undefined` for `libinference_engine.so` against modern glibc).
 - Dynamic vendor pipeline + `DT_NEEDED`-based shipped-libs verify; `inference_engine` RUNPATH=`$ORIGIN` cascade for Linux/Windows shared vendor libs.
 - `NativeLibLoader` cross-platform load fixes (resource extraction + Windows pre-load topo-retry).
 - Three release-gate smokes (Linux K/N, Apple SwiftPM consumer, Windows JVM) wired into CI.

@@ -286,9 +285,9 @@
 Additive fix release for Linux/MinGW Kotlin/Native consumers. Apple/SPM consumers see no API or behavior changes vs v0.10.0.

 - `leap-sdk` Linux/MinGW K/N artifacts on Maven Central now publish a `-natives.zip` classifier containing the runtime `.so`/`.dll` libraries.
 - New `ai.liquid.leap.nativelibs` Gradle plugin auto-wires the natives ZIP into consumer K/N executables.
 - `leap-openai-client` now publishes Linux/MinGW K/N klibs.

 ### v0.10.0 — 2026-04-28

 Initial Kotlin Multiplatform unification release. See [the 0.9.x → 0.10.x section above](#0-9-x-0-10-x-kotlin-multiplatform-unification) for the full migration story.
@@ -1,21 +1,21 @@
 ---
 title: "Ollama"
 description: "Deploy Liquid AI LFM models with Ollama. Pull, configure, and serve LFM2.5 models locally with an OpenAI-compatible API."
 ---

 <Tip>
  Use Ollama for quick local model serving with a simple CLI or Docker-based deployment.
 </Tip>

 Ollama uses GGUF models and supports GPU acceleration (CUDA, Metal, ROCm).
 
 <Warning>
-  The official Ollama v0.17.0 (latest stable) from [ollama.com](https://ollama.com) fails with a `missing tensor 'output_norm.weight'` error on the `lfm2moe` architecture. This affects all LFM MoE models (e.g. LFM2-24B-A2B, LFM2-8A-A1B). To run any LFM MoE model you specifically need [v0.17.1-rc0](https://github.com/ollama/ollama/releases/tag/v0.17.1-rc0) or later.
+  The official Ollama v0.17.0 (latest stable) from [ollama.com](https://ollama.com) fails with a `missing tensor 'output_norm.weight'` error on the `lfm2moe` architecture. This affects all LFM MoE models (e.g. LFM2-24B-A2B, LFM2-8B-A1B). To run any LFM MoE model you specifically need [v0.17.1-rc0](https://github.com/ollama/ollama/releases/tag/v0.17.1-rc0) or later.
 </Warning>
 
 <div className="colab-link">
  <a href="https://colab.research.google.com/github/Liquid4All/docs/blob/main/notebooks/LFM2_Inference_with_Ollama.ipynb" target="_blank">
    <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open in Colab"></img>
  </a>
 </div>

@@ -52,15 +52,15 @@
    docker exec -it ollama ollama run hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF
    ```

    See the [Ollama Docker documentation](https://ollama.com/blog/ollama-is-now-available-as-an-official-docker-image) for more details.
  </Tab>
 </Tabs>

 ## Using LFM2 Models

 Ollama can load GGUF models directly from Hugging Face or from local files.

 ### Running GGUFs

 You can run LFM2 models directly from Hugging Face:

@@ -107,7 +107,7 @@
  PARAMETER stop "<|endoftext|>"
  ```

  Import the model with the Modelfile:

  ```bash
  ollama create my-model -f Modelfile
@@ -138,11 +138,11 @@
 ollama run hf.co/LiquidAI/LFM2.5-1.2B-Instruct-GGUF "What is machine learning?"
 ```

 If you imported a model with a custom name using a Modelfile, use that name instead (e.g., `ollama run my-model`).

 ## Serving Models

 Ollama automatically starts a server on `http://localhost:11434` with an OpenAI-compatible API for programmatic access.

 ### Python Client

@@ -166,7 +166,7 @@
 ```

 <Accordion title="Curl request examples">
  Ollama provides two native API endpoints:

  **Generate API** (simple completion):

@@ -191,7 +191,7 @@

 ## Vision Models

 LFM2-VL GGUF models can also be used for multimodal inference with Ollama.

 <Accordion title="Interactive Chat with Images">
  Run a vision model directly and provide images in the chat:
@@ -215,7 +215,7 @@

 <Accordion title="Using the API">
  ```python
  from openai import OpenAI
  import base64

  client = OpenAI(
@@ -224,8 +224,8 @@
  )

  # Encode image to base64
  with open("image.jpg", "rb") as image_file:
      image_data = base64.b64encode(image_file.read()).decode("utf-8")

  response = client.chat.completions.create(
      model="hf.co/LiquidAI/LFM2.5-VL-1.6B-GGUF",

@@ -1,7 +1,6 @@
 ---
 title: "Advanced Features"
 description: "GenerationOptions, JSONSchemaGenerator, function-calling type references — same surface everywhere."
-noindex: true
 ---
 
 <Warning>
@@ -16,22 +15,22 @@

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    `GenerationOptions` is a Kotlin `data class` bridged into Swift. Kotlin parameter defaults don't survive the ObjC bridge, so the canonical Swift idiom is the parameterless init plus chained `.with(...)` builders:

    ```swift
    public class GenerationOptions {
      public var temperature: Float?
      public var topP: Float?
      public var minP: Float?
      public var repetitionPenalty: Float?
      public var topK: Int32?
      public var rngSeed: Int64?
      public var jsonSchemaConstraint: String?
      public var functionCallParser: LeapFunctionCallParser?
      public var injectSchemaIntoPrompt: Bool        // default true
      public var maxTokens: Int32?
      public var inlineThinkingTags: Bool            // default false
      public var enableThinking: Bool                // default false
      public var extras: String?

      public convenience init()
@@ -77,7 +76,7 @@
  </Tab>
 </Tabs>

 - **Sampling fields** — `temperature`, `topP`, `minP`, `topK`, and `repetitionPenalty`. Use the model bundle's recommended values; arbitrary defaults from generic tutorials usually underperform.
 - **`rngSeed`** — deterministic sampling seed for tests and reproducible runs.
 - **`maxTokens`** — maximum completion tokens to generate. Prompt tokens do not count toward this cap.
 - **`jsonSchemaConstraint`** — JSON Schema string for constrained generation. Use the higher-level helpers — Swift `options.with(jsonSchema: T.jsonSchema())` / Kotlin `setResponseFormatType<T>()` — instead of writing the schema by hand.

@@ -1,14 +1,13 @@
 ---
 title: "AI Agent Usage Guide"
 description: "End-to-end recipes for building AI agents with the LEAP SDK — same patterns across iOS, macOS, Android, JVM, and native."
-noindex: true
 ---
 
 <Warning>
 The LEAP SDK is deprecated and this page is no longer maintained. Build on llama.cpp directly instead — see [Migrating from LEAP SDK](/deployment/on-device/llama-cpp/migrating-from-leap-sdk).
 </Warning>

 This guide walks through the patterns for building a real AI agent — multi-turn conversation, function calling with tool dispatch, multimodal inputs, and a complete view-model wiring. The cross-platform pages cover individual APIs in depth — start here for the full picture, then drill into the dedicated references when you need details.

 ## Architecture

@@ -46,7 +45,7 @@
    private func handle(_ response: MessageResponse) {
        switch onEnum(of: response) {
        case .chunk(let chunk):
            currentText += chunk.text
        case .reasoningChunk(let reasoning):
            log("Reasoning:", reasoning.reasoning)
        case .functionCalls(let payload):
@@ -57,7 +56,7 @@
            // `audio.samples` is `KotlinFloatArray` — bridge to `[Float]` via
            // `LeapSDK.ArrayConversionsKt.floatArrayToNSData(array:)` if your
            // renderer expects a Swift array (see the demo in leap-ui-demo/shared/).
            audioPlayer.enqueue(audio.samples, sampleRate: Int(audio.sampleRate))
        case .complete(let completion):
            currentText = ""
            if let stats = completion.stats {
@@ -74,7 +73,7 @@
            is MessageResponse.Chunk -> _text.value += response.text
            is MessageResponse.ReasoningChunk -> Log.d(TAG, "Reasoning: ${response.reasoning}")
            is MessageResponse.FunctionCalls -> {
                response.functionCalls.forEach { call -> dispatch(call) }
            }
            is MessageResponse.AudioSample -> audioPlayer.enqueue(response.samples, response.sampleRate)
            is MessageResponse.Complete -> {
@@ -168,20 +167,20 @@

 Define `runtimeDispatch(_:)` as your tool-call → result router: validate arguments, call the underlying implementation, JSON-encode the result. Register the corresponding `LeapFunction` definitions on the conversation before you start the loop — see [Function Calling](./function-calling).

 ## Multimodal inputs

 <Info>
 **Multimodality is model-specific.** Most multimodal models ship as text + one other modality (vision OR audio), not both. Send image parts (Swift `ChatMessageContent.fromJPEGData(_:)` / Kotlin `ImageUtils.fromBitmap(...)`) only to a vision-capable model, and audio parts (Swift `ChatMessageContent.fromWAVData(_:)` / Kotlin `ChatMessageContent.Audio(...)`) only to an audio-capable model. Verify on the model's [Hugging Face card](https://huggingface.co/LiquidAI) before wiring up the input.
 </Info>

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    // Vision-capable model
    let imageMessage = ChatMessage(
      role: .user,
      content: [.text("Describe what you see."), ChatMessageContent.fromJPEGData(jpegData)],
      reasoningContent: nil,
      functionCalls: nil
    )

@@ -206,7 +205,7 @@
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    // Vision-capable model
    val imageMessage = ChatMessage(
        role = ChatMessage.Role.USER,
        content = listOf(
            ChatMessageContent.Text("Describe what you see."),
@@ -267,7 +266,7 @@
            isLoading = true
            defer { isLoading = false }
            do {
                let runner = try await downloader.loadModel(
                    modelName: "LFM2.5-1.2B-Instruct",
                    quantizationType: "Q4_K_M"
                )
@@ -433,7 +432,7 @@
 - **Always handle every `MessageResponse` case.** Even if you only care about `.chunk` and `.complete`, give `.functionCalls`, `.audioSample`, and `.reasoningChunk` explicit (empty) branches — otherwise an exhaustive switch will fail to compile when a new variant is added.
 - **Cancel before re-issuing.** Don't start a second `generateResponse(...)` while one is in flight. Either cancel the previous `Task` / `Job`, or check `conversation.isGenerating` first.
 - **Don't `runBlocking` in production paths.** It's fine in `onCleared()` for guaranteed cleanup (because `viewModelScope` is already cancelled at that point). Anywhere else, it freezes the calling thread.
 - **Use `cacheDir` (Android) / `cachesDirectory` (iOS) for KV-cache reuse paths.** They're regenerable — letting the OS reclaim them on storage pressure is the right semantics. See [Model Loading → KV cache reuse](./model-loading#kv-cache-reuse).
 - **Validate tool-call arguments before dispatching.** The `arguments: Map<String, Any?>` (Kotlin) / `[String: Any?]` (Swift) shape is unsafe by design — defensively coerce types and apply business-level invariants.
 - **Match the model's recommended sampling parameters.** The LEAP bundle manifest (`sampling_parameters` under `generation_time_parameters` in each `<Quant>.json` on [LiquidAI/LeapBundles](https://huggingface.co/LiquidAI/LeapBundles)) carries defaults tuned per checkpoint for the llama.cpp engine the SDK runs. Overriding `temperature` and friends often hurts quality more than it helps — start from the manifest values rather than the HF model card defaults (the two can differ).

@@ -442,22 +441,22 @@
 <Tabs>
  <Tab title="iOS / macOS">
    - iOS deployment target: **17.0+** · macOS: **15.0+**
    - Xcode 16.0+, Swift 6.0
    - Run model loads inside a `Task` from a `@MainActor` view model. `ModelDownloader` background downloads (via `URLSessionConfiguration.background(withIdentifier:)`) survive app suspension; see [Model Loading](./model-loading#constructing-the-downloader).
    - The voice widget exists on UIKit and AppKit — see [Voice Assistant Widget](./voice-assistant).
  </Tab>
  <Tab title="Android">
    - **Min SDK 31** (Android 12).
    - Use a real device for testing — the emulator may crash loading model bundles.
    - `LeapModelDownloader` (the Android one) requires `POST_NOTIFICATIONS` at runtime on Android 13+ and a few manifest entries — see [Quick Start → Install the SDK](./quick-start#2-install-the-sdk).
    - Background prefetch uses `requestDownloadModel(...)`, which enqueues the WorkManager downloader and runs it as a foreground worker while files transfer. The SDK ships notification configuration via `LeapModelDownloaderNotificationConfig`.
    - For most cases, hold the runner in a `ViewModel` with `viewModelScope`. Unload via `runBlocking(Dispatchers.IO) { runner.unload() }` in `onCleared()`.
  </Tab>
  <Tab title="JVM / Linux native / Windows native">
    - JVM: JDK 11+. No `Context` parameter, no foreground service, no notifications — `LeapDownloader` is a simple async fetcher with a configurable `saveDir`.
    - Linux native runtime: glibc **2.34+** (Ubuntu 22.04, Debian 12, RHEL 9 or newer). Older hosts fail at process start.
    - Windows native: Windows 10+. DLLs co-locate next to the `.exe` (Windows' standard search order finds them).
    - **Pin to 0.10.7 or newer** for Kotlin/Native — earlier 0.10.x releases (0.10.0, 0.10.1) have unresolved cinterop / linker issues that prevent producing a working executable; the fixes shipped in the 0.10.4.x point releases (SPM) and v0.10.6 / v0.10.7 (Android-SDK repo). See [Desktop & Native Platforms](./desktop-platforms).
  </Tab>
 </Tabs>

@@ -465,12 +464,12 @@

 | Symptom | Likely cause / fix |
 |---|---|
 | `LeapModelLoadingException` / `LeapError.modelLoadingFailure` | Missing companion file for multimodal model (mmproj / audio decoder). Verify the manifest or pass explicit paths via `loadSimpleModel(ModelSource(...))`. |
 | Model loads but generates gibberish | Wrong sampling parameters or wrong function-call parser for the model family. Check the model card; default to `LFMFunctionCallParser` for LFM models, `HermesFunctionCallParser` for Qwen3/Hermes. |
 | "ZIP archive corrupted" on download | Network hiccup mid-download. `LeapDownloader` / `LeapModelDownloader` validates SHA-256, so a partial file fails the check. Remove the cache directory and retry. |
 | Generation hangs after `cancel()` | Cancellation is cooperative — the engine checks between tokens. There's at most one extra token of slack. If it's longer, you may be missing a `Job` cancel or the stream is being awaited on a thread other than the one you're cancelling from. |
 | Voice widget records silence | Missing microphone permission, or `AVAudioSession`/Android audio config not set to `playAndRecord` / mono / 16 kHz. See [Voice Assistant Widget](./voice-assistant). |
 | K/N executable fails at start with `dlsym@GLIBC_2.34` | Runtime host's glibc is older than 2.34. Upgrade to Ubuntu 22.04+, Debian 12+, RHEL 9+, or build for an older runtime target. |
 | Compile error "@Guide annotation missing" (Swift) | All properties on a `@Generatable` `struct` need a `@Guide`. Annotate every stored property. |

 For deeper failure-mode coverage, see [Utilities → Errors](./utilities#errors).
@@ -1,7 +1,6 @@
 ---
 title: "Cloud AI Comparison"
 description: "Mapping LEAP SDK concepts to cloud chat-completion APIs like OpenAI."
-noindex: true
 ---
 
 <Warning>
@@ -58,25 +57,25 @@
  </Tab>
  <Tab title="Kotlin (Android)">
    ```kotlin
    val downloader = LeapModelDownloader(context)
    val runner = downloader.loadModel(
        modelName = "LFM2.5-1.2B-Instruct",
        quantizationType = "Q4_K_M",
    )
    ```
  </Tab>
  <Tab title="Kotlin (JVM / native)">
    ```kotlin
    val downloader = LeapDownloader(LeapDownloaderConfig(saveDir = cacheDir))
    val runner = downloader.loadModel(
        modelName = "LFM2.5-1.2B-Instruct",
        quantizationType = "Q4_K_M",
    )
    ```
  </Tab>
 </Tabs>

 The returned `ModelRunner` plays the same role as the cloud API's client object — except it carries the model weights. Release it and you'll have to load again before generating.

 ## 2. Request generation

@@ -192,7 +191,7 @@
    ```
  </Tab>
  <Tab title="Kotlin (Android)">
    Use `viewModelScope` (or `lifecycleScope` for activity-bound work). The flow is collected on the coroutine; cancellation is cooperative.

    ```kotlin
    class ChatViewModel(application: Application) : AndroidViewModel(application) {
@@ -219,7 +218,7 @@
    ```
  </Tab>
  <Tab title="Kotlin (JVM / native)">
    Use any coroutine scope — `runBlocking` for CLIs, a custom `CoroutineScope` for server-side code, or `MainScope()` for Compose for Desktop.

    ```kotlin
    fun main() = runBlocking {
@@ -243,7 +242,7 @@
 | Concept | OpenAI | LEAP |
 |---|---|---|
 | Role-tagged messages | `{"role": "user", "content": "..."}` | `ChatMessage(role: .user, textContent: "...")` |
 | Streaming responses | `stream=True` iterator | `SkieSwiftFlow<MessageResponse>` (Swift, iterable with `for try await`) / `Flow<MessageResponse>` (Kotlin) |
 | Function calling | Tool definitions + `tool_calls` field | `registerFunction(LeapFunction)` + `MessageResponse.FunctionCalls` |
 | Structured output | `response_format = json_schema` | Swift `options.with(jsonSchema: T.jsonSchema())` / Kotlin `setResponseFormatType<T>()` |
 | Token usage stats | `usage` object on completion | `Complete.stats` (`promptTokens`, `completionTokens`, `tokenPerSecond`) |
@@ -252,8 +251,8 @@

 - **No remote endpoint.** You ship the model with the app (or download it the first time it runs). Latency is bounded by device CPU/GPU, not network round-trips.
 - **Explicit lifecycle.** Hold a `ModelRunner` reference; `unload()` when done. Cloud clients never load anything explicitly.
 - **Multimodal inputs go in `content` array, same as OpenAI.** Image and audio parts use the same OpenAI `image_url` / `input_audio` wire format.
 - **Companion files for multimodal models.** Vision and audio-capable models need an `mmproj` (vision) and/or audio decoder/tokenizer co-located on disk. Manifest-based loading handles this automatically; `loadSimpleModel` accepts explicit `mmprojPath` / `audioDecoderPath` / `audioTokenizerPath`.

 ## Next steps


@@ -1,7 +1,6 @@
 ---
 title: "Constrained Generation"
 description: "Generate structured JSON output with compile-time validation — same approach on every platform."
-noindex: true
 ---
 
 <Warning>
@@ -104,7 +103,7 @@
        generationOptions: options
    ) {
        if case .complete(let completion) = onEnum(of: response) {
            let jsonText = completion.fullMessage.content.compactMap { part -> String? in
                if case let .text(t) = onEnum(of: part) { return t.text }
                return nil
            }.joined()
@@ -150,12 +149,12 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let schemaString = JSONSchemaGenerator.getJSONSchema(for: Joke.self)
    let message = ChatMessage(
        role: .user,
        content: [.text("Tell me a programming joke following this JSON Schema: \(schemaString)")],
        reasoningContent: nil,
        functionCalls: nil
    )
    ```

@@ -163,9 +162,9 @@
  </Tab>
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    val jsonSchema = JSONSchemaGenerator.getJSONSchema<CityFact>()
    conversation.generateResponse(
        "Show the city facts about Tokyo following this JSON Schema: $jsonSchema",
        options
    )
    ```
@@ -185,7 +184,7 @@
 | Enum | `String` with constrained `enumValues` | Kotlin `enum class` (plain name used as value) |
 | Object | nested `@Generatable` `struct` | nested `@Generatable` `data class` |
 | Array | `[T]` of any supported type | `List<T>` / `MutableList<T>` of supported type |
 | Optional | `Optional<T>` (`T?`) | nullable `T?` |

 ## Complex nested structures

@@ -193,7 +192,7 @@
  <Tab title="Swift (iOS / macOS)">
    ```swift
    @Generatable("A recipe with ingredients and instructions")
    struct Recipe: Codable {
        @Guide("Name of the dish")
        let name: String

@@ -285,7 +284,7 @@

 ### Lower temperature for structured output

 Temperature `0.1–0.3` typically improves adherence to the schema — high-temperature sampling adds variation that doesn't help when you need parseable JSON. Use the per-model defaults the LFM model cards recommend (e.g. `0.1` for instruct/VL, `0.3` for LFM2 text) and lower from there if the model strays.

 ### Validate the decoded output

@@ -332,12 +331,12 @@
 | Error | When it happens |
 |---|---|
 | `LeapGeneratableSchematizationException` (Kotlin) | The data class can't be translated to JSON Schema (unsupported field type, missing primary-constructor declaration). |
 | `LeapGeneratableDeserializationException` (Kotlin) | The generated JSON can't be deserialized into the target data class. |
 | Swift `DecodingError` | `JSONDecoder` rejects the generated payload — usually because the model output contains stray prose alongside the JSON; filter `Complete.fullMessage.content` for the `.text` fragments first. |

 ## Troubleshooting

 **"External macro implementation could not be found" (Swift)** — clean the build folder, restart Xcode, verify Swift 5.9+.

 **Generated JSON includes prose alongside the JSON object** — common with low-quality prompts. Add "Reply with only the JSON object" to the user message, lower temperature, and filter `.text` content fragments before decoding.


@@ -1,7 +1,6 @@
 ---
 title: "Conversation & Generation"
 description: "Reference for ModelRunner, Conversation, MessageResponse, and GenerationOptions — same API on every platform."
-noindex: true
 ---
 
 <Warning>
@@ -65,7 +64,7 @@

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    `Conversation` is a Kotlin `interface` bridged to Swift as a protocol — the get-only properties surface as `{ get }` in Swift. The generation methods return a SKIE-bridged `SkieSwiftFlow<MessageResponse>` (iterable with `for try await`):

    ```swift
    public protocol Conversation {
@@ -134,12 +133,12 @@

 ### Streaming generation

 The async stream is the recommended way to drive generation — both platforms emit the same `MessageResponse` cases in the same order. Cancel the consuming task / coroutine to stop generation cleanly.

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let user = ChatMessage(role: .user, textContent: "Hello! What can you do?")
    let options = GenerationOptions()
      .with(temperature: 0.3)
      .with(minP: 0.15)
@@ -226,7 +225,7 @@
 </Tabs>

 <Info>
 **Cancellation.** Cancelling the Swift `Task` or the Kotlin coroutine `Job` stops generation and frees native resources. On both platforms cancellation is cooperative — the engine checks between tokens, so there's at most one extra token of slack after `cancel()`.
 </Info>

 ### Export chat history
@@ -236,7 +235,7 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let jsonString: String = conversation.exportToJSON()
    ```
  </Tab>
  <Tab title="Kotlin (all platforms)">
@@ -290,7 +289,7 @@
 - **`ReasoningChunk`** — thinking-style tokens emitted by reasoning models (wrapped between `<think>` / `</think>` upstream). Only fires when `GenerationOptions.enableThinking = true` *and* the model supports it.
 - **`FunctionCalls`** — one or more tool invocations the model wants you to execute. See [Function Calling](./function-calling).
 - **`AudioSample`** — float32 mono PCM frames from audio-capable checkpoints. The sample rate is constant for a generation; route the frames to a renderer.
 - **`Complete`** — final marker. `fullMessage` is the assembled assistant `ChatMessage` (also present in `conversation.history`). `stats` is nullable (`GenerationStats?`); when present it holds `promptTokens`, `completionTokens`, `totalTokens`, `tokenPerSecond` (non-nullable `Float`), and `cachedPromptTokens`.

 ### `GenerationFinishReason`

@@ -310,22 +309,22 @@

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    `GenerationOptions` is a Kotlin `data class` bridged into Swift. Kotlin parameter defaults don't survive the ObjC bridge, so the canonical Swift idiom is the parameterless init plus chained `.with(...)` builders from `ConvenienceExtensions.swift`:

    ```swift
    public class GenerationOptions {
      public var temperature: Float?
      public var topP: Float?
      public var minP: Float?
      public var repetitionPenalty: Float?
      public var topK: Int32?
      public var rngSeed: Int64?
      public var jsonSchemaConstraint: String?
      public var functionCallParser: LeapFunctionCallParser?
      public var injectSchemaIntoPrompt: Bool        // default true
      public var maxTokens: Int32?
      public var inlineThinkingTags: Bool            // default false
      public var enableThinking: Bool                // default false
      public var extras: String?

      public convenience init()                      // builder entry point
@@ -395,12 +394,12 @@
  </Tab>
 </Tabs>

 - **Sampling fields** (`temperature`, `topP`, `minP`, `topK`, `repetitionPenalty`) — standard sampling knobs. Use the values from the LEAP bundle manifest (`sampling_parameters` under `generation_time_parameters` in each model's `<Quant>.json` on [LiquidAI/LeapBundles](https://huggingface.co/LiquidAI/LeapBundles)); they're tuned per checkpoint by the training team and differ from the HF model card defaults (the manifest values are the llama.cpp-engine path the SDK runs). Arbitrary "0.7" defaults from generic AI tutorials usually underperform.
 - **`rngSeed`** — set for deterministic / reproducible output (testing, debugging). Default is non-deterministic.
 - **`maxTokens`** — cap the response length. The model stops after this many completion tokens (prompt tokens don't count). Defaults to "until EOS or context limit." Useful for cost control with constrained output.
 - **`jsonSchemaConstraint`** — JSON Schema string for constrained generation. Use the higher-level helpers — Swift `options.with(jsonSchema: T.jsonSchema())` (or `GenerationOptionsCompat.setResponseFormat(jsonSchema:)`) / Kotlin `setResponseFormatType<T>()` — with `@Generatable` types. See [Constrained Generation](./constrained-generation).
 - **`injectSchemaIntoPrompt`** — when `true` (default), the schema is appended to the system message for semantic guidance *in addition* to the structural constraint at decode time. Set `false` to skip the prompt injection (matches `llama-server` grammar mode) — saves prompt tokens for large schemas.
 - **`functionCallParser`** — picks the tokenizer expected by the model. `LFMFunctionCallParser` (default) for Liquid Foundation Models; `HermesFunctionCallParser()` for Hermes/Qwen3 formats; `null` to receive raw tool-call text in `Chunk`s.
 - **`enableThinking`** — turn on reasoning mode for models that support it (e.g. LFM2.5-Thinking). Reasoning tokens arrive as `ReasoningChunk`s.
 - **`inlineThinkingTags`** — when `true`, thinking tokens are emitted as ordinary `Chunk`s with the literal `<think>...</think>` tags intact (instead of `ReasoningChunk`). `ChatMessage.reasoningContent` is still populated on the final message.
 - **`extras`** — backend-specific JSON payload (internal use).
@@ -416,4 +415,4 @@
                             cache is disabled or missed.
 ```

 `cachedPromptTokens` is useful for observing KV-cache effectiveness — a high ratio of cached tokens to total prompt tokens means the prefix matched and you skipped the prefill compute for those tokens.
@@ -1,14 +1,13 @@
 ---
 title: "Desktop & Native Platforms"
 description: "Run the LEAP SDK on JVM desktop, native Linux, native Windows, and macOS — same API as Android and iOS."
-noindex: true
 ---
 
 <Warning>
 The LEAP SDK is deprecated and this page is no longer maintained. Build on llama.cpp directly instead — see [Migrating from LEAP SDK](/deployment/on-device/llama-cpp/migrating-from-leap-sdk).
 </Warning>

 The LEAP SDK is a Kotlin Multiplatform library. The same conversation, model-loading, and generation APIs you use on Android and iOS run unchanged on JVM desktop and Kotlin/Native targets. This page covers installation and per-platform notes for everything outside the mobile guides.

 <Info>
 **Where to start by platform:**
@@ -28,12 +27,12 @@
 |---|---|---|---|---|
 | **Android** | ARM64 | API 31 (Android 12) | JNI | See [Quick Start](/deployment/on-device/sdk/quick-start). |
 | **JVM Desktop** | macOS ARM64 · Linux x86_64 · Linux aarch64 · Windows x86_64 · Windows aarch64 | JDK 11 | JNI | This page. |
 | **Linux native** | x86_64 · aarch64 | glibc 2.34+ (Ubuntu 22.04, Debian 12, RHEL 9) | C-interop (Kotlin/Native) | This page. |
 | **Windows native** | x86_64 (MinGW toolchain) | Windows 10+ | C-interop (Kotlin/Native) | This page. |
 | **iOS** | ARM64 (device + simulator) | iOS 17 | C-interop | See [Quick Start](/deployment/on-device/sdk/quick-start). |
 | **macOS** | ARM64 (Apple Silicon) | macOS 15 | C-interop (Kotlin/Native `macosArm64`) | Swift API: see [Quick Start](/deployment/on-device/sdk/quick-start). For JVM on macOS, use the **JVM Desktop** row above. The `macosArm64` Kotlin/Native klib is niche — see [macOS (Apple Silicon)](#macos-apple-silicon) below. |

 x86 JVM hosts (e.g. Linux/Windows x86_64 desktop JVMs) load the engine via JNI. JNI binaries ship inside the `leap-sdk` JAR — no extra setup needed.

 ## JVM Desktop

@@ -109,7 +108,7 @@

 ### Loading a model

 `LeapDownloader` is the cross-platform downloader. Point it at a writable directory and call `loadModel(modelName:, quantizationType:)` for manifest-based downloads, or `loadSimpleModel(model: ModelSource(...))` for a GGUF you already have on disk.

 ```kotlin
 import ai.liquid.leap.manifest.LeapDownloader
@@ -150,7 +149,7 @@
 }
 ```

 ### Loading a sideloaded GGUF

 When the file already lives somewhere on disk (CI artifact, app resource folder, network share), skip the manifest lookup:

@@ -170,11 +169,11 @@

 - **Memory.** Plan for at least `model_size_on_disk + 1 GiB` of free RAM. With `use_mmap=true` (the default since v0.10.4 — see the [changelog](/deployment/on-device/leap-sdk-changelog#memory-mapped-model-loading-by-default)) the OS pages weights in lazily, so resident memory grows as the model is exercised rather than at load time.
 - **Threads.** The engine defaults to a sensible CPU thread count for the host (`CpuThreadAdvisor.getRecommendedThreadCount()`). Override by passing `ModelLoadingOptions(cpuThreads = N)` through `loadModel(...)` if you need to share the box with other workloads.
 - **GPU acceleration.** Available on macOS (Metal, automatic) and on Linux JVM builds with a CUDA-capable GPU when the matching native variant is on the classpath. GPU offload is configured through the `extras` JSON payload on `ModelLoadingOptions` (advanced use only — most desktop workloads run pure-CPU).

 ## Linux native (Kotlin/Native)

 For statically-targeted Linux binaries — CLIs, daemons, embedded server processes — the SDK ships `linuxX64` and `linuxArm64` Kotlin/Native targets. The engine is shipped as a separate `-natives.zip` classifier artifact rather than embedded in a JAR, because Kotlin/Native has no runtime resource-extraction equivalent to JVM's `getResourceAsStream`.

 ### Installation (recommended: `ai.liquid.leap.nativelibs` plugin)

@@ -218,10 +217,10 @@
 ./gradlew linkReleaseExecutableLinuxX64
 ```

 The resulting binary lives at `build/bin/linuxX64/releaseExecutable/`, alongside the `.so` files the plugin installed (`libinference_engine.so`, `libinference_engine_llamacpp_backend.so`, `libie_zip.so`, plus their transitive dependencies). Keep them co-located when you ship — the cinterop manifest bakes `-rpath=$ORIGIN` into the binary so the dynamic linker resolves siblings.

 <Warning>
 **Versions 0.10.0 and 0.10.1 cannot link a working Kotlin/Native executable** due to Maven Central / cinterop issues; v0.10.2 and v0.10.3 were never published, and the fixes shipped across v0.10.4.x, v0.10.6, and v0.10.7. Maven Central is immutable per GAV, so the older versions cannot be republished — pin to **0.10.7 or newer**. See [the changelog](/deployment/on-device/leap-sdk-changelog#kotlin-native-linux-windows) for the full story.
 </Warning>

 ### Manual recipe (if you can't apply the plugin)
@@ -259,8 +258,8 @@

 ### Runtime requirements

 - **glibc 2.34+** — Ubuntu 22.04, Debian 12, RHEL 9, or newer. The pinned glibc-2.19 sysroot Kotlin/Native links against is *only* used at link time; the engine `.so` is built against modern glibc and calls into symbols like `dlsym@GLIBC_2.34` at runtime. Older hosts fail at process start with a glibc version error.
 - **Co-located `.so` files** — the dynamic linker uses `rpath=$ORIGIN` from the binary, plus `DT_RUNPATH=$ORIGIN:$ORIGIN/../lib` from the engine `.so` itself. The Copy task installs every dependent library (umbrella libs, `libllama`, `libmtmd`, `libggml*`, per-CPU-microarch GGML variants, SONAME aliases). Don't cherry-pick from the natives ZIP — ship the whole set.

 The Maven coordinates for the `-natives.zip` artifacts:

@@ -269,7 +268,7 @@

 ## Windows native (MinGW x64)

 The same Kotlin/Native flow works for Windows x86_64 via the MinGW-w64 toolchain.

 ```kotlin
 plugins {
@@ -292,7 +291,7 @@
 ./gradlew linkReleaseExecutableMingwX64
 ```

 The plugin installs `inference_engine.dll`, `libinference_engine_llamacpp_backend.dll`, `ie_zip.dll`, and their transitive DLLs into the link output directory. Windows' standard DLL search order finds DLLs co-located with the `.exe` before checking `PATH`, so no `rpath` plumbing is needed — just ship the executable and its sibling DLLs together.

 The Maven coordinates for the `-natives.zip` artifact:

@@ -313,7 +312,7 @@
 | iOS | macOS |
 |---|---|
 | `UIViewControllerRepresentable` | `NSViewControllerRepresentable` |
 | `VoiceAssistantViewController` (UIKit) | `VoiceAssistantNSViewController` (AppKit) |
 | `UIHostingController` | `NSHostingController` |
 | `import UIKit` | `import AppKit` |
 | Deployment target: iOS 17 | Deployment target: macOS 15 |
@@ -326,11 +325,11 @@
 )
 ```

 The XCFramework slice for macOS ARM64 is in the same zip as the iOS slices. The released framework ships exactly three slices — `ios-arm64`, `ios-arm64-simulator`, `macos-arm64`; **Mac Catalyst is not supported**, and the iOS simulator slice is ARM64-only (Intel-Mac simulator hosts cannot run it).

 ### From Kotlin (JVM, Compose for Desktop)

 If you're targeting macOS as a JVM host — for example with Compose Multiplatform Desktop, IntelliJ-style tooling, or a Kotlin CLI — use the [JVM Desktop instructions](#jvm-desktop) above. The `leap-sdk` JAR ships a macOS ARM64 JNI binary.

 ```kotlin
 dependencies {
@@ -342,7 +341,7 @@
 The voice widget renders via Compose for Desktop on JVM macOS; the same `VoiceAssistantStore` API you use on iOS/Android works unchanged.

 <Info>
 **`macosArm64` Kotlin/Native target.** The SDK also ships a `macosArm64` Kotlin/Native klib for shared-code KMP projects that want to compile native macOS binaries directly (no JVM, no Swift). Most macOS consumers should prefer either Swift (via SPM) or JVM — the Kotlin/Native macOS path exists primarily so KMP `commonMain` code is portable to macOS, not as a recommended end-user entry point.
 </Info>

 ## Picking the right target

@@ -1,7 +1,6 @@
 ---
 title: "Function Calling"
 description: "Tool use with LeapFunction — same API on every platform, with Hermes and Pythonic parsers."
-noindex: true
 ---
 
 <Warning>
@@ -157,9 +156,9 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let toolMessage = ChatMessage(
      role: .tool,
      textContent: #"{"temperature":72,"conditions":"sunny"}"#
    )

    let updatedHistory = conversation.history + [toolMessage]
@@ -169,7 +168,7 @@
  </Tab>
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    val toolMessage = ChatMessage(
        role = ChatMessage.Role.TOOL,
        content = listOf(
            ChatMessageContent.Text("""{"temperature":72,"conditions":"sunny"}""")
@@ -188,12 +187,12 @@

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    Both types are Kotlin `data class`es bridged into Swift. `@ObjCName` annotations rename the `description` parameter on the Swift inits to `functionDescription:` / `parameterDescription:`.

    ```swift
    public class LeapFunction {
      public var name: String
      public var functionDescription: String       // ObjC-renamed from Kotlin `description`
      public var parameters: [LeapFunctionParameter]

      public init(name: String, functionDescription: String, parameters: [LeapFunctionParameter])
@@ -202,13 +201,13 @@
    public class LeapFunctionParameter {
      public var name: String
      public var type: LeapFunctionParameterType
      public var parameterDescription: String      // ObjC-renamed from Kotlin `description`
      public var optional: Bool

      public init(
        name: String,
        type: LeapFunctionParameterType,
        parameterDescription: String,
        optional: Bool                              // no default in Swift — pass `false` for required
      )
    }
@@ -285,13 +284,13 @@
  <Tab title="Swift (iOS / macOS)">
    ```swift
    LeapFunction(
      name: "get_weather",
      functionDescription: "Query the weather of cities",
      parameters: [
        LeapFunctionParameter(
          name: "cities",
          type: LeapFunctionParameterType.LeapArr(
            itemType: LeapFunctionParameterType.LeapStr(enumValues: nil, description: nil),
            description: nil
          ),
          parameterDescription: "Names of the cities to query weather for",
@@ -300,7 +299,7 @@
        LeapFunctionParameter(
          name: "unit",
          type: LeapFunctionParameterType.LeapStr(
            enumValues: ["celsius", "fahrenheit"],
            description: nil
          ),
          parameterDescription: "Temperature unit",
@@ -313,20 +312,20 @@
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    LeapFunction(
      name = "get_weather",
      description = "Get the weather forecast of cities",
      parameters = listOf(
        LeapFunctionParameter(
          name = "cities",
          type = LeapFunctionParameterType.LeapArr(
            itemType = LeapFunctionParameterType.LeapStr()
          ),
          description = "City names to query",
        ),
        LeapFunctionParameter(
          name = "temperature_unit",
          type = LeapFunctionParameterType.LeapStr(
            enumValues = listOf("Fahrenheit", "Celsius", "Kelvin")
          ),
          description = "Units for temperature",
        ),

@@ -1,7 +1,6 @@
 ---
 title: "Messages & Content"
 description: "ChatMessage, ChatMessageContent, audio format requirements — same shape on every platform."
-noindex: true
 ---
 
 <Warning>
@@ -20,8 +19,8 @@
    public class ChatMessage {
      public var role: ChatMessage.Role
      public var content: [ChatMessageContent]
      public var reasoningContent: String?
      public var functionCalls: [LeapFunctionCall]?

      // Primary init — pass `reasoningContent: nil, functionCalls: nil` for ordinary messages.
      public init(
@@ -81,11 +80,11 @@

 ### Serialization

 Round-trip the message through `kotlinx.serialization` — there is no separate "from `[String: Any]`" initializer on either platform.

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    Encode with `LeapJson.encodeToString` (or your own `JSONEncoder` against the OpenAI shape) and decode with the matching Kotlin serializer. See [Utilities → Serialization](./utilities#serialization) for examples that route through `LeapJson`.
  </Tab>
  <Tab title="Kotlin (all platforms)">
    `ChatMessage` is `@Serializable`. Encode with `Json.encodeToString(message)` and decode with `Json.decodeFromString<ChatMessage>(jsonString)` — see [Utilities → Serialization](./utilities#serialization). On error, expect a `LeapSerializationException` (not `LeapSerializationError`).
@@ -96,7 +95,7 @@

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    `ChatMessageContent` is the Kotlin `sealed class` bridged to Swift — switch on its subclasses with SKIE's `onEnum(of:)` helper. There is no native Swift `enum`, no positional `.image(_:)` / `.audio(_:)` factory, and no `init(from json:)`. Use the static factories on the Swift overlay:

    ```swift
    // Text (cross-platform):
@@ -193,11 +192,11 @@
 </Warning>

 <Warning>
 **Mono required.** Stereo or multi-channel WAVs are rejected with an error. Downmix to mono first.
 </Warning>

 <Info>
 **Automatic resampling.** The engine resamples to 16 kHz when needed, but providing 16 kHz audio directly avoids the resampling overhead. For best quality, record at 16 kHz mono.
 </Info>

 ## Creating audio content
@@ -207,8 +206,8 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let wavURL = Bundle.main.url(forResource: "audio", withExtension: "wav")!
    let wavData = try Data(contentsOf: wavURL)

    let message = ChatMessage(
        role: .user,
@@ -223,7 +222,7 @@
  </Tab>
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    val wavBytes = File("/path/to/audio.wav").readBytes()
    val audio = ChatMessageContent.Audio(wavBytes)

    val message = ChatMessage(
@@ -360,7 +359,7 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    for try await response in conversation.generateResponse(message: userMessage) {
        if case .audioSample(let audio) = onEnum(of: response) {
            // audio.samples: [Float] in [-1.0, 1.0]
            // audio.sampleRate: Int (typically 24000 for audio-gen models)

@@ -1,35 +1,34 @@
 ---
 title: "Model Loading"
 description: "Reference for ModelDownloader, LeapDownloader, loadModel, loadSimpleModel, and KV cache reuse."
-noindex: true
 ---
 
 <Warning>
 The LEAP SDK is deprecated and this page is no longer maintained. Build on llama.cpp directly instead — see [Migrating from LEAP SDK](/deployment/on-device/llama-cpp/migrating-from-leap-sdk).
 </Warning>

 The LEAP SDK ships two downloader classes built on the same pipeline. They differ by what platform integration they add:

 | Platform | Class | What it does |
 |---|---|---|
 | **Android** | `LeapModelDownloader` | One-shot `loadModel(...)` that routes through the optional [Leap Model Service](#leap-model-service-android) when installed, plus WorkManager-backed background download staging (`requestDownloadModel` / `observeDownloadProgress`) and foreground-service notifications. |
 | **iOS / macOS (Swift)** | `ModelDownloader` | One-shot `loadModel(...)` and `loadSimpleModel(...)` that route every file transfer through `URLSession`. Pass `sessionConfiguration: .background(withIdentifier:)` for downloads that survive app suspension. Also exposes the underlying `downloadModel` / `requestDownloadModel` / `queryStatus` lifecycle for prefetch flows. The class ships in the `LeapModelDownloader` SPM library product. |
 | **All platforms (iOS, Android, JVM, Linux native, Windows native, macOS Kotlin)** | `LeapDownloader` | The cross-platform manifest loader. One-shot `loadModel(...)` and `loadSimpleModel(...)`. No platform-native background integration — the iOS `ModelDownloader` and Android `LeapModelDownloader` classes wrap one of these internally. |

 All downloader classes return the same `ModelRunner` type. They share an on-disk model cache when pointed at the same directory: `LeapDownloaderConfig.saveDir` for Swift / JVM / native, and `modelFileDir` for Android `LeapModelDownloader`. Once a download has landed, calling `LeapDownloader.loadModel(...)` against the shared cache picks up the files without re-downloading.

 <Info>
 **Parameter naming.** Every loader uses the same parameter labels across Swift and Kotlin:

 - Manifest loaders and lifecycle methods use `modelName:` / `quantizationType:` consistently. Swift `ModelDownloader` exposes `downloadModel(...)`, `requestDownloadModel(...)`, `queryStatus(...)`, and `removeModel(...)`; Android `LeapModelDownloader` exposes `requestDownloadModel(...)`, `requestStopDownload(...)`, `queryStatus(...)`, and `getModelResourceFolder(...)`; cross-platform `LeapDownloader` exposes foreground `downloadModel(...)` / `loadModel(...)` plus cache cleanup helpers.
 - **`ModelSource` (sideloaded)** uses `quantizationId` — the field is part of the source descriptor, not a loader parameter.
 </Info>

 <Info>
 **Swift class vs. SPM product name (v0.10.6+).** In Swift code the class is `ModelDownloader`; the SPM library product / framework module / `import` statement is `LeapModelDownloader`. In 0.10.5 both shared one name, which made the class effectively uninstantiable from Swift due to type-vs-module shadowing. The Kotlin class — and therefore Android consumers — still see `LeapModelDownloader`.
 </Info>

 ## Constructing the downloader

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
@@ -73,9 +72,9 @@
    class LeapModelDownloader(
        private val context: Context,
        modelFileDir: File? = null,
        private val notificationConfig: LeapModelDownloaderNotificationConfig = LeapModelDownloaderNotificationConfig(),
        private val downloaderConfig: LeapDownloaderConfig = LeapDownloaderConfig(),
        private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
    )
    ```

@@ -117,11 +116,11 @@
    ```swift
    extension ModelDownloader {
      public func loadModel(
        modelName: String,
        quantizationType: String,
        options: LiquidInferenceEngineManifestOptions? = nil,
        generationTimeParameters: GenerationTimeParameters? = nil,
        forceDownload: Bool = false,
        downloadProgress: ((_ fraction: Double, _ bytesPerSecond: Int64) -> Void)? = nil
      ) async throws -> ModelRunner
    }
@@ -180,11 +179,11 @@
  <Tab title="Kotlin (Android)">
    ```kotlin
    suspend fun loadModel(
        modelName: String,
        quantizationType: String,
        options: ModelLoadingOptions? = null,
        forceDownload: Boolean = false,
        forceLocal: Boolean = false,
        progress: ((ProgressData) -> Unit)? = null,
    ): ModelRunner
    ```
@@ -213,8 +212,8 @@
  <Tab title="Kotlin (JVM / native)">
    ```kotlin
    suspend fun loadModel(
        modelName: String,
        quantizationType: String,
        options: ModelLoadingOptions? = null,
        generationTimeParameters: GenerationTimeParameters? = null,
        forceDownload: Boolean = false,
@@ -238,9 +237,9 @@

 Find available model and quantization slugs in the [LEAP Model Library](https://leap.liquid.ai/models).

 ## Sideloaded files

 Use this path when you ship the model as an app asset, `adb push` it for development, download it via your own pipeline, or stage a multimodal model with its companion files in a known directory — anything that doesn't go through the LEAP manifest registry.

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
@@ -391,7 +390,7 @@

 ## Fetch without loading

 Useful for onboarding flows that prefetch over Wi-Fi or staging models you'll load later. A subsequent `loadModel(...)` call with the same identifiers picks up the cached files without re-downloading.

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
@@ -399,7 +398,7 @@
    extension ModelDownloader {
      public func downloadModel(
        modelName: String,
        quantizationType: String,
        downloadProgress: ((_ fraction: Double, _ bytesPerSecond: Int64) -> Void)? = nil
      ) async throws -> DownloadedModelManifest

@@ -408,11 +407,11 @@
      // (matches Android idempotent-call semantics).
      public func requestDownloadModel(
        modelName: String,
        quantizationType: String,
        forceDownload: Bool = false
      )
      public func requestStopDownload(modelName: String, quantizationType: String)
      public func queryStatus(modelName: String, quantizationType: String) async -> ModelDownloadStatus
      public func removeModel(modelName: String, quantizationType: String) async

      // Manifest-URL flavours — same shape, keyed by NSURL.
@@ -440,13 +439,13 @@
      public let localMultimodalProjectorPath: String?
      public let localAudioDecoderPath: String?
      public let localAudioTokenizerPath: String?
      public let chatTemplate: String?
    }
    ```
  </Tab>
  <Tab title="Kotlin (Android)">
    ```kotlin
    // Enqueues a unique WorkManager download worker and returns after staging it.
    suspend fun requestDownloadModel(modelName: String, quantizationType: String, forceDownload: Boolean = false)
    suspend fun requestStopDownload(modelName: String, quantizationType: String)
    suspend fun queryStatus(modelName: String, quantizationType: String): ModelDownloadStatus
@@ -480,16 +479,16 @@
    ```swift
    public struct LiquidInferenceEngineOptions {
      public let bundlePath: String
      public let cacheOptions: LiquidCacheOptions?
      public let cpuThreads: UInt32?
      public let contextSize: UInt32?
      public let nGpuLayers: UInt32?
      public let mmProjPath: String?
      public let audioDecoderPath: String?
      public let audioTokenizerPath: String?
      public let audioDecoderUseGpu: Bool       // default false
      public let chatTemplate: String?
      public let useMmap: Bool?
      public let extras: String?
    }

@@ -537,7 +536,7 @@
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    data class ModelLoadingOptions(
        var randomSeed: Long? = null,
        var cpuThreads: Int = CpuThreadAdvisor.getRecommendedThreadCount(),
        var chatTemplate: String? = null,
        var cacheOptions: EngineOptions.CacheOptions? = null,
@@ -577,7 +576,7 @@

 - **`cpuThreads`** — CPU thread count for token generation. Kotlin defaults to `CpuThreadAdvisor.getRecommendedThreadCount()`; Swift defaults to engine pick when `nil`.
 - **`contextSize`** — override the maximum context length. Kotlin defaults to **8192**; Swift defaults to model's recommendation when `nil`.
 - **`useMmap`** — tristate `Boolean?`. `null` (default) defers to the engine default of `true`. Set to `false` to force full-read loading on filesystems where `mmap` misbehaves (some Android scoped-storage paths, certain network mounts). Added in v0.10.5.
 - **`nGpuLayers`** (Swift) — number of transformer blocks to offload to GPU (macOS Metal). `-1` offloads everything.
 - **`audioDecoderUseGpu`** (Swift) — opt the audio decoder onto the Metal backend.
 - **`randomSeed`** (Kotlin) — reproducible sampling seed.
@@ -587,7 +586,7 @@
 - **`extras`** — backend-specific configuration payload (JSON string).

 <Info>
 **Companion files.** GGUF checkpoints look for sibling vision (`mmproj`) and audio (decoder / tokenizer) files unless you override the paths. Co-locate them next to the model file or pass explicit paths via `ModelSource` for vision and audio features.
 </Info>

 ### `GenerationTimeParameters` & `SamplingParameters` (Kotlin)
@@ -615,7 +614,7 @@

 ## KV cache reuse

 `EngineOptions.CacheOptions` (Kotlin) / `LiquidCacheOptions` (Swift) tells the engine to persist KV-cache data between generations so requests sharing a prompt prefix can skip the prefill work for the shared tokens. Added in v0.10.4; Swift convenience surface in v0.10.4.3; per-tier bounded-LRU caps stabilized in v0.10.5.

 <Warning>
 **Disabled by default.** Cache options are `null`/`nil` until you explicitly pass them. Apps that don't opt in see no prefix reuse and no on-disk cache directory — runner load behaves exactly as it did pre-v0.10.4. On Kotlin, `enabled = true` is the sole opt-in gate: a positive `maxEntries` alone is *not* sufficient.
@@ -625,10 +624,10 @@

 Transformer inference has two phases:

 - **Prefill** — the model runs the full prompt through every layer and stores the attention keys and values (the "KV cache") for each prompt token. `O(prompt_length)`. Dominates time-to-first-token (TTFT) for prompts longer than a few hundred tokens on-device.
 - **Decode** — each new output token only attends back to the cached K/V vectors. `O(1)` per token in prompt length.

 When the cache is enabled, the SDK keeps those K/V vectors around on disk after generation finishes. The next call checks whether the new prompt shares a prefix with any cached entry; matching tokens are loaded from disk instead of recomputed. Per-token decode speed is unchanged — the win is entirely in prefill avoidance.

 The cache is a **bounded LRU**: the SDK enforces a size budget and evicts least-recently-used entries automatically. Don't clean up the directory yourself; deleting it manually is a hard reset.

@@ -650,10 +649,10 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let cacheDir = FileManager.default
      .urls(for: .cachesDirectory, in: .userDomainMask)[0]
      .appendingPathComponent("leap-kv-cache")
    try? FileManager.default.createDirectory(at: cacheDir, withIntermediateDirectories: true)

    let options = LiquidInferenceEngineManifestOptions(
      cacheOptions: .enabled(path: cacheDir.path),
@@ -673,13 +672,13 @@
  </Tab>
  <Tab title="Kotlin (Android)">
    ```kotlin
    val cacheDir = context.cacheDir.resolve("leap-kv-cache").apply { mkdirs() }

    val runner = downloader.loadModel(
        modelName = "LFM2-1.2B",
        quantizationType = "Q5_K_M",
        options = ModelLoadingOptions().apply {
            cacheOptions = ModelLoadingOptions.cacheOptions(path = cacheDir.absolutePath)
        },
    )
    ```
@@ -728,8 +727,8 @@
 - **Cross-launch.** Cached entries survive process restarts. Delete the directory to reset.
 - **First call.** The first request for a given prefix sees no speedup — it's the call that writes the entry. Subsequent calls hit the cache.
 - **Memory-only mode.** Pass `EngineOptions.CacheOptions(path = ..., enabled = true, diskDisabled = true)` to skip the disk tier entirely — useful for benchmarking or callers that don't need cross-restart persistence.
 - **wasmJs caveat.** The WASM bridge currently drops the entire `cache_options` block; a one-shot warning is logged when `enabled = true` is set on wasmJs. Native (Apple, Linux, MinGW), JVM, and Android propagate all fields end-to-end.
 - **Swift backwards compat.** Prior to v0.10.4.3 the `cacheOptions` parameter was only reachable through the verbose Obj-C designated init with `KotlinUInt(unsignedInt:)` wrapping. New code should use `.enabled(path:)` and the `with(...)` builders.

 See the [SDK changelog — KV cache reuse](/deployment/on-device/leap-sdk-changelog#kv-cache-reuse-across-generations) for the cross-platform overview.

@@ -761,7 +760,7 @@
 - **Cross-app model sharing.** Multiple apps that load the same model + quantization share one in-memory copy.
 - **Persistent foreground notification** with live state ("Loading model…", "Generating… N active", "Ready — N models loaded").
 - **Per-UID session quotas** (max 3 sessions per client app, enforced by the service).
 - **Disk-backed KV cache reuse across cold starts** — the service maintains its own KV cache directory, so prefill warmup persists across process restarts and across client apps.
 - **Service-side progress** — when routing through the service, `LeapModelDownloader.loadModel(...)`'s `progress` callback fires for service-side downloads too. Passing `null` (the default) preserves the original deferred-load behavior (the model loads on first session creation rather than eagerly inside `loadModel`).
 - **AIDL-routed function calling** — `Conversation.registerFunction(...)` and `registerFunctions(...)` are forwarded to the service and applied on the shared session.


@@ -1,7 +1,6 @@
 ---
 title: "OpenAI-Compatible Client"
 description: "Lightweight client for OpenAI-compatible chat completions APIs — ideal for hybrid on-device + cloud routing."
-noindex: true
 ---
 
 <Warning>
@@ -192,9 +191,9 @@
    // warning for the full reasoning.
    let client = OpenAiClientKt.OpenAiClient(
        config: OpenAiClientConfig(
            apiKey: "sk-or-…",
            baseUrl: "https://openrouter.ai/api/v1",
            extraHeaders: [
                "HTTP-Referer": "https://yourapp.example.com",
                "X-Title": "Your App"
            ]
@@ -206,9 +205,9 @@
    ```kotlin
    val client = OpenAiClient(
        OpenAiClientConfig(
            apiKey = "sk-or-…",
            baseUrl = "https://openrouter.ai/api/v1",
            extraHeaders = mapOf(
                "HTTP-Referer" to "https://yourapp.example.com",
                "X-Title" to "Your App",
            ),
@@ -225,8 +224,8 @@
    ```swift
    let client = OpenAiClientKt.OpenAiClient(
        config: OpenAiClientConfig(
            apiKey: "anything",  // Required by config but typically unused
            baseUrl: "http://10.0.0.42:8000/v1"
        )
    )
    ```
@@ -235,8 +234,8 @@
    ```kotlin
    val client = OpenAiClient(
        OpenAiClientConfig(
            apiKey = "anything",
            baseUrl = "http://10.0.0.42:8000/v1",
        )
    )
    ```
@@ -299,7 +298,7 @@

    @MainActor
    final class HybridChatViewModel: ObservableObject {
        private let onDevice: Conversation
        private let cloud: OpenAiClient

        init(onDevice: Conversation, cloud: OpenAiClient) {
@@ -308,7 +307,7 @@
        }

        func send(_ text: String, useCloud: Bool) async throws {
            if useCloud {
                // Cloud path: leap-sdk-openai-client has no SKIE — collect the Kotlin
                // Flow manually and downcast each event with `as?`. Note the flattened
                // Swift type names (`ChatMessageUser`, `ChatCompletionEventDelta`).
@@ -422,7 +421,7 @@
 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    ```swift
    deinit { client.close() }
    ```

    The lower-level constructor that accepts an externally-managed `HttpClient` is part of the Kotlin/Ktor surface and isn't a useful entry point from Swift — the Ktor engine machinery isn't bridged into the public Swift API. Use `OpenAiClientKt.OpenAiClient(config:)` and let the SDK own the session. If multiple consumers share a client, share the `OpenAiClient` instance and `close()` once at teardown.

@@ -1,11 +1,10 @@
 ---
 title: "LEAP SDK (archived)"
 description: "The LEAP SDK is deprecated. This archived reference is kept for teams still shipping it; new projects should use llama.cpp directly."
-noindex: true
 ---
 
 <Warning>
 The **LEAP SDK is deprecated** and no longer receives new releases. It was a Kotlin Multiplatform wrapper around llama.cpp, and everything it provided is available from llama.cpp directly. New projects should follow the [Build with llama.cpp](/deployment/on-device/llama-cpp/mobile) guides; existing users can find a concept-by-concept mapping in [Migrating from LEAP SDK](/deployment/on-device/llama-cpp/migrating-from-leap-sdk).
 </Warning>

 Published LEAP SDK artifacts remain available (Swift Package Manager via [`Liquid4All/leap-sdk`](https://github.com/Liquid4All/leap-sdk), Maven Central under `ai.liquid.leap:*`), but they are frozen at their last release and are not updated for new LFM checkpoints. Sampling defaults, chat templates, and tool-call parsing for current models are maintained upstream in llama.cpp.

@@ -1,7 +1,6 @@
 ---
 title: "Quick Start"
 description: "Install the LEAP SDK on iOS, macOS, Android, JVM, Linux, or Windows — same API everywhere."
-noindex: true
 ---
 
 <Warning>
@@ -10,18 +9,18 @@

 Latest version: `v0.10.7`

 The Leap SDK is a Kotlin Multiplatform library: the same `ModelRunner` / `Conversation` / `MessageResponse` API runs on every supported target. The code differs only in **language** (Swift vs. Kotlin) and **packaging** (SPM, Gradle, or Kotlin/Native plugin) — the call shapes are identical. For background on what the SDK is and what first-class LFM support means in practice, see the [Overview](/deployment/on-device/sdk/overview).

 <Info>
 **Migrating from 0.9.x?** v0.10.0 unifies the SDK into a single Kotlin Multiplatform distribution published from [`Liquid4All/leap-sdk`](https://github.com/Liquid4All/leap-sdk). The standalone `Liquid4All/leap-ios` repo is no longer the source-of-truth. See the [SDK changelog](/deployment/on-device/leap-sdk-changelog#0-9-x-0-10-x-kotlin-multiplatform-unification) for the transition story and drop-in replacements for legacy `Leap.load(...)` / `LiquidEngine(...)` call sites.
 </Info>

 ## 1. Prerequisites

 <Tabs>
  <Tab title="iOS / macOS">
    - Xcode 16.0+ with Swift 6.0.
    - iOS **17.0+** or macOS **15.0+** (Apple Silicon only — Mac Catalyst is **not** supported; the shipped XCFrameworks contain only `ios-arm64`, `ios-arm64-simulator`, and `macos-arm64` slices, and `Package.swift` declares only `.iOS(.v17)` / `.macOS(.v15)` platforms).
    - A physical iPhone or iPad with at least 3 GB RAM for best performance. The simulator works for development but runs models much slower.

    <Warning>
@@ -29,7 +28,7 @@
    </Warning>
  </Tab>
  <Tab title="Android">
    - Kotlin Android Plugin **2.3.0+** and Android Gradle Plugin **8.13.0+**:
      ```kotlin
      plugins {
          id("com.android.application") version "8.13.2" apply false
@@ -48,15 +47,15 @@
    </Warning>
  </Tab>
  <Tab title="JVM Desktop">
    - **JDK 11+** (Hotspot or any standard JVM).
    - Kotlin 2.3.0+ if you're writing Kotlin (Java consumers work too).
    - Supported hosts: macOS ARM64, Linux x86_64, Linux aarch64, Windows x86_64, Windows aarch64.

    The `leap-sdk` JAR bundles the JNI binaries for every supported OS/arch — no extra setup needed.
  </Tab>
  <Tab title="Linux / Windows native">
    - Kotlin **2.3.20+** and Gradle 8.x for the Kotlin/Native build.
    - **Linux runtime:** glibc **2.34+** (Ubuntu 22.04, Debian 12, RHEL 9, or newer).
    - **Windows runtime:** Windows 10+.

    <Warning>
@@ -247,7 +246,7 @@

 ## 3. Load a model

 The recommended path is **manifest-based** loading. On every platform, the platform downloader's `loadModel(...)` downloads (if needed) and loads in one call — `ModelDownloader.loadModel(...)` on iOS / macOS, `LeapModelDownloader.loadModel(...)` on Android, and `LeapDownloader.loadModel(...)` on JVM and Linux / Windows Kotlin/Native. All paths fetch from the [LEAP Model Library](https://leap.liquid.ai/models) on first use and load from cache thereafter.

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
@@ -278,7 +277,7 @@
            defer { isLoading = false }
            do {
                let runner = try await downloader.loadModel(
                    modelName: "LFM2-1.2B",
                    quantizationType: "Q5_K_M"
                ) { fraction, _ in
                    // fraction: Double (0...1) · bytesPerSecond: Int64
@@ -395,7 +394,7 @@
  </Tab>
 </Tabs>

 ### Loading a sideloaded GGUF

 When you already have a model file on disk — shipped as an app asset, `adb push`-ed for development, or downloaded by your own pipeline — use `loadSimpleModel(model: ModelSource(...))` to skip the LEAP Model Library lookup entirely.

@@ -404,9 +403,9 @@
    ```swift
    let runner = try await downloader.loadSimpleModel(
      model: ModelSource(
        modelPath: bundledURL.path,
        modelName: "LFM2-1.2B-Instruct",
        quantizationId: "Q4_K_M"
      )
    )
    ```
@@ -417,9 +416,9 @@
    ```kotlin
    val runner = downloader.loadSimpleModel(
        model = ModelSource(
            modelPath = "/path/to/lfm2-1_2b-q4_k_m.gguf",
            modelName = "LFM2-1.2B-Instruct",
            quantizationId = "Q4_K_M"
        )
    )
    ```
@@ -437,8 +436,8 @@
    ```swift
    func send(_ text: String) {
        guard let conversation else { return }
        generationTask?.cancel()
        let userMessage = ChatMessage(role: .user, textContent: text)
        let options = GenerationOptions()
            .with(temperature: 0.3)
            .with(minP: 0.15)
@@ -468,7 +467,7 @@
        case .audioSample(let audio):
            audioRenderer.enqueue(audio.samples, sampleRate: Int(audio.sampleRate))
        case .functionCalls(let payload):
            handleFunctionCalls(payload.functionCalls)
        case .complete(let completion):
            if let stats = completion.stats {
                print("Finished with \(stats.totalTokens) tokens")
@@ -505,14 +504,14 @@
  </Tab>
 </Tabs>

 Cancel the in-flight task (Swift) or coroutine job (Kotlin) to interrupt generation early.

 ## 5. Send images and audio (optional)

 If the loaded model is multimodal (and its companion files were detected), you can attach a non-text part — an image, a WAV blob, or raw PCM samples — alongside the text in a `ChatMessage`.

 <Info>
 **Multimodality is model-specific.** Most multimodal models we ship are text + one other modality: text + vision (the VLM family) or text + audio (the audio family) — not both in the same checkpoint. Send image content (`fromJPEGData(_:)`, `image(url:)`, `fromBitmap(...)` / `fromUIImage(_:)`) only to a vision-capable model, and audio content (`fromWAVData(_:)`, `fromFloatSamples(_:sampleRate:)`) only to an audio-capable model. Mixing modalities a model wasn't trained on will either fail to load the companion file or produce nonsense. Check the model's [Hugging Face card](https://huggingface.co/LiquidAI) before wiring up a non-text input path.
 </Info>

 <Tabs>
@@ -520,10 +519,10 @@
    ```swift
    // Text + image (vision-capable model). Use `ChatMessageContent.fromJPEGData(_:)`
    // for raw JPEG bytes, or `.image(url:)` for a data URL / remote URL.
    let imageMessage = ChatMessage(
      role: .user,
      content: [.text("Describe what you see."), ChatMessageContent.fromJPEGData(jpegData)],
      reasoningContent: nil,
      functionCalls: nil
    )

@@ -551,7 +550,7 @@
  <Tab title="Kotlin (all platforms)">
    ```kotlin
    // Text + image (vision-capable model)
    val imageMessage = ChatMessage(
        role = ChatMessage.Role.USER,
        content = listOf(
            ChatMessageContent.Text("Describe what you see."),
@@ -593,7 +592,7 @@
 </Card>

 <Card title="Function Calling" icon="wrench" href="/deployment/on-device/sdk/function-calling">
  Tool use with Hermes and Pythonic parsers.
 </Card>

 <Card title="Constrained Generation" icon="brackets-curly" href="/deployment/on-device/sdk/constrained-generation">

@@ -1,7 +1,6 @@
 ---
 title: "Utilities"
 description: "Error handling, serialization, Android-specific downloader internals, and a putting-it-together example."
-noindex: true
 ---
 
 <Warning>
@@ -39,7 +38,7 @@

 ## Serialization

 `ChatMessage`, `ChatMessageContent`, `LeapFunctionCall`, and `Manifest` are serializable on every platform and round-trip cleanly into JSON compatible with OpenAI's chat-completions schema.

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
@@ -57,7 +56,7 @@
    // round-trip that talks to your sync backend.
    ```

    Persist `data` to disk, UserDefaults, or your sync backend. On restore, decode the JSON via Kotlin's `LeapJson` (re-exported through SKIE) into a `[ChatMessage]` and rebuild via `modelRunner.createConversationFromHistory(history:)`. There is no Swift-native dictionary-based `ChatMessage` initializer — the Kotlin serializer is the source of truth on both platforms.
  </Tab>
  <Tab title="Kotlin (all platforms)">
    The SDK uses [kotlinx.serialization](https://github.com/Kotlin/kotlinx.serialization) — `@Serializable` is already declared on the relevant types in the core SDK.
@@ -113,7 +112,7 @@

 ### Permission setup

 `requestDownloadModel(...)` enqueues a WorkManager download worker. During transfer, the worker runs in the foreground and displays notifications, so declare these in your `AndroidManifest.xml`:

 ```xml
 <uses-permission android:name="android.permission.INTERNET" />
@@ -152,7 +151,7 @@
    private val downloaderConfig: LeapDownloaderConfig = LeapDownloaderConfig(),
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
 ) {
    suspend fun requestDownloadModel(modelName: String, quantizationType: String, forceDownload: Boolean = false)
    suspend fun requestStopDownload(modelName: String, quantizationType: String)
    suspend fun queryStatus(modelName: String, quantizationType: String): ModelDownloadStatus
    fun observeDownloadProgress(modelName: String, quantizationType: String): StateFlow<ModelDownloadProgress?>
@@ -179,9 +178,9 @@
 }
 ```

 Refer to the nested status type as `LeapModelDownloader.ModelDownloadStatus.NotOnLocal` / `.DownloadInProgress` / `.Downloaded` on Android — the Android downloader does not expose a top-level `ai.liquid.leap.downloader.ModelDownloadStatus`. (Apple ships a top-level `ai.liquid.leap.downloader.ModelDownloadStatus` `sealed interface` with a different payload — `DownloadInProgress(progress: Double)` and a `data object Downloaded` with no size — so don't share status-decoding code unmodified across platforms.)

 - **`requestDownloadModel`** — `suspend` fire-and-forget prefetch. It enqueues a unique WorkManager download worker; the download itself survives app restarts, and the call returns after staging the work request.
 - **`requestStopDownload`** — `suspend`; cancels an in-flight background download.
 - **`queryStatus`** — `suspend` one-shot status check.
 - **`observeDownloadProgress`** — `StateFlow<ModelDownloadProgress?>` for UI updates during a background download. It emits `null` when no download is active.
@@ -190,7 +189,7 @@

 ### Removing a downloaded model

 Use the Android downloader's resource folder to clean up disk, or construct a cross-platform `LeapDownloader` with the same `saveDir` and call its instance method `deleteModelResources(...)`:

 ```kotlin
 val resourceFolder = downloader.getModelResourceFolder(
@@ -214,8 +213,8 @@
  <Tab title="Swift (iOS / macOS)">
    ```swift
    let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!.path
    let modelsDir = (caches as NSString).appendingPathComponent("leap_models")
    let downloader = ModelDownloader(config: LeapDownloaderConfig(saveDir: modelsDir))

    let runner = try await downloader.loadModel(
      modelName: "LFM2.5-1.2B-Instruct",
@@ -250,7 +249,7 @@
    // pass `cacheDir.absolutePath`, not the `File` itself. On Android, prefer
    // `LeapModelDownloader(application)` (the cross-platform `LeapDownloader` works
    // too, but doesn't integrate with WorkManager).
    val downloader = LeapDownloader(LeapDownloaderConfig(saveDir = cacheDir.absolutePath))
    val runner = downloader.loadModel(
        modelName = "LFM2.5-1.2B-Instruct",
        quantizationType = "Q4_K_M"

@@ -1,7 +1,6 @@
 ---
 title: "Voice Assistant Widget"
 description: "Drop-in Compose Multiplatform voice UI — runs on iOS, macOS, Android, and JVM Desktop."
-noindex: true
 ---
 
 <Warning>
@@ -10,13 +9,13 @@

 The `leap-ui` module (introduced in v0.10.0) ships a ready-to-use voice assistant widget — an animated orb, mic button, and status label — backed by a state machine that handles recording, generation, and audio playback. Wire it to a model and it handles the rest.

 `leap-ui` is a Compose Multiplatform module, so the same widget runs on:

 - **iOS** — bridged to UIKit via `VoiceAssistantViewController` and exposed to SwiftUI through `UIViewControllerRepresentable`.
 - **macOS** — bridged to AppKit via `VoiceAssistantNSViewController`. SwiftUI hosts via `NSViewControllerRepresentable` + `NSHostingController`.
 - **Android** — direct Compose for Android.
 - **JVM Desktop** — Compose for Desktop. Same Maven artifact; you provide audio I/O implementations (the demo apps in `leap-ui-demo/` ship patterns you can adapt).
 - **Web (Wasm, experimental)** — present in the source tree (`leap-ui-demo/web`) but not yet covered by the stable release notes through v0.10.7 — treat as preview.

 ## Add the dependency

@@ -80,7 +79,7 @@

 <Tabs>
  <Tab title="Swift (iOS / macOS)">
    The factory `VoiceAssistantStore.makeForApple()` hides Kotlin coroutine plumbing from Swift callers. It creates the store with a `MainScope()`, the default Apple audio recorder and player, and an EMA-smoothed amplitude.

    ```swift
    import LeapModelDownloader
@@ -494,7 +493,7 @@
 | `VoiceAssistantStore` | State machine + orchestrator. Apple platforms: `makeForApple()`. |
 | `VoiceAssistantStateHolder` | Compose-friendly state container, exposed to Swift. |
 | `VoiceAssistantWidget` (Compose) | The widget itself. Drop into any Compose tree (Android, JVM, iOS via host controller, macOS via host controller). |
 | `VoiceAssistantViewController` (UIKit) / `VoiceAssistantNSViewController` (AppKit) | Pre-built hosts for Apple. |
 | `AppleAudioRecorder` / `AppleAudioPlayer` | Default audio I/O on iOS / macOS. |
 | `VoiceConversation` | Adapter interface you implement to bridge the store to a `Conversation`. |
 | `VoiceWidgetLabels`, `VoiceWidgetColors` | Theming (use `.companion.Default` to access the canonical palette). |

@@ -1,9 +1,12 @@
 ---
 title: "Authentication"
 description: "Authentication commands for the LEAP Bundle CLI"
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ## `login`
 
 Authenticate with the LEAP platform using your API token.

@@ -1,9 +1,12 @@
 ---
 title: "Bundle Creation"
 description: "Commands for creating and validating bundle requests in the LEAP Bundle CLI"
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ## `create`
 
 Create a new bundle request by uploading a model directory.
@@ -26,7 +29,7 @@
  - If both `--parallel` and `--sequential` are specified, `--parallel` takes precedence.
 - `--executorch` (deprecated): Use ExecuTorch bundling instead of GGUF. By default, the CLI uses GGUF bundling. This option may be removed in a future version.
 - `--quantization <type>`: Specify the quantization type for the model bundle. Options include `Q4_K_M` (default), `Q8_0`, `F16`, and [other llama.cpp quantization types](https://github.com/ggml-org/llama.cpp/blob/0a0bba05e8390ab7e4a54bb8c0ed0a25da64cf62/tools/quantize/quantize.cpp#L22-L58).
 - `--mmproj-quantization <type>`: (GGUF only) Specify the mmproj quantization type for vision-language or audio models. Valid options: `q4`, `q8` (default), `f16`.

 **Behavior**

@@ -65,7 +68,7 @@
 # Create GGUF bundle with specific quantization
 leap-bundle create ./my-model-directory --quantization Q8_0

 # Create GGUF bundle for VL model with mmproj quantization
 leap-bundle create ./my-vl-model-directory --mmproj-quantization f16
 ```

@@ -110,7 +113,7 @@
 **Process Flow**

 1. Validates input directory exists
 2. Calculates directory hash for deduplication
 3. Creates bundle request via API
 4. Uploads directory contents to S3 using signed URLs
 5. Updates request status to track progress

@@ -1,9 +1,12 @@
 ---
 title: "Bundle Management"
 description: "Commands for listing and canceling bundle requests in the LEAP Bundle CLI"
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ## `list`
 
 List bundle requests or get details for a specific request.

@@ -2,9 +2,12 @@
 title: "LEAP Bundle CLI Changelog"
 sidebarTitle: "Changelog"
 description: "Release history for leap-bundle, the Liquid AI model bundling CLI tool."
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ## `v0.9.0` - 2026-01-02
 
 **New features**

@@ -1,9 +1,12 @@
 ---
 title: "Configuration"
 description: "Configuration commands and file format for the LEAP Bundle CLI"
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ## `config`
 
 View CLI configuration settings.

@@ -2,15 +2,18 @@
 title: "Data Privacy"
 description: "This page outlines how the LEAP Model Bundling Service handles your data, what information we collect and delete."
 sidebar_position: 3
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ### Bundle Request Information
 
 When you create a bundle request using `leap-bundle create`, we store the following information:

 - **Input file path**: The path of your input model directory.
 - **Input file hash**: A cryptographic hash of your model directory contents for deduplication.
 - **Bundle arguments**: All command-line arguments passed to the bundling service. E.g. required quantization type.
 - **Request metadata**: Creation time, etc.
 - **User identification**: Your internal user ID to associate requests with your account.

@@ -1,9 +1,12 @@
 ---
 title: "Download"
 description: "Download commands for bundle requests and LEAP models in the LEAP Bundle CLI"
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 The `download` command supports two modes of operation:
 
 <Tabs>

@@ -2,7 +2,6 @@
 title: "LEAP Bundle CLI Quick Start"
 sidebarTitle: "Quick Start"
 description: "The Bundling Service helps users create and manage model bundles for Liquid Edge AI Platform (LEAP). Currently users interact with it through a command-line interface (CLI)."
-noindex: true
 ---
 
 <Warning>

@@ -1,9 +1,12 @@
 ---
 title: "Reference"
 description: "Reference information for the LEAP Bundle CLI including limitations, error handling, and exit codes"
-noindex: true
 ---
 
+<Warning>
+  The LEAP Model Bundling Service is deprecated and no longer maintained. For new deployments, download GGUF files from [Hugging Face](https://huggingface.co/LiquidAI) and run them with [llama.cpp](/deployment/on-device/llama-cpp).
+</Warning>
+
 ## All Commands
 
 | Command                | Description                                                                   |
@@ -28,7 +31,7 @@

 ## Current Limitations

 - The bundle tool only works on these model types for now: LFM2, LFM2-VL, Qwen.
  - We are working on expanding support to more models.

 ## Error Handling

diff --git a/docs.json b/docs.json
@@ -11,6 +11,7 @@
   "name": "Liquid AI Docs",
   "description": "Documentation for Liquid AI Foundation Models (LFM)",
   "seo": {
+    "indexing": "all",
     "organization": {
       "name": "Liquid AI",
       "url": "https://www.liquid.ai",
@@ -619,6 +620,38 @@
     {
       "source": "/lfm/fine-tuning",
       "destination": "/lfm/fine-tuning/overview"
+    },
+    {
+      "source": "/lfm/getting-started/intro",
+      "destination": "/lfm/getting-started/welcome"
+    },
+    {
+      "source": "/lfm/inference/lmstudio",
+      "destination": "/deployment/on-device/lm-studio"
+    },
+    {
+      "source": "/lfm/key-concepts/models",
+      "destination": "/lfm/models/complete-library"
+    },
+    {
+      "source": "/deployment/tools/model-bundling",
+      "destination": "/deployment/on-device/llama-cpp"
+    },
+    {
+      "source": "/lfm/models/lfm3-1-7b",
+      "destination": "/lfm/models/lfm3-1.7b"
+    },
+    {
+      "source": "/lfm/getting-started/text-generation-and-prompting",
+      "destination": "/lfm/key-concepts/text-generation-and-prompting"
+    },
+    {
+      "source": "/lfm/frameworks/leap",
+      "destination": "/deployment/on-device/llama-cpp/migrating-from-leap-sdk"
+    },
+    {
+      "source": "/lfm/getting-started/vision",
+      "destination": "/lfm/key-concepts/vision-capabilities"
     }
   ],
   "ai": {

diff --git a/examples/laptop-examples/audio-car-cockpit.mdx b/examples/laptop-examples/audio-car-cockpit.mdx
@@ -7,9 +7,13 @@
   Browse the complete example on GitHub
 </Card>
 
+<Note>
+This demo uses LFM2.5-Audio-1.5B and LFM2-1.2B-Tool, both of which are deprecated. For new projects, see [LFM3-Audio-2B](/lfm/models/lfm3-audio-2b) for speech and [LFM2.5-1.2B-Instruct](/lfm/models/lfm25-1.2b-instruct) for tool calling. The demo and commands below use the original models.
+</Note>
+
 ## What's inside?
 
 Combines [LFM2.5-Audio-1.5B](https://huggingface.co/LiquidAI/LFM2.5-Audio-1.5B-GGUF) in TTS and STT modes with [LFM2-1.2B-Tool](https://huggingface.co/LiquidAI/LFM2-1.2B-Tool-GGUF) within a mockup of a car cockpit, letting the user control the car functionalities by voice.

 All running locally in real-time.


diff --git a/examples/laptop-examples/audio-to-text-in-real-time.mdx b/examples/laptop-examples/audio-to-text-in-real-time.mdx
@@ -7,7 +7,11 @@
   Browse the complete example on GitHub
 </Card>
 
-This example demonstrates how to use the [LFM2.5-Audio-1.5B](https://docs.liquid.ai/lfm/models/lfm25-audio-1.5b) model with llama.cpp to transcribe audio files locally in real-time.
+<Note>
+This example uses LFM2.5-Audio-1.5B, which is deprecated. For new projects, use [LFM3-Audio-2B](/lfm/models/lfm3-audio-2b).
+</Note>
+
+This example demonstrates how to use the [LFM2.5-Audio-1.5B](/lfm/models/lfm25-audio-1.5b) model with llama.cpp to transcribe audio files locally in real-time.
 
 Intelligent audio assistants on the edge are possible, and this repository is just one step towards that.
 
@@ -19,7 +23,7 @@
    cd cookbook/examples/audio-transcription-cli
    ```

 2. Install uv on your system, if you don't have it already.

    <Accordion title="Click to see installation instructions for uv">
      **macOS/Linux:**
@@ -80,7 +84,7 @@

 ## llama.cpp support for audio models

 [llama.cpp](https://github.com/ggerganov/llama.cpp) is a super fast and lightweight open-source inference engine for Language Models. It is written in C++ and can be used to run LLMs on your local machine. For example, our Python CLI used llama.cpp under the hood to deliver fast transcriptions, instead of using either `PyTorch` or the higher-level `transformers` library.

 In the [examples.sh](https://github.com/Liquid4All/cookbook/blob/main/examples/audio-transcription-cli/examples.sh) script you will find 3 examples on how to run inference with LFM2.5-Audio-1.5B for 3 common use cases:

@@ -135,7 +139,7 @@
 
 ### What is LFM2.5-350M?
 
-[LFM2.5-350M](https://docs.liquid.ai/lfm/models/lfm25-350m) is a small text-to-text model that can be used for tasks like text cleaning. To achieve optimal performance for your particular use case, you need to optimize your system and user prompts.
+[LFM2.5-350M](/lfm/models/lfm25-350m) is a small text-to-text model that can be used for tasks like text cleaning. To achieve optimal performance for your particular use case, you need to optimize your system and user prompts.
 
 ## Need help?
 

diff --git a/examples/laptop-examples/invoice-extractor-tool-with-liquid-nanos.mdx b/examples/laptop-examples/invoice-extractor-tool-with-liquid-nanos.mdx
@@ -1,13 +1,17 @@
 ---
 title: "Invoice extractor tool"
 description: "Extract structured payment details from invoice PDFs using LFM2.5-VL-1.6B and llama.cpp, running fully local."
 ---

 <Card title="View Source Code" icon="github" href="https://github.com/Liquid4All/cookbook/tree/main/examples/invoice-parser">
   Browse the complete example on GitHub
 </Card>
 
+<Note>
+**Newer model available:** This example uses LFM2.5-VL-1.6B. For new projects, see [LFM3-VL-2B](/lfm/models/lfm3-vl-2b).
+</Note>
+
 A Python CLI that extracts payment details from invoice PDFs.
 
 ![Invoice extraction: a utility bill image goes through LFM2.5-VL-1.6B on llama.cpp and comes out as structured JSON](https://github.com/Liquid4All/cookbook/raw/main/examples/invoice-parser/media/diagram.jpg)

@@ -23,7 +27,7 @@
 
 * **Set up local AI inference** using llama.cpp to run Liquid models entirely on your machine without requiring cloud services or API keys
 * **Build a file monitoring system** that automatically processes new files dropped into a directory
-* **Extract structured output from images** using [LFM2.5-VL-1.6B](https://docs.liquid.ai/lfm/models/lfm25-vl-1.6b), a small vision-language model.
+* **Extract structured output from images** using [LFM2.5-VL-1.6B](/lfm/models/lfm25-vl-1.6b), a small vision-language model.
 
 ## Environment setup
 

diff --git a/examples/web/audio-webgpu-demo.mdx b/examples/web/audio-webgpu-demo.mdx
@@ -7,6 +7,10 @@
   Browse the complete example on Hugging Face
 </Card>
 
+<Note>
+This demo uses LFM2.5-Audio-1.5B, which is deprecated. For new projects, see [LFM3-Audio-2B](/lfm/models/lfm3-audio-2b). The instructions below use the original model.
+</Note>
+
 This example showcases the **LFM2.5-Audio-1.5B** model running entirely within a web browser using WebGPU and ONNX Runtime Web technology. The demo provides three powerful audio processing modes: automatic speech recognition, text-to-speech synthesis, and interleaved conversations.
 
 ## What's Inside?
@@ -62,12 +66,12 @@
 **2. Text-to-Speech (TTS)**
 - Input: Written text
 - Output: Natural-sounding audio
 - Use case: Create voice assistants, audiobooks, or accessibility features

 **3. Interleaved Mode**
 - Input: Mixed audio and text
 - Output: Conversational responses in text or audio
 - Use case: Interactive voice assistants and chatbots

 ## System Requirements