From 08378c1b5f104c15adcb1273d0651fa3b7a5734e Mon Sep 17 00:00:00 2001 From: AlexFromAtomic <275106994+AlexFromAtomic@users.noreply.github.com> Date: Thu, 13 Aug 2026 16:04:10 +0300 Subject: [PATCH 1/4] Add Atomic Chat page under Edge Inference Add deployment/on-device/atomic-chat covering installation on desktop and mobile, model downloads from the in-app Hugging Face library and the Use this model flow, chat usage with recommended sampling parameters, vision models, and the local OpenAI-compatible endpoint. --- deployment/on-device/atomic-chat.mdx | 59 ++++++++++++++++++++++++++++ docs.json | 3 +- link-snapshot.yaml | 1 + 3 files changed, 62 insertions(+), 1 deletion(-) create mode 100644 deployment/on-device/atomic-chat.mdx diff --git a/deployment/on-device/atomic-chat.mdx b/deployment/on-device/atomic-chat.mdx new file mode 100644 index 0000000..a17f44c --- /dev/null +++ b/deployment/on-device/atomic-chat.mdx @@ -0,0 +1,59 @@ +--- +title: "Atomic Chat" +description: "Atomic Chat is a desktop and mobile app for running LLMs and agents locally with a friendly graphical user interface." +--- + + + Use Atomic Chat for local inference with a graphical interface on desktop and mobile, one-click model downloads from Hugging Face, and no command-line setup. + + +Atomic Chat uses GGUF models on all platforms and MLX models on Apple Silicon. + +## Installation + +Download and install Atomic Chat from [atomic.chat](https://atomic.chat): + +* **macOS** (Apple Silicon): DMG installer +* **Windows** (x64): EXE installer +* **Linux** (x86_64): AppImage +* **iPhone and iPad**: [App Store](https://apps.apple.com/us/app/atomic-chat-private-local-ai/id6761720226) +* **Android**: [Google Play](https://play.google.com/store/apps/details?id=chat.atomic.app) + +## Downloading Models + +1. Open Atomic Chat and open the model library +2. Search for "LiquidAI" or any other model +3. Select a model and quantization level +4. Click Download + +The model library searches Hugging Face directly, so all LiquidAI GGUF releases are available in the app from day zero. + +### Open from Hugging Face + +Atomic Chat is a Local Apps provider on Hugging Face, so models can be opened straight from the Hub: + +1. Open any GGUF or MLX model page, for example [LFM2.5-VL-3B-GGUF](https://huggingface.co/LiquidAI/LFM2.5-VL-3B-GGUF) +2. Click **Use this model** and choose **Atomic Chat** +3. The model opens in the app: download it and start chatting + +## Using the Chat Interface + +1. Start a new chat and select your downloaded model +2. Adjust sampling parameters (`temperature`, `top_k`, `repeat_penalty`) in the model settings +3. Start chatting + +Use the sampling parameters recommended on each model card. For example, `LFM2.5-1.2B-Instruct` works best with `temperature` 0.1, `top_k` 50, and `repeat_penalty` 1.05. + +## Vision Models + +LFM2-VL and LFM2.5-VL GGUF models run in Atomic Chat on both desktop and mobile. Download a vision model from the model library, then attach images to your messages to ask questions about them. + +## Local API Server + +On macOS, Atomic Chat can expose the loaded model through a local OpenAI-compatible endpoint. Point Cline, Kilo Code, or any OpenAI client at the base URL shown in the app, with no API key required. + +## Tips + +* **Quantization**: `Q4_K_M` offers the best balance of size and quality; step up to `Q6_K` or `Q8_0` if you have memory to spare +* **Apple Silicon**: GGUF models run with Metal acceleration, and MLX builds of LFM models are supported natively +* **Long conversations**: the TurboQuant engine compresses the KV cache to 3-4 bits, so long contexts fit in significantly less memory diff --git a/docs.json b/docs.json index 5533453..76c73fb 100644 --- a/docs.json +++ b/docs.json @@ -97,7 +97,8 @@ "deployment/on-device/lm-studio", "deployment/on-device/mlx", "deployment/on-device/onnx", - "deployment/on-device/ollama" + "deployment/on-device/ollama", + "deployment/on-device/atomic-chat" ] }, { diff --git a/link-snapshot.yaml b/link-snapshot.yaml index fe095da..b5bad0b 100644 --- a/link-snapshot.yaml +++ b/link-snapshot.yaml @@ -30,6 +30,7 @@ active: - /deployment/on-device/android/openai-client - /deployment/on-device/android/utilities - /deployment/on-device/android/voice-assistant + - /deployment/on-device/atomic-chat - /deployment/on-device/ios/advanced-features - /deployment/on-device/ios/ai-agent-usage-guide - /deployment/on-device/ios/cloud-ai-comparison From 67e3c6f6a6f3d6191fc03c47bbdb670d977c0cba Mon Sep 17 00:00:00 2001 From: AlexFromAtomic <275106994+AlexFromAtomic@users.noreply.github.com> Date: Thu, 13 Aug 2026 16:04:23 +0300 Subject: [PATCH 2/4] Mention Atomic Chat alongside LM Studio in runtime lists Add Atomic Chat to the GGUF format bullets and the local-runtime lists in the model library, use-case evaluation, migration guide, and FAQs, mirroring the existing LM Studio placements. --- guides/migration-guide.mdx | 2 +- guides/use-case-evaluation.mdx | 2 +- lfm/help/faqs.mdx | 2 +- lfm/models/complete-library.mdx | 8 ++++---- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/guides/migration-guide.mdx b/guides/migration-guide.mdx index 709d9be..579faca 100644 --- a/guides/migration-guide.mdx +++ b/guides/migration-guide.mdx @@ -36,7 +36,7 @@ Across runtimes, avoid carrying over hand-written Qwen, Llama, or Gemma prompt t For GPU inference, see [Transformers](/deployment/gpu-inference/transformers), [vLLM](/deployment/gpu-inference/vllm), or [SGLang](/deployment/gpu-inference/sglang). -For edge and on-device inference, see [llama.cpp](/deployment/on-device/llama-cpp), [Ollama](/deployment/on-device/ollama), [LM Studio](/deployment/on-device/lm-studio), [MLX](/deployment/on-device/mlx), [ONNX](/deployment/on-device/onnx), or the [LEAP SDK](/deployment/on-device/sdk/quick-start). +For edge and on-device inference, see [llama.cpp](/deployment/on-device/llama-cpp), [Ollama](/deployment/on-device/ollama), [Atomic Chat](/deployment/on-device/atomic-chat), [LM Studio](/deployment/on-device/lm-studio), [MLX](/deployment/on-device/mlx), [ONNX](/deployment/on-device/onnx), or the [LEAP SDK](/deployment/on-device/sdk/quick-start). ## Chat Template diff --git a/guides/use-case-evaluation.mdx b/guides/use-case-evaluation.mdx index ec73c4b..65b252d 100644 --- a/guides/use-case-evaluation.mdx +++ b/guides/use-case-evaluation.mdx @@ -15,7 +15,7 @@ Use this guide when you want to validate LFMs on an actual product task. The goa ## Integration -LFMs serve through OpenAI-compatible endpoints on [vLLM](/deployment/gpu-inference/vllm) and [SGLang](/deployment/gpu-inference/sglang), load in [Transformers](/deployment/gpu-inference/transformers), and run locally through [llama.cpp](/deployment/on-device/llama-cpp), [Ollama](/deployment/on-device/ollama), [MLX](/deployment/on-device/mlx), and [LM Studio](/deployment/on-device/lm-studio). +LFMs serve through OpenAI-compatible endpoints on [vLLM](/deployment/gpu-inference/vllm) and [SGLang](/deployment/gpu-inference/sglang), load in [Transformers](/deployment/gpu-inference/transformers), and run locally through [llama.cpp](/deployment/on-device/llama-cpp), [Ollama](/deployment/on-device/ollama), [Atomic Chat](/deployment/on-device/atomic-chat), [MLX](/deployment/on-device/mlx), and [LM Studio](/deployment/on-device/lm-studio). Read these three pages before judging quality: diff --git a/lfm/help/faqs.mdx b/lfm/help/faqs.mdx index 880d8c4..31c635f 100644 --- a/lfm/help/faqs.mdx +++ b/lfm/help/faqs.mdx @@ -53,7 +53,7 @@ Yes! Use the [LEAP SDK](/deployment/on-device/sdk/quick-start) to deploy models -- **GGUF**: For llama.cpp, LM Studio, Ollama (Q4_0, Q4_K_M, Q5_K_M, Q6_K, Q8_0, F16) +- **GGUF**: For llama.cpp, LM Studio, Ollama, Atomic Chat (Q4_0, Q4_K_M, Q5_K_M, Q6_K, Q8_0, F16) - **MLX**: For Apple Silicon (4-bit, 5-bit, 6-bit, 8-bit, bf16) - **ONNX**: For cross-platform deployment with ONNX Runtime diff --git a/lfm/models/complete-library.mdx b/lfm/models/complete-library.mdx index 2ca38b3..862613f 100644 --- a/lfm/models/complete-library.mdx +++ b/lfm/models/complete-library.mdx @@ -8,7 +8,7 @@ description: "Liquid Foundation Models (LFMs) are a new class of multimodal arch All of our models share the following capabilities: - 32K token context length for extended conversations and document processing (128K for LFM2.5-8B-A1B) -- Designed for fast inference with [Transformers](/deployment/gpu-inference/transformers), [llama.cpp](/deployment/on-device/llama-cpp), [vLLM](/deployment/gpu-inference/vllm), [SGLang](/deployment/gpu-inference/sglang), [MLX](/deployment/on-device/mlx), [Ollama](/deployment/on-device/ollama), and [LEAP](/deployment/on-device/sdk/quick-start) +- Designed for fast inference with [Transformers](/deployment/gpu-inference/transformers), [llama.cpp](/deployment/on-device/llama-cpp), [vLLM](/deployment/gpu-inference/vllm), [SGLang](/deployment/gpu-inference/sglang), [MLX](/deployment/on-device/mlx), [Ollama](/deployment/on-device/ollama), [Atomic Chat](/deployment/on-device/atomic-chat), and [LEAP](/deployment/on-device/sdk/quick-start) - Trainable via SFT, DPO, VLM, and GRPO workflows with [LEAP Finetune](/lfm/fine-tuning/leap-finetune), [TRL](/lfm/fine-tuning/trl), and [Unsloth](/lfm/fine-tuning/unsloth) @@ -53,7 +53,7 @@ Start with the model family that matches your input and output shape, then choos - Use [llama.cpp](/deployment/on-device/llama-cpp), [Ollama](/deployment/on-device/ollama), [MLX](/deployment/on-device/mlx), or the [LEAP SDK](/deployment/on-device/sdk/quick-start) depending on platform and packaging needs. + Use [llama.cpp](/deployment/on-device/llama-cpp), [Ollama](/deployment/on-device/ollama), [Atomic Chat](/deployment/on-device/atomic-chat), [MLX](/deployment/on-device/mlx), or the [LEAP SDK](/deployment/on-device/sdk/quick-start) depending on platform and packaging needs. @@ -70,8 +70,8 @@ Start with the model family that matches your input and output shape, then choos Use the format that matches your runtime and deployment target: -- **GGUF** — Best for local CPU/GPU inference on any platform. Use with [llama.cpp](/deployment/on-device/llama-cpp), [LM Studio](/deployment/on-device/lm-studio), or [Ollama](/deployment/on-device/ollama). Append `-GGUF` to any model name. -- **MLX** — Best for Mac users with Apple Silicon. Leverages unified memory for fast inference via [MLX](/deployment/on-device/mlx). Browse at [mlx-community](https://huggingface.co/mlx-community/collections?search=LFM). +- **GGUF** — Best for local CPU/GPU inference on any platform. Use with [llama.cpp](/deployment/on-device/llama-cpp), [LM Studio](/deployment/on-device/lm-studio), [Ollama](/deployment/on-device/ollama), or [Atomic Chat](/deployment/on-device/atomic-chat). Append `-GGUF` to any model name. +- **MLX** — Best for Mac users with Apple Silicon. Leverages unified memory for fast inference via [MLX](/deployment/on-device/mlx) or [Atomic Chat](/deployment/on-device/atomic-chat). Browse at [mlx-community](https://huggingface.co/mlx-community/collections?search=LFM). - **ONNX** — Best for production deployments and edge devices. Cross-platform with ONNX Runtime across CPUs, GPUs, and accelerators. Append `-ONNX` to any model name. ### Quantization From 676c97b6622831ed4884ccd38c52c61ea9af322a Mon Sep 17 00:00:00 2001 From: AlexFromAtomic <275106994+AlexFromAtomic@users.noreply.github.com> Date: Thu, 13 Aug 2026 16:59:42 +0300 Subject: [PATCH 3/4] Document Atomic Chat local API serving for agents Add an Atomic Chat tab to the agent harness serving options and expand the Local API Server section on the Atomic Chat page with the enable steps, the default endpoint, and an OpenAI client example. --- deployment/on-device/atomic-chat.mdx | 28 +++++++++++++++++++++++++++- examples/agent-harnesses.mdx | 19 ++++++++++++++++++- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/deployment/on-device/atomic-chat.mdx b/deployment/on-device/atomic-chat.mdx index a17f44c..dad8492 100644 --- a/deployment/on-device/atomic-chat.mdx +++ b/deployment/on-device/atomic-chat.mdx @@ -50,7 +50,33 @@ LFM2-VL and LFM2.5-VL GGUF models run in Atomic Chat on both desktop and mobile. ## Local API Server -On macOS, Atomic Chat can expose the loaded model through a local OpenAI-compatible endpoint. Point Cline, Kilo Code, or any OpenAI client at the base URL shown in the app, with no API key required. +On desktop, Atomic Chat can serve the currently loaded model through a local OpenAI-compatible endpoint: + +1. Load the model in a chat +2. Open **Integrations** +3. Click **Start Server** + +The server listens at `http://localhost:1337/v1` by default (the port, path prefix, and an optional API key are configurable in the server settings). Point Cline, Kilo Code, or any OpenAI client at it: + +```python +from openai import OpenAI + +client = OpenAI( + base_url="http://localhost:1337/v1", + api_key="not-needed" +) + +response = client.chat.completions.create( + model="lfm2.5-1.2b-instruct", # the model name shown in the app + messages=[ + {"role": "user", "content": "What is machine learning?"} + ], + temperature=0.1, + max_tokens=512, + extra_body={"top_k": 50, "repeat_penalty": 1.05}, +) +print(response.choices[0].message.content) +``` ## Tips diff --git a/examples/agent-harnesses.mdx b/examples/agent-harnesses.mdx index eb93ea4..1fb658f 100644 --- a/examples/agent-harnesses.mdx +++ b/examples/agent-harnesses.mdx @@ -16,7 +16,7 @@ local URL yours prints. You point your harness at that URL. Each backend uses its own default port, so your endpoint depends on which one you run. - llama.cpp and MLX use `8080`, vLLM uses `8000`, SGLang uses `30000`, and LM Studio uses `1234`. + llama.cpp and MLX use `8080`, vLLM uses `8000`, SGLang uses `30000`, LM Studio uses `1234`, and Atomic Chat uses `1337`. The examples in this guide use `http://localhost:8080/v1`. When you configure a harness, replace the port with your server's. @@ -101,6 +101,23 @@ Install one backend and start it with tool calling enabled. 3. Set the context length in the model settings. 4. Click **Start Server**. It serves at `http://localhost:1234`. + + **Install:** + + Download and install [Atomic Chat](https://atomic.chat), then search for **LFM2.5-2.6B** in + the model library and download the `Q4_K_M` GGUF. See the + [Atomic Chat guide](/deployment/on-device/atomic-chat). + + **Run:** + + 1. Load **LFM2.5-2.6B** in a chat. + 2. Open **Integrations**. + 3. Click **Start Server**. It serves the loaded model at `http://localhost:1337/v1`. + + The API key is optional for local use; leave it empty unless you set one in the server settings. + The same Integrations screen also bundles launchers for Hermes Agent, OpenClaw, and Kilo Code, + so you can run a harness right next to the server. + **Install** (Apple Silicon only): From bbd5cb9126ee681e3e7ec42f1447cbfc83d65cf0 Mon Sep 17 00:00:00 2001 From: Leonie Monigatti Date: Fri, 21 Aug 2026 13:53:18 +0200 Subject: [PATCH 4/4] minor polishes --- deployment/on-device/atomic-chat.mdx | 126 +++++++++++++++++++++------ examples/agent-harnesses.mdx | 5 +- lfm/models/complete-library.mdx | 2 +- 3 files changed, 104 insertions(+), 29 deletions(-) diff --git a/deployment/on-device/atomic-chat.mdx b/deployment/on-device/atomic-chat.mdx index dad8492..8dd865b 100644 --- a/deployment/on-device/atomic-chat.mdx +++ b/deployment/on-device/atomic-chat.mdx @@ -1,6 +1,6 @@ --- title: "Atomic Chat" -description: "Atomic Chat is a desktop and mobile app for running LLMs and agents locally with a friendly graphical user interface." +description: "Atomic Chat is a desktop and mobile app for running LLMs locally with a graphical user interface." --- @@ -21,42 +21,50 @@ Download and install Atomic Chat from [atomic.chat](https://atomic.chat): ## Downloading Models -1. Open Atomic Chat and open the model library -2. Search for "LiquidAI" or any other model -3. Select a model and quantization level -4. Click Download +1. Open Atomic Chat and open the model library via the **Models** tab +2. Search for "LiquidAI" +3. Select a model and quantization level (`Q4_K_M` recommended) +4. Click **Download** -The model library searches Hugging Face directly, so all LiquidAI GGUF releases are available in the app from day zero. +See the [Models page](/lfm/models/complete-library) for all available GGUF models. -### Open from Hugging Face - -Atomic Chat is a Local Apps provider on Hugging Face, so models can be opened straight from the Hub: +## Using the Chat Interface -1. Open any GGUF or MLX model page, for example [LFM2.5-VL-3B-GGUF](https://huggingface.co/LiquidAI/LFM2.5-VL-3B-GGUF) -2. Click **Use this model** and choose **Atomic Chat** -3. The model opens in the app: download it and start chatting +1. Go to the **New Chat** tab +2. Select your model from the dropdown +3. Adjust parameters (`temperature`, `top_k`, `repeat_penalty`) in the model settings +4. Start chatting -## Using the Chat Interface +## Generation Parameters -1. Start a new chat and select your downloaded model -2. Adjust sampling parameters (`temperature`, `top_k`, `repeat_penalty`) in the model settings -3. Start chatting +Control text generation behavior using the GUI sidebar or API parameters. Key parameters: -Use the sampling parameters recommended on each model card. For example, `LFM2.5-1.2B-Instruct` works best with `temperature` 0.1, `top_k` 50, and `repeat_penalty` 1.05. +* **`temperature`** (`float`, default 1.0): Controls randomness (0.0 = deterministic, higher = more random). Typical range: 0.1-2.0 +* **`top_p`** (`float`, default 1.0): Nucleus sampling - limits to tokens with cumulative probability ≤ top\_p. Typical range: 0.1-1.0 +* **`top_k`** (`int`, default 40): Limits to top-k most probable tokens. Typical range: 1-100 +* **`repeat_penalty`** (`float`, default 1.0): Penalty for repeating tokens (>1.0 = discourage repetition). Typical range: 1.0-1.5 -## Vision Models +Via the OpenAI-compatible API: -LFM2-VL and LFM2.5-VL GGUF models run in Atomic Chat on both desktop and mobile. Download a vision model from the model library, then attach images to your messages to ask questions about them. +```python +response = client.chat.completions.create( + model="local-model", + messages=[{"role": "user", "content": "What is machine learning?"}], + temperature=0.1, + max_tokens=512, + extra_body={"top_k": 50, "repeat_penalty": 1.05}, +) +``` -## Local API Server +## Running the Server -On desktop, Atomic Chat can serve the currently loaded model through a local OpenAI-compatible endpoint: +On desktop, Atomic Chat can serve the currently loaded model through a local OpenAI-compatible server for programmatic access: 1. Load the model in a chat -2. Open **Integrations** -3. Click **Start Server** +2. Open the **Integrations** tab +3. Click **Start Server** (runs at `http://localhost:1337/`) -The server listens at `http://localhost:1337/v1` by default (the port, path prefix, and an optional API key are configurable in the server settings). Point Cline, Kilo Code, or any OpenAI client at it: +Use the OpenAI Python client: ```python from openai import OpenAI @@ -67,7 +75,7 @@ client = OpenAI( ) response = client.chat.completions.create( - model="lfm2.5-1.2b-instruct", # the model name shown in the app + model="local-model", # Any string works messages=[ {"role": "user", "content": "What is machine learning?"} ], @@ -78,6 +86,74 @@ response = client.chat.completions.create( print(response.choices[0].message.content) ``` +### Streaming Responses + +```python +stream = client.chat.completions.create( + model="local-model", + messages=[ + {"role": "user", "content": "Tell me a story."} + ], + stream=True +) + +for chunk in stream: + if chunk.choices[0].delta.content is not None: + print(chunk.choices[0].delta.content, end="") +``` + +You can also use curl to interact with the server: + + + ```bash + curl http://localhost:1337/v1/chat/completions \ + -H "Content-Type: application/json" \ + -d '{ + "model": "local-model", + "messages": [{"role": "user", "content": "Hello!"}], + "temperature": 0.1, + "top_k": 50, + "repeat_penalty": 1.05 + }' + ``` + + +## Vision Models + +LFM2-VL and LFM2.5-VL GGUF models run in Atomic Chat on both desktop and mobile. + +Download a vision model from the model library, then attach images to your messages to ask questions about them. + + + ```python + from openai import OpenAI + import base64 + + client = OpenAI( + base_url="http://localhost:1337/v1", + api_key="not-needed" + ) + + # 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="local-model", + messages=[ + { + "role": "user", + "content": [ + {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_data}"}}, + {"type": "text", "text": "What's in this image?"} + ] + } + ] + ) + print(response.choices[0].message.content) + ``` + + ## Tips * **Quantization**: `Q4_K_M` offers the best balance of size and quality; step up to `Q6_K` or `Q8_0` if you have memory to spare diff --git a/examples/agent-harnesses.mdx b/examples/agent-harnesses.mdx index 1fb658f..fb09523 100644 --- a/examples/agent-harnesses.mdx +++ b/examples/agent-harnesses.mdx @@ -111,10 +111,9 @@ Install one backend and start it with tool calling enabled. **Run:** 1. Load **LFM2.5-2.6B** in a chat. - 2. Open **Integrations**. - 3. Click **Start Server**. It serves the loaded model at `http://localhost:1337/v1`. + 2. Open the **Integrations** tab. + 3. Click **Start Server**. It serves the loaded model at `http://localhost:1337`. - The API key is optional for local use; leave it empty unless you set one in the server settings. The same Integrations screen also bundles launchers for Hermes Agent, OpenClaw, and Kilo Code, so you can run a harness right next to the server. diff --git a/lfm/models/complete-library.mdx b/lfm/models/complete-library.mdx index 862613f..48182cb 100644 --- a/lfm/models/complete-library.mdx +++ b/lfm/models/complete-library.mdx @@ -8,7 +8,7 @@ description: "Liquid Foundation Models (LFMs) are a new class of multimodal arch All of our models share the following capabilities: - 32K token context length for extended conversations and document processing (128K for LFM2.5-8B-A1B) -- Designed for fast inference with [Transformers](/deployment/gpu-inference/transformers), [llama.cpp](/deployment/on-device/llama-cpp), [vLLM](/deployment/gpu-inference/vllm), [SGLang](/deployment/gpu-inference/sglang), [MLX](/deployment/on-device/mlx), [Ollama](/deployment/on-device/ollama), [Atomic Chat](/deployment/on-device/atomic-chat), and [LEAP](/deployment/on-device/sdk/quick-start) +- Designed for fast inference with [Transformers](/deployment/gpu-inference/transformers), [llama.cpp](/deployment/on-device/llama-cpp), [vLLM](/deployment/gpu-inference/vllm), [SGLang](/deployment/gpu-inference/sglang), [MLX](/deployment/on-device/mlx), [Ollama](/deployment/on-device/ollama), [Atomic Chat](/deployment/on-device/atomic-chat), and [LEAP](/deployment/on-device/sdk/quick-start) - Trainable via SFT, DPO, VLM, and GRPO workflows with [LEAP Finetune](/lfm/fine-tuning/leap-finetune), [TRL](/lfm/fine-tuning/trl), and [Unsloth](/lfm/fine-tuning/unsloth)