feat(parakeet-cpp): Moondream Ultra and Redux gallery entries, VAD option, pin bump (#12455)

* chore(parakeet-cpp): bump parakeet.cpp to 11c1a0f

Picks up support for the Moondream Ultra and Redux models and the
VAD-segmented transcription entry point (C-API ABI is still 10).

Assisted-by: Claude:claude-sonnet-5-5

* feat(parakeet-cpp): add vad option for long-audio transcription

Models with a VAD head (Moondream Ultra and Redux) can cut long audio at
pauses. Setting vad:true in the model options routes offline
transcription through parakeet_capi_transcribe_path_json_vad. The symbol
is probed at startup like the other optional entry points, and vad:true
fails the load with a clear message when the library lacks it. A model
without a VAD head fails the request with the library's own message.
The option is off by default and does not affect streaming.

Also say in the load error that a packed ternary Redux model is CPU only,
because the library reports its refusal on a GPU backend through its log,
not through the C API.

Assisted-by: Claude:claude-sonnet-5-5

* feat(gallery): add Moondream Ultra and Redux for parakeet-cpp

Add five entries from the public parakeet-cpp GGUF repository: Ultra in
F16 and Q8_0, and Redux as packed ternary (CPU only, offline only) and
as dequantized F16 and Q8_0 (any backend). The entries enable vad:true so
long audio is cut at pauses. Checksums come from the repository's LFS
metadata. The weights are CC-BY-4.0.

Assisted-by: Claude:claude-sonnet-5-5

* docs(parakeet-cpp): document Moondream Ultra, Redux and the vad option

Assisted-by: Claude:claude-sonnet-5-5

---------

Co-authored-by: Ettore Di Giacinto <mudler@localai.io>

backend/go/parakeet-cpp/Makefile

@@ -1,6 +1,6 @@
 # parakeet-cpp backend Makefile.
 #
-# Upstream pin lives below as PARAKEET_VERSION?=bee7c14dfcc23613df58176c59a40459e7b47095
+# Upstream pin lives below as PARAKEET_VERSION?=11c1a0fc00556d390987e651217f9fc7caa4c4f7
 # (.github/bump_deps.sh) can find and update it - matches the
 # whisper.cpp / ds4 / vibevoice-cpp convention.
 #
@@ -15,7 +15,7 @@
 # That's what the L0 smoke test uses. The default target below does the
 # proper clone-at-pin + cmake build so CI doesn't need a side-checkout.
 
-PARAKEET_VERSION?=bee7c14dfcc23613df58176c59a40459e7b47095
+PARAKEET_VERSION?=11c1a0fc00556d390987e651217f9fc7caa4c4f7
 PARAKEET_REPO?=https://github.com/mudler/parakeet.cpp
 
 GOCMD?=go

backend/go/parakeet-cpp/goparakeetcpp.go

@@ -39,6 +39,13 @@ var (
 	CppFreeString         func(s uintptr)
 	CppLastError          func(ctx uintptr) string
 
+	// CppTranscribePathJSONVad is CppTranscribePathJSON with long audio cut at
+	// pauses by the model's own VAD head (segments of at most 30 s; the document
+	// has the same shape, times are relative to the whole file). Returns 0 and
+	// sets last_error to "model has no VAD head" for models without one. Present
+	// only in newer libparakeet.so (additive, no ABI bump); nil when absent.
+	CppTranscribePathJSONVad func(ctx uintptr, wavPath string, decoder int32) uintptr
+
 	// Batched JSON transcription: takes a concatenated float buffer of clips
 	// plus their per-clip sample counts (sum(nSamples)==len(samplesConcat))
 	// and returns a malloc'd char* JSON ARRAY of per-clip {"text","words",
@@ -239,6 +246,10 @@ type ParakeetCpp struct {
 	// YAML option, default 0=off). When >0 it adds NeMo's silence-gap split on
 	// top of the punctuation split; converted to seconds via the JSON frame_sec.
 	segmentGapFrames int
+	// vad routes offline transcription through the VAD-segmented C-API entry
+	// point (vad:true model option). It bypasses the dynamic batcher, which has
+	// no VAD variant, and is not used for streaming.
+	vad bool
 }
 
 // Load is the LocalAI gRPC entry point for LoadModel: it calls
@@ -250,6 +261,12 @@ func (p *ParakeetCpp) Load(opts *pb.ModelOptions) error {
 		return errors.New("parakeet-cpp: ModelFile is required")
 	}
 
+	vad, err := parseVADOption(opts)
+	if err != nil {
+		return err
+	}
+	p.vad = vad
+
 	if err := p.loadRoles(opts); err != nil {
 		return err
 	}
@@ -309,6 +326,37 @@ func optInt(opts *pb.ModelOptions, key string, def int) int {
 	return def
 }
 
+// optBool reads a boolean model option (key:value form, strconv.ParseBool
+// values). It returns def when the key is absent and an error when the value
+// does not parse, so a typo like "vad:ture" fails the load instead of being
+// silently ignored.
+func optBool(opts *pb.ModelOptions, key string, def bool) (bool, error) {
+	v := optString(opts, key)
+	if v == "" {
+		return def, nil
+	}
+	b, err := strconv.ParseBool(v)
+	if err != nil {
+		return false, fmt.Errorf("parakeet-cpp: option %s: %q is not a boolean", key, v)
+	}
+	return b, nil
+}
+
+// parseVADOption reads the vad: model option (default false). Enabling it
+// needs a libparakeet.so that exports parakeet_capi_transcribe_path_json_vad.
+// Whether the model itself has a VAD head is only known to the library; a
+// model without one fails each request with the library's message.
+func parseVADOption(opts *pb.ModelOptions) (bool, error) {
+	vad, err := optBool(opts, "vad", false)
+	if err != nil || !vad {
+		return false, err
+	}
+	if CppTranscribePathJSONVad == nil {
+		return false, errors.New("parakeet-cpp: vad:true needs a libparakeet.so with parakeet_capi_transcribe_path_json_vad; rebuild the backend against a newer parakeet.cpp")
+	}
+	return true, nil
+}
+
 // runBatch is the dispatcher's batch handler and the ONLY caller of the C
 // engine on the unary path. It concatenates the batch PCM, calls the batched
 // JSON C-API under engineMu, splits the JSON array, and replies to each request.
@@ -402,21 +450,30 @@ func (p *ParakeetCpp) AudioTranscription(ctx context.Context, opts *pb.Transcrip
 	// any non-WAV upload (MP3, etc.) fails with "failed to load audio". This
 	// mirrors what every other audio backend (whisper, crispasr) does via
 	// utils.AudioToWav before handing the file to the engine.
-	if p.bat == nil {
+	//
+	// With vad:true the same file-path route is taken through the
+	// VAD-segmented entry point, which cuts long audio at pauses. The batcher
+	// has no VAD variant, so this path replaces it for offline requests.
+	if p.bat == nil || p.vad {
 		converted, cleanup, err := convertToWavMono16k(opts.Dst)
 		if err != nil {
 			return pb.TranscriptResult{}, err
 		}
 		defer cleanup()
-		cstr := CppTranscribePathJSON(p.ctxPtr, converted, 0)
-		if cstr == 0 {
-			return pb.TranscriptResult{}, fmt.Errorf("parakeet-cpp: transcribe_path_json failed: %s", CppLastError(p.ctxPtr))
+		doc, err := p.transcribePathDoc(converted)
+		if err != nil {
+			return pb.TranscriptResult{}, err
 		}
-		raw := goStringFromCPtr(cstr)
-		CppFreeString(cstr)
-		var doc transcriptJSON
-		if err := json.Unmarshal([]byte(raw), &doc); err != nil {
-			return pb.TranscriptResult{}, fmt.Errorf("parakeet-cpp: decode transcript json: %w", err)
+		if p.vad && p.wantSpeakers(opts.GetDiarize()) && len(doc.Words) > 0 {
+			pcm, _, err := decodeWavMono16k(converted)
+			if err != nil {
+				return pb.TranscriptResult{}, err
+			}
+			segs, err := p.diarizeSegmentsPCM(pcm)
+			if err != nil {
+				return pb.TranscriptResult{}, err
+			}
+			return transcriptResultWithSpeakers(doc, opts, p.segmentGapFrames, assignSpeakers(doc.Words, segs)), nil
 		}
 		return transcriptResultFromDoc(doc, opts, p.segmentGapFrames), nil
 	}
@@ -460,6 +517,34 @@ func (p *ParakeetCpp) AudioTranscription(ctx context.Context, opts *pb.Transcrip
 	return transcriptResultWithSpeakers(doc, opts, p.segmentGapFrames, speakers), nil
 }
 
+// transcribePathDoc transcribes a 16 kHz mono WAV at path through the file-path
+// C-API (the VAD-segmented variant when vad:true) and decodes the JSON document.
+// It holds engineMu for the call: the engine is single-threaded and the batcher
+// is not involved on this path.
+func (p *ParakeetCpp) transcribePathDoc(path string) (transcriptJSON, error) {
+	fn, name := CppTranscribePathJSON, "transcribe_path_json"
+	if p.vad {
+		fn, name = CppTranscribePathJSONVad, "transcribe_path_json_vad"
+	}
+	p.engineMu.Lock()
+	cstr := fn(p.ctxPtr, path, 0)
+	var lastErr string
+	if cstr == 0 {
+		lastErr = CppLastError(p.ctxPtr)
+	}
+	p.engineMu.Unlock()
+	if cstr == 0 {
+		return transcriptJSON{}, fmt.Errorf("parakeet-cpp: %s failed: %s", name, lastErr)
+	}
+	raw := goStringFromCPtr(cstr)
+	CppFreeString(cstr)
+	var doc transcriptJSON
+	if err := json.Unmarshal([]byte(raw), &doc); err != nil {
+		return transcriptJSON{}, fmt.Errorf("parakeet-cpp: decode transcript json: %w", err)
+	}
+	return doc, nil
+}
+
 // segmentSeparators is NeMo's default segment_seperators (sentence-ending
 // punctuation). Splitting on these matches NeMo's default segment timestamps.
 var segmentSeparators = []rune{'.', '?', '!'}

backend/go/parakeet-cpp/goparakeetcpp_test.go

@@ -48,6 +48,9 @@ func ensureLibLoaded() {
 		purego.RegisterLibFunc(&CppFree, lib, "parakeet_capi_free")
 		purego.RegisterLibFunc(&CppTranscribePath, lib, "parakeet_capi_transcribe_path")
 		purego.RegisterLibFunc(&CppTranscribePathJSON, lib, "parakeet_capi_transcribe_path_json")
+		if sym, err := purego.Dlsym(lib, "parakeet_capi_transcribe_path_json_vad"); err == nil && sym != 0 {
+			purego.RegisterLibFunc(&CppTranscribePathJSONVad, lib, "parakeet_capi_transcribe_path_json_vad")
+		}
 		if sym, err := purego.Dlsym(lib, "parakeet_capi_transcribe_pcm_batch_json"); err == nil && sym != 0 {
 			purego.RegisterLibFunc(&CppTranscribePcmBatchJSON, lib, "parakeet_capi_transcribe_pcm_batch_json")
 		}

backend/go/parakeet-cpp/main.go

@@ -71,6 +71,13 @@ func main() {
 		purego.RegisterLibFunc(&CppTranscribePcmBatchJSON, lib, "parakeet_capi_transcribe_pcm_batch_json")
 	}
 
+	// VAD-segmented offline transcription (vad:true model option). Additive in
+	// the C-API (no ABI bump); same probe pattern, so an older libparakeet.so
+	// still loads and Load refuses vad:true with a clear message.
+	if sym, err := purego.Dlsym(lib, "parakeet_capi_transcribe_path_json_vad"); err == nil && sym != 0 {
+		purego.RegisterLibFunc(&CppTranscribePathJSONVad, lib, "parakeet_capi_transcribe_path_json_vad")
+	}
+
 	// Per-request language variants (multilingual nemotron). Same probe pattern:
 	// present only in libparakeet.so built with multilingual support, so the
 	// backend still loads against an older library and falls back to the

backend/go/parakeet-cpp/roles.go

@@ -166,7 +166,12 @@ func (p *ParakeetCpp) loadRoles(opts *pb.ModelOptions) error {
 		// No ctx to ask for last_error (the C-API's last-error buffer lives on
 		// the ctx that was never returned). Surface the path so the operator
 		// at least knows which load failed.
-		return fmt.Errorf("parakeet-cpp: parakeet_capi_load failed for %q", opts.ModelFile)
+		//
+		// A packed ternary Redux GGUF (redux-packed) is the likeliest cause on a
+		// GPU build: the library refuses it with a message that goes to its own
+		// log, not through the C-API, so name the cause here.
+		return fmt.Errorf("parakeet-cpp: parakeet_capi_load failed for %q (see the backend log for the library message; "+
+			"a packed ternary Redux model is CPU only and is refused on a GPU backend, use the redux-f16 or redux-q8_0 file there)", opts.ModelFile)
 	}
 	loaded := []uintptr{primary}
 	// freeLoaded undoes everything loadRoles opened this call: every context

backend/go/parakeet-cpp/vad_test.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"context"
+	"path/filepath"
+
+	pb "github.com/mudler/LocalAI/pkg/grpc/proto"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+// The vad: option specs run against stubbed C entry points (the same seam as
+// diarize_test.go), so they need no libparakeet.so.
+
+var _ = Describe("vad: model option", func() {
+	var (
+		savedVad, savedPlain func(uintptr, string, int32) uintptr
+		savedFree            func(uintptr)
+		savedLastError       func(uintptr) string
+		pool                 *diarizeCstrPool
+	)
+
+	BeforeEach(func() {
+		savedVad, savedPlain = CppTranscribePathJSONVad, CppTranscribePathJSON
+		savedFree, savedLastError = CppFreeString, CppLastError
+		pool = &diarizeCstrPool{}
+		CppFreeString = func(uintptr) {}
+	})
+	AfterEach(func() {
+		CppTranscribePathJSONVad, CppTranscribePathJSON = savedVad, savedPlain
+		CppFreeString, CppLastError = savedFree, savedLastError
+	})
+
+	opts := func(o ...string) *pb.ModelOptions { return &pb.ModelOptions{Options: o} }
+
+	It("is off by default and does not need the VAD symbol", func() {
+		CppTranscribePathJSONVad = nil
+		vad, err := parseVADOption(opts())
+		Expect(err).ToNot(HaveOccurred())
+		Expect(vad).To(BeFalse())
+	})
+
+	It("parses vad:true when the library exports the VAD entry point", func() {
+		CppTranscribePathJSONVad = func(uintptr, string, int32) uintptr { return 0 }
+		vad, err := parseVADOption(opts("vad:true"))
+		Expect(err).ToNot(HaveOccurred())
+		Expect(vad).To(BeTrue())
+	})
+
+	It("refuses vad:true on a library without the VAD entry point", func() {
+		CppTranscribePathJSONVad = nil
+		_, err := parseVADOption(opts("vad:true"))
+		Expect(err).To(MatchError(ContainSubstring("parakeet_capi_transcribe_path_json_vad")))
+	})
+
+	It("rejects a value that is not a boolean", func() {
+		_, err := parseVADOption(opts("vad:ture"))
+		Expect(err).To(MatchError(ContainSubstring(`"ture" is not a boolean`)))
+	})
+
+	It("routes AudioTranscription through the VAD entry point, not the batcher", func() {
+		CppTranscribePathJSON = func(uintptr, string, int32) uintptr {
+			Fail("the plain path entry point must not be used when vad is on")
+			return 0
+		}
+		var gotPath string
+		CppTranscribePathJSONVad = func(ctx uintptr, path string, decoder int32) uintptr {
+			gotPath = path
+			Expect(ctx).To(Equal(uintptr(7)))
+			Expect(decoder).To(Equal(int32(0)))
+			return pool.cstr(`{"text":"hello world.","frame_sec":0.08,"words":[` +
+				`{"w":"hello","start":0.1,"end":0.4,"conf":0.9},` +
+				`{"w":"world.","start":40.0,"end":40.5,"conf":0.9}],"tokens":[]}`)
+		}
+		wav := filepath.Join(GinkgoT().TempDir(), "long.wav")
+		writeMono16kWav(wav, 16000)
+
+		// bat is nil and vad is on: the VAD route must be taken either way.
+		p := &ParakeetCpp{ctxPtr: 7, vad: true}
+		res, err := p.AudioTranscription(context.Background(), &pb.TranscriptRequest{Dst: wav})
+		Expect(err).ToNot(HaveOccurred())
+		Expect(gotPath).ToNot(BeEmpty())
+		Expect(res.Text).To(Equal("hello world."))
+		Expect(res.Segments).ToNot(BeEmpty())
+	})
+
+	It("surfaces the library message when the model has no VAD head", func() {
+		CppTranscribePathJSONVad = func(uintptr, string, int32) uintptr { return 0 }
+		CppLastError = func(uintptr) string { return "model has no VAD head" }
+		wav := filepath.Join(GinkgoT().TempDir(), "a.wav")
+		writeMono16kWav(wav, 16000)
+
+		p := &ParakeetCpp{ctxPtr: 7, vad: true}
+		_, err := p.AudioTranscription(context.Background(), &pb.TranscriptRequest{Dst: wav})
+		Expect(err).To(MatchError(ContainSubstring("transcribe_path_json_vad failed: model has no VAD head")))
+	})
+})

docs/content/features/audio-to-text.md

@@ -243,6 +243,33 @@ options:
 
 By default each request runs on its own. Raise `batch_max_size` (for example 4 to 16) to enable batching; it pays off on GPU under concurrent load, where coalescing the per-step decode GEMMs across requests is a large throughput win. Leave it at 1 on CPU and for low-concurrency setups, where batching only adds latency. Batching only affects concurrent unary requests; streaming sessions always run on their own.
 
+### Moondream Ultra and Redux
+
+[Moondream](https://huggingface.co/moondream) publishes two derivatives of NVIDIA parakeet-tdt-0.6b-v3, Ultra and Redux. Both have a voice-activity-detection (VAD) head. The gallery has five entries, built from the GGUFs in [`mudler/parakeet-cpp-gguf`](https://huggingface.co/mudler/parakeet-cpp-gguf):
+
+| Gallery entry | File | Runs on |
+|---|---|---|
+| `parakeet-cpp-moondream-ultra-f16` | `ultra-f16.gguf` | CPU and GPU |
+| `parakeet-cpp-moondream-ultra-q8_0` | `ultra-q8_0.gguf` | CPU and GPU |
+| `parakeet-cpp-moondream-redux-packed` | `redux-packed.gguf` | CPU only, offline only |
+| `parakeet-cpp-moondream-redux-f16` | `redux-f16.gguf` | any backend, can stream |
+| `parakeet-cpp-moondream-redux-q8_0` | `redux-q8_0.gguf` | any backend |
+
+The packed Redux file stores the encoder as ternary weights (213 MB). It cannot load on a GPU backend and cannot stream. If a GPU build fails to load it, check the backend log for the library message and use the `redux-f16` or `redux-q8_0` entry instead. The weights are CC-BY-4.0: credit Moondream and NVIDIA.
+
+With `vad:true`, long audio is cut at pauses found by the model's VAD head into pieces of at most 30 seconds, and each piece is transcribed in turn. Word timestamps stay relative to the whole file. Audio of 30 seconds or less gives the same result as without the option. The gallery entries set it. Add it to your own model YAML like this:
+
+```yaml
+name: moondream-ultra
+backend: parakeet-cpp
+parameters:
+  model: ultra-q8_0.gguf
+options:
+- vad:true   # cut long audio at pauses (default false); needs a model with a VAD head
+```
+
+`vad:true` applies to offline transcription only and bypasses dynamic batching, because the batched entry point has no VAD variant. Streaming is not affected. A model without a VAD head fails each request with `model has no VAD head`, and a `libparakeet.so` that is too old to export the VAD entry point fails the load. Remove the option for models that have no VAD head.
+
 ## See also
 
 - [Audio Transform]({{< relref "audio-transform.md" >}}) - clean up the audio (echo cancellation, noise suppression, dereverberation) before passing it to a transcription model.

gallery/index.yaml

@@ -53764,6 +53764,171 @@
     - filename: parakeet-cpp/nemotron-3.5-asr-streaming-0.6b-q8_0.gguf
       uri: huggingface://mudler/parakeet-cpp-gguf/nemotron-3.5-asr-streaming-0.6b-q8_0.gguf
       sha256: ba2f13eccd4a5245be728f77e6149bd6a4fdcdd133ff2e08ac6005bcef7a99f1
+- name: parakeet-cpp-moondream-ultra-f16
+  url: github:mudler/LocalAI/gallery/virtual.yaml@master
+  urls:
+    - https://huggingface.co/mudler/parakeet-cpp-gguf
+    - https://github.com/mudler/parakeet.cpp
+  description: |
+    Moondream Ultra, F16: Moondream's post-trained derivative of NVIDIA parakeet-tdt-0.6b-v3 (TDT, 0.6B). Runs on CPU and GPU. Full-precision file, about 1.4 GB.
+    GGUF for the parakeet-cpp backend (C++/ggml port of NVIDIA NeMo Parakeet). The
+    model has a voice-activity-detection head, and the vad:true option cuts long
+    audio at pauses before transcription. License CC-BY-4.0: credit Moondream and NVIDIA.
+  license: cc-by-4.0
+  tags:
+    - parakeet
+    - parakeet-cpp
+    - moondream
+    - asr
+    - speech-recognition
+    - stt
+    - gguf
+    - ggml
+  overrides:
+    backend: parakeet-cpp
+    known_usecases:
+      - transcript
+    name: parakeet-cpp-moondream-ultra-f16
+    options:
+      - vad:true
+    parameters:
+      model: parakeet-cpp/ultra-f16.gguf
+  files:
+    - filename: parakeet-cpp/ultra-f16.gguf
+      uri: huggingface://mudler/parakeet-cpp-gguf/ultra-f16.gguf
+      sha256: 5414aea5536178726e8dca20cdfc91cfa3e5443a83a65c4d08acd1c5df65323f
+- name: parakeet-cpp-moondream-ultra-q8_0
+  url: github:mudler/LocalAI/gallery/virtual.yaml@master
+  urls:
+    - https://huggingface.co/mudler/parakeet-cpp-gguf
+    - https://github.com/mudler/parakeet.cpp
+  description: |
+    Moondream Ultra, Q8_0: the same model as the F16 file, quantized to 8 bits (about 0.9 GB). Runs on CPU and GPU.
+    GGUF for the parakeet-cpp backend (C++/ggml port of NVIDIA NeMo Parakeet). The
+    model has a voice-activity-detection head, and the vad:true option cuts long
+    audio at pauses before transcription. License CC-BY-4.0: credit Moondream and NVIDIA.
+  license: cc-by-4.0
+  tags:
+    - parakeet
+    - parakeet-cpp
+    - moondream
+    - asr
+    - speech-recognition
+    - stt
+    - gguf
+    - ggml
+  overrides:
+    backend: parakeet-cpp
+    known_usecases:
+      - transcript
+    name: parakeet-cpp-moondream-ultra-q8_0
+    options:
+      - vad:true
+    parameters:
+      model: parakeet-cpp/ultra-q8_0.gguf
+  files:
+    - filename: parakeet-cpp/ultra-q8_0.gguf
+      uri: huggingface://mudler/parakeet-cpp-gguf/ultra-q8_0.gguf
+      sha256: c2fb452a9df468a141012b01c8c168a25ce93f710897c7de6e353c6cc250986a
+- name: parakeet-cpp-moondream-redux-packed
+  url: github:mudler/LocalAI/gallery/virtual.yaml@master
+  urls:
+    - https://huggingface.co/mudler/parakeet-cpp-gguf
+    - https://github.com/mudler/parakeet.cpp
+  description: |
+    Moondream Redux, packed ternary weights (about 213 MB). Redux is Moondream's ternary-encoder derivative of NVIDIA parakeet-tdt-0.6b-v3 (TDT, 0.6B). CPU only and offline only: the library refuses to load it on a GPU backend and does not stream it. For a GPU or for streaming, use the redux-f16 or redux-q8_0 entry instead.
+    GGUF for the parakeet-cpp backend (C++/ggml port of NVIDIA NeMo Parakeet). The
+    model has a voice-activity-detection head, and the vad:true option cuts long
+    audio at pauses before transcription. License CC-BY-4.0: credit Moondream and NVIDIA.
+  license: cc-by-4.0
+  tags:
+    - parakeet
+    - parakeet-cpp
+    - moondream
+    - asr
+    - speech-recognition
+    - stt
+    - gguf
+    - ggml
+  overrides:
+    backend: parakeet-cpp
+    known_usecases:
+      - transcript
+    name: parakeet-cpp-moondream-redux-packed
+    options:
+      - vad:true
+    parameters:
+      model: parakeet-cpp/redux-packed.gguf
+  files:
+    - filename: parakeet-cpp/redux-packed.gguf
+      uri: huggingface://mudler/parakeet-cpp-gguf/redux-packed.gguf
+      sha256: 574614b9a4d9f72ab202877a7ad6a1f4bf819dd1d27b9d42dfe8cd429fcebdd5
+- name: parakeet-cpp-moondream-redux-f16
+  url: github:mudler/LocalAI/gallery/virtual.yaml@master
+  urls:
+    - https://huggingface.co/mudler/parakeet-cpp-gguf
+    - https://github.com/mudler/parakeet.cpp
+  description: |
+    Moondream Redux, dequantized to F16 (about 1.4 GB). Same model as the packed file, but it runs on any backend, including GPU, and can stream.
+    GGUF for the parakeet-cpp backend (C++/ggml port of NVIDIA NeMo Parakeet). The
+    model has a voice-activity-detection head, and the vad:true option cuts long
+    audio at pauses before transcription. License CC-BY-4.0: credit Moondream and NVIDIA.
+  license: cc-by-4.0
+  tags:
+    - parakeet
+    - parakeet-cpp
+    - moondream
+    - asr
+    - speech-recognition
+    - stt
+    - gguf
+    - ggml
+  overrides:
+    backend: parakeet-cpp
+    known_usecases:
+      - transcript
+    name: parakeet-cpp-moondream-redux-f16
+    options:
+      - vad:true
+    parameters:
+      model: parakeet-cpp/redux-f16.gguf
+  files:
+    - filename: parakeet-cpp/redux-f16.gguf
+      uri: huggingface://mudler/parakeet-cpp-gguf/redux-f16.gguf
+      sha256: f2e2a9c412191a4ecbeb70f0c9b837749c0147489f7f2d36f3a0b4bc5d41cf79
+- name: parakeet-cpp-moondream-redux-q8_0
+  url: github:mudler/LocalAI/gallery/virtual.yaml@master
+  urls:
+    - https://huggingface.co/mudler/parakeet-cpp-gguf
+    - https://github.com/mudler/parakeet.cpp
+  description: |
+    Moondream Redux, dequantized and quantized to Q8_0 (about 0.9 GB). Runs on any backend, including GPU.
+    GGUF for the parakeet-cpp backend (C++/ggml port of NVIDIA NeMo Parakeet). The
+    model has a voice-activity-detection head, and the vad:true option cuts long
+    audio at pauses before transcription. License CC-BY-4.0: credit Moondream and NVIDIA.
+  license: cc-by-4.0
+  tags:
+    - parakeet
+    - parakeet-cpp
+    - moondream
+    - asr
+    - speech-recognition
+    - stt
+    - gguf
+    - ggml
+  overrides:
+    backend: parakeet-cpp
+    known_usecases:
+      - transcript
+    name: parakeet-cpp-moondream-redux-q8_0
+    options:
+      - vad:true
+    parameters:
+      model: parakeet-cpp/redux-q8_0.gguf
+  files:
+    - filename: parakeet-cpp/redux-q8_0.gguf
+      uri: huggingface://mudler/parakeet-cpp-gguf/redux-q8_0.gguf
+      sha256: 3429a4598946c406dbb4af5bb589d4dd307b069d550d98e24bef6779c4e6988f
 - name: parakeet-cpp-nemotron-3-diarization
   url: github:mudler/LocalAI/gallery/virtual.yaml@master
   urls: