From 3797753fbcc2f68a4b37e1ac67ff710c2b8dbd27 Mon Sep 17 00:00:00 2001
From: localai-org-maint-bot
 <306269227+localai-org-maint-bot@users.noreply.github.com>
Date: Thu, 20 Aug 2026 06:14:04 +0000
Subject: [PATCH] feat(tts): support multi-reference personalities

Saved profiles previously resolved to one audio path and transcript, so
cloning backends could not use several examples of one personality.

Store ordered audio and transcript pairs while preserving the legacy
first-reference fields. Fish Speech and audio.cpp receive all pairs,
including on distributed workers. Other backends retain their
single-reference behavior.

Assisted-by: Codex:gpt-5
---
 backend/cpp/audio-cpp/generation_request.cpp  |   3 +-
 .../audio-cpp/generation_request_ctest.cpp    |   8 +
 backend/python/fish-speech/backend.py         |  22 ++-
 core/http/endpoints/localai/tts.go            |  23 ++-
 core/http/endpoints/localai/voice_profiles.go |  71 ++++---
 .../endpoints/localai/voice_profiles_test.go  |  20 ++
 core/http/react-ui/e2e/voice-library.spec.js  |   4 +-
 .../react-ui/public/locales/en/media.json     |  37 ++--
 .../react-ui/src/pages/VoiceProfileCreate.jsx |  42 ++++-
 core/services/nodes/file_staging_client.go    |  39 ++++
 core/services/nodes/file_staging_tts_test.go  |  15 ++
 core/services/voiceprofile/store.go           | 174 ++++++++++++------
 core/services/voiceprofile/store_test.go      |  23 +++
 docs/content/features/text-to-audio.md        |  18 +-
 pkg/mcp/localaitools/dto.go                   |  18 +-
 pkg/mcp/localaitools/inproc/client.go         |  23 ++-
 swagger/docs.go                               |  17 ++
 swagger/swagger.json                          |  17 ++
 swagger/swagger.yaml                          |  11 ++
 19 files changed, 465 insertions(+), 120 deletions(-)

diff --git a/backend/cpp/audio-cpp/generation_request.cpp b/backend/cpp/audio-cpp/generation_request.cpp
index f74cb1a210d7..805bf35d8d8a 100644
--- a/backend/cpp/audio-cpp/generation_request.cpp
+++ b/backend/cpp/audio-cpp/generation_request.cpp
@@ -22,7 +22,8 @@ bool voice_is_reference_file(const std::string &voice) {
 
 RequestShape build_tts_shape(const backend::TTSRequest &request) {
     RequestShape shape;
-    shape.has_voice_reference = voice_is_reference_file(request.voice());
+    shape.has_voice_reference = voice_is_reference_file(request.voice()) ||
+                                request.params().find("multi_reference_cond") != request.params().end();
     // !empty() as well as has_instructions(), and it must match the guard in
     // build_tts_request: a request whose instructions are an empty string
     // carries no style condition, so telling routing to prefer VoiceDesign for
diff --git a/backend/cpp/audio-cpp/generation_request_ctest.cpp b/backend/cpp/audio-cpp/generation_request_ctest.cpp
index 507b2054de72..e9b5d51069bc 100644
--- a/backend/cpp/audio-cpp/generation_request_ctest.cpp
+++ b/backend/cpp/audio-cpp/generation_request_ctest.cpp
@@ -128,6 +128,14 @@ static void test_tts_shape() {
         check(!shape.has_voice_reference,
               "shape: a preset name is not a voice reference");
     }
+    {
+        backend::TTSRequest request;
+        (*request.mutable_params())["multi_reference_cond"] =
+            R"([{"audio":"one.wav","text":"one"}])";
+        const auto shape = build_tts_shape(request);
+        check(shape.has_voice_reference,
+              "shape: multi-reference conditioning is a voice reference");
+    }
     {
         backend::TTSRequest request;
         request.set_voice(dir.string());
diff --git a/backend/python/fish-speech/backend.py b/backend/python/fish-speech/backend.py
index 138396599a63..6dd46c4815c1 100644
--- a/backend/python/fish-speech/backend.py
+++ b/backend/python/fish-speech/backend.py
@@ -326,11 +326,29 @@ def TTS(self, request, context):
             max_new_tokens = self.options.get("max_new_tokens", 1024)
             chunk_length = self.options.get("chunk_length", 200)
 
-            # Build references list for voice cloning
+            # Build references list for voice cloning. Saved LocalAI
+            # personalities use the same ordered JSON shape as audio.cpp.
             references = []
             voice_name = request.voice if request.voice else None
 
-            if voice_name and os.path.isfile(voice_name):
+            multi_reference_cond = request.params.get("multi_reference_cond", "") if hasattr(request, "params") else ""
+            if multi_reference_cond:
+                reference_entries = json.loads(multi_reference_cond)
+                if not isinstance(reference_entries, list) or not reference_entries:
+                    raise ValueError("multi_reference_cond must be a non-empty JSON array")
+                for entry in reference_entries:
+                    if not isinstance(entry, dict) or not entry.get("audio") or not entry.get("text"):
+                        raise ValueError("multi_reference_cond entries require audio and text")
+                    ref_audio_path = self._get_ref_audio_path(entry["audio"])
+                    with open(ref_audio_path, "rb") as f:
+                        audio_bytes = f.read()
+                    references.append(ServeReferenceAudio(audio=audio_bytes, text=entry["text"]))
+                print(
+                    f"[INFO] Using {len(references)} per-request reference audios",
+                    file=sys.stderr,
+                )
+
+            elif voice_name and os.path.isfile(voice_name):
                 ref_audio_path = self._get_ref_audio_path(voice_name)
                 with open(ref_audio_path, "rb") as f:
                     audio_bytes = f.read()
diff --git a/core/http/endpoints/localai/tts.go b/core/http/endpoints/localai/tts.go
index 16b49a91267f..f8d6c558fdc6 100644
--- a/core/http/endpoints/localai/tts.go
+++ b/core/http/endpoints/localai/tts.go
@@ -1,6 +1,7 @@
 package localai
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -67,7 +68,7 @@ func TTSEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig
 				if profiles == nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "voice profile store is unavailable")
 				}
-				profile, referencePath, release, err := profiles.LeaseAudio(c.Request().Context(), profileID)
+				profile, referencePaths, release, err := profiles.LeaseAudios(c.Request().Context(), profileID)
 				if err != nil {
 					if errors.Is(err, voiceprofile.ErrNotFound) {
 						return echo.NewHTTPError(http.StatusNotFound, "voice profile not found")
@@ -75,7 +76,7 @@ func TTSEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig
 					return fmt.Errorf("resolve voice profile: %w", err)
 				}
 				defer release()
-				cfg.Voice = referencePath
+				cfg.Voice = referencePaths[0]
 				if cfg.Language == "" && profile.Language != "" {
 					cfg.Language = profile.Language
 				}
@@ -83,6 +84,20 @@ func TTSEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig
 					input.Params = make(map[string]string)
 				}
 				input.Params["ref_text"] = profile.Transcript
+				if supportsMultipleVoiceReferences(cfg.Backend) && len(referencePaths) > 1 {
+					references := make([]map[string]string, 0, len(referencePaths))
+					for index, path := range referencePaths {
+						references = append(references, map[string]string{"audio": path, "text": profile.References[index].Transcript})
+					}
+					encoded, err := json.Marshal(references)
+					if err != nil {
+						return fmt.Errorf("encode voice profile references: %w", err)
+					}
+					input.Params["multi_reference_cond"] = string(encoded)
+					if cfg.Backend == "audio-cpp" {
+						cfg.Voice = ""
+					}
+				}
 				xlog.Debug("Resolved saved voice profile", "id", profile.ID, "model", input.Model)
 			}
 		}
@@ -138,3 +153,7 @@ func TTSEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig
 		return c.Attachment(filePath, filepath.Base(filePath))
 	}
 }
+
+func supportsMultipleVoiceReferences(backendName string) bool {
+	return backendName == "fish-speech" || backendName == "audio-cpp"
+}
diff --git a/core/http/endpoints/localai/voice_profiles.go b/core/http/endpoints/localai/voice_profiles.go
index 38990d212cb7..d2f19eb4a568 100644
--- a/core/http/endpoints/localai/voice_profiles.go
+++ b/core/http/endpoints/localai/voice_profiles.go
@@ -14,7 +14,7 @@ import (
 	"github.com/mudler/xlog"
 )
 
-const maxVoiceProfileJSONBytes = voiceprofile.MaxAudioBytes*4/3 + 2*1024*1024
+const maxVoiceProfileJSONBytes = voiceprofile.MaxAudioBytes*voiceprofile.MaxReferences*4/3 + 2*1024*1024
 
 // VoiceProfileListResponse is returned by the profile library endpoint.
 type VoiceProfileListResponse struct {
@@ -25,12 +25,18 @@ type VoiceProfileListResponse struct {
 // It is primarily used by the LocalAI admin MCP client; the browser sends a
 // multipart audio field to avoid base64 overhead.
 type CreateVoiceProfileRequest struct {
-	Name             string `json:"name"`
-	Description      string `json:"description,omitempty"`
-	Language         string `json:"language,omitempty"`
-	Transcript       string `json:"transcript"`
-	AudioBase64      string `json:"audio_base64"`
-	ConsentConfirmed bool   `json:"consent_confirmed"`
+	Name             string                               `json:"name"`
+	Description      string                               `json:"description,omitempty"`
+	Language         string                               `json:"language,omitempty"`
+	Transcript       string                               `json:"transcript"`
+	AudioBase64      string                               `json:"audio_base64"`
+	ConsentConfirmed bool                                 `json:"consent_confirmed"`
+	References       []CreateVoiceProfileReferenceRequest `json:"references,omitempty"`
+}
+
+type CreateVoiceProfileReferenceRequest struct {
+	Transcript  string `json:"transcript"`
+	AudioBase64 string `json:"audio_base64"`
 }
 
 func voiceProfileError(code int, message string) schema.ErrorResponse {
@@ -118,31 +124,39 @@ func CreateVoiceProfileEndpoint(store *voiceprofile.Store) echo.HandlerFunc {
 
 		contentType := c.Request().Header.Get(echo.HeaderContentType)
 		if strings.HasPrefix(contentType, echo.MIMEMultipartForm) {
-			c.Request().Body = http.MaxBytesReader(c.Response().Writer, c.Request().Body, voiceprofile.MaxAudioBytes+2*1024*1024)
-			fileHeader, err := c.FormFile("audio")
+			c.Request().Body = http.MaxBytesReader(c.Response().Writer, c.Request().Body, voiceprofile.MaxAudioBytes*voiceprofile.MaxReferences+2*1024*1024)
+			form, err := c.MultipartForm()
 			if err != nil {
 				if isRequestBodyTooLarge(err) {
 					return writeVoiceProfileError(c, voiceprofile.ErrAudioTooLarge)
 				}
 				return writeVoiceProfileError(c, fmt.Errorf("%w: audio is required", voiceprofile.ErrInvalidInput))
 			}
-			if fileHeader.Size > voiceprofile.MaxAudioBytes {
-				return writeVoiceProfileError(c, voiceprofile.ErrAudioTooLarge)
+			files := form.File["audio"]
+			transcripts := form.Value["transcript"]
+			if len(files) == 0 || len(files) != len(transcripts) || len(files) > voiceprofile.MaxReferences {
+				return writeVoiceProfileError(c, fmt.Errorf("%w: each audio needs one transcript", voiceprofile.ErrInvalidInput))
 			}
-			audio, err := fileHeader.Open()
-			if err != nil {
-				return writeVoiceProfileError(c, fmt.Errorf("open uploaded audio: %w", err))
+			references := make([]voiceprofile.ReferenceInput, 0, len(files))
+			for index, fileHeader := range files {
+				if fileHeader.Size > voiceprofile.MaxAudioBytes {
+					return writeVoiceProfileError(c, voiceprofile.ErrAudioTooLarge)
+				}
+				audio, err := fileHeader.Open()
+				if err != nil {
+					return writeVoiceProfileError(c, fmt.Errorf("open uploaded audio: %w", err))
+				}
+				defer func() { _ = audio.Close() }()
+				references = append(references, voiceprofile.ReferenceInput{Transcript: transcripts[index], Audio: audio})
 			}
-			defer func() { _ = audio.Close() }()
 
 			consent, _ := strconv.ParseBool(c.FormValue("consent_confirmed"))
-			profile, err := store.Create(c.Request().Context(), voiceprofile.CreateInput{
+			profile, err := store.CreateWithReferences(c.Request().Context(), voiceprofile.CreateInput{
 				Name:             c.FormValue("name"),
 				Description:      c.FormValue("description"),
 				Language:         c.FormValue("language"),
-				Transcript:       c.FormValue("transcript"),
 				ConsentConfirmed: consent,
-			}, audio)
+			}, references)
 			if err != nil {
 				return writeVoiceProfileError(c, err)
 			}
@@ -157,17 +171,26 @@ func CreateVoiceProfileEndpoint(store *voiceprofile.Store) echo.HandlerFunc {
 			}
 			return writeVoiceProfileError(c, fmt.Errorf("%w: invalid JSON body", voiceprofile.ErrInvalidInput))
 		}
-		if base64.StdEncoding.DecodedLen(len(request.AudioBase64)) > int(voiceprofile.MaxAudioBytes) {
-			return writeVoiceProfileError(c, voiceprofile.ErrAudioTooLarge)
+		referenceRequests := request.References
+		if len(referenceRequests) == 0 {
+			referenceRequests = []CreateVoiceProfileReferenceRequest{{Transcript: request.Transcript, AudioBase64: request.AudioBase64}}
+		}
+		if len(referenceRequests) > voiceprofile.MaxReferences {
+			return writeVoiceProfileError(c, voiceprofile.ErrInvalidInput)
+		}
+		references := make([]voiceprofile.ReferenceInput, 0, len(referenceRequests))
+		for _, reference := range referenceRequests {
+			if base64.StdEncoding.DecodedLen(len(reference.AudioBase64)) > int(voiceprofile.MaxAudioBytes) {
+				return writeVoiceProfileError(c, voiceprofile.ErrAudioTooLarge)
+			}
+			references = append(references, voiceprofile.ReferenceInput{Transcript: reference.Transcript, Audio: base64.NewDecoder(base64.StdEncoding, strings.NewReader(reference.AudioBase64))})
 		}
-		audio := base64.NewDecoder(base64.StdEncoding, strings.NewReader(request.AudioBase64))
-		profile, err := store.Create(c.Request().Context(), voiceprofile.CreateInput{
+		profile, err := store.CreateWithReferences(c.Request().Context(), voiceprofile.CreateInput{
 			Name:             request.Name,
 			Description:      request.Description,
 			Language:         request.Language,
-			Transcript:       request.Transcript,
 			ConsentConfirmed: request.ConsentConfirmed,
-		}, audio)
+		}, references)
 		if err != nil {
 			return writeVoiceProfileError(c, err)
 		}
diff --git a/core/http/endpoints/localai/voice_profiles_test.go b/core/http/endpoints/localai/voice_profiles_test.go
index c913f8355d37..e0425cb2141a 100644
--- a/core/http/endpoints/localai/voice_profiles_test.go
+++ b/core/http/endpoints/localai/voice_profiles_test.go
@@ -121,6 +121,26 @@ var _ = Describe("Voice profile endpoints", func() {
 		Expect(recorder.Code).To(Equal(http.StatusCreated), recorder.Body.String())
 	})
 
+	It("creates a profile with ordered JSON references", func() {
+		payload, err := json.Marshal(CreateVoiceProfileRequest{
+			Name: "Personality", ConsentConfirmed: true,
+			References: []CreateVoiceProfileReferenceRequest{
+				{Transcript: "First reference.", AudioBase64: base64.StdEncoding.EncodeToString(voiceProfileWAV(time.Second))},
+				{Transcript: "Second reference.", AudioBase64: base64.StdEncoding.EncodeToString(voiceProfileWAV(2 * time.Second))},
+			},
+		})
+		Expect(err).NotTo(HaveOccurred())
+		request := httptest.NewRequest(http.MethodPost, "/api/voice-profiles", bytes.NewReader(payload))
+		request.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+		recorder := httptest.NewRecorder()
+		e.ServeHTTP(recorder, request)
+		Expect(recorder.Code).To(Equal(http.StatusCreated), recorder.Body.String())
+		var created voiceprofile.Profile
+		Expect(json.Unmarshal(recorder.Body.Bytes(), &created)).To(Succeed())
+		Expect(created.References).To(HaveLen(2))
+		Expect(created.Transcript).To(Equal("First reference."))
+	})
+
 	It("rejects creation without explicit consent", func() {
 		body, contentType := voiceProfileMultipart("false")
 		request := httptest.NewRequest(http.MethodPost, "/api/voice-profiles", body)
diff --git a/core/http/react-ui/e2e/voice-library.spec.js b/core/http/react-ui/e2e/voice-library.spec.js
index 07b82ccb4920..0ef49f9e048d 100644
--- a/core/http/react-ui/e2e/voice-library.spec.js
+++ b/core/http/react-ui/e2e/voice-library.spec.js
@@ -60,7 +60,7 @@ async function mockVoiceAPIs(page) {
   return state
 }
 
-test.describe('Voice Library', () => {
+test.describe('Personality Library', () => {
   let apiState
 
   test.beforeEach(async ({ page }) => {
@@ -69,7 +69,7 @@ test.describe('Voice Library', () => {
 
   test('renders the library-first master/detail view', async ({ page }) => {
     await page.goto('/app/voice-library')
-    await expect(page.getByRole('heading', { name: /Voice Library/i })).toBeVisible()
+    await expect(page.getByRole('heading', { name: /Personality Library/i })).toBeVisible()
     await expect(page.locator('.voice-row', { hasText: 'Documentary narrator' })).toBeVisible()
     await expect(page.locator('.voice-library-detail')).toContainText('The exact words spoken in this reference.')
     await expect(page.locator('.voice-library-detail')).toContainText('Consent confirmed')
diff --git a/core/http/react-ui/public/locales/en/media.json b/core/http/react-ui/public/locales/en/media.json
index 1b392d9d5c7b..af93d06f5b0c 100644
--- a/core/http/react-ui/public/locales/en/media.json
+++ b/core/http/react-ui/public/locales/en/media.json
@@ -172,25 +172,25 @@
     },
     "voiceLibrary": {
       "cloningReady": "Voice cloning",
-      "loading": "Loading saved voices…",
+      "loading": "Loading saved personalities…",
       "modelDefault": "Use model default",
-      "empty": "No saved voices yet.",
+      "empty": "No saved personalities yet.",
       "create": "Create one",
-      "manage": "Manage Voice Library",
+      "manage": "Manage Personality Library",
       "namedVoiceHint": "This model does not accept reference-audio profiles. You can still enter a named speaker supported by its backend."
     }
   },
   "voiceLibrary": {
-    "title": "Voice Library",
-    "subtitle": "Create and manage reusable reference voices for every installed model that supports voice cloning.",
-    "loading": "Loading saved voices…",
-    "listLabel": "Saved voice profiles",
+    "title": "Personality Library",
+    "subtitle": "Create and manage reusable voice personalities with one or more reference recordings.",
+    "loading": "Loading saved personalities…",
+    "listLabel": "Saved voice personalities",
     "status": {
       "ready": "Ready"
     },
     "summary": {
       "label": "Voice library status",
-      "profiles": "saved voices",
+      "profiles": "saved personalities",
       "modelsReady_one": "{{count}} compatible model ready",
       "modelsReady_other": "{{count}} compatible models ready",
       "noModels": "No compatible model installed"
@@ -204,8 +204,8 @@
       "allLanguages": "All languages"
     },
     "empty": {
-      "title": "Your voice library is empty",
-      "body": "Record or upload one consented reference clip, add its exact transcript, and reuse it across compatible TTS models."
+      "title": "Your personality library is empty",
+      "body": "Record or upload consented reference clips, add their exact transcripts, and reuse the personality across compatible TTS models."
     },
     "noResults": {
       "title": "No voices match these filters",
@@ -251,12 +251,12 @@
       "endpointNote": "The same model, input, and voice fields also work with POST /tts."
     },
     "actions": {
-      "create": "Create voice",
-      "createFirst": "Create your first voice",
+      "create": "Create personality",
+      "createFirst": "Create your first personality",
       "retry": "Try again",
       "clearFilters": "Clear filters",
       "useInTTS": "Use in Text to Speech",
-      "delete": "Delete voice",
+      "delete": "Delete personality",
       "installModel": "Install a compatible model",
       "browseModels": "Browse all models"
     },
@@ -274,9 +274,14 @@
     }
   },
   "voiceCreate": {
-    "eyebrow": "Voice Library",
-    "title": "Create a reusable voice",
-    "subtitle": "Add one clean reference clip and its exact transcript. LocalAI handles the backend-specific cloning parameters at generation time.",
+    "eyebrow": "Personality Library",
+    "title": "Create a reusable personality",
+    "subtitle": "Create a reusable personality from one or more clean reference clips and their exact transcripts.",
+    "references": {
+      "add": "Add another reference",
+      "additional": "Reference {{number}}",
+      "remove": "Remove"
+    },
     "sections": {
       "reference": {
         "title": "Reference audio",
diff --git a/core/http/react-ui/src/pages/VoiceProfileCreate.jsx b/core/http/react-ui/src/pages/VoiceProfileCreate.jsx
index 14d1caa02c66..502447ef9b66 100644
--- a/core/http/react-ui/src/pages/VoiceProfileCreate.jsx
+++ b/core/http/react-ui/src/pages/VoiceProfileCreate.jsx
@@ -66,6 +66,7 @@ export default function VoiceProfileCreate() {
   const [description, setDescription] = useState('')
   const [language, setLanguage] = useState('')
   const [transcript, setTranscript] = useState('')
+  const [additionalReferences, setAdditionalReferences] = useState([])
   const [consent, setConsent] = useState(false)
   const [submitting, setSubmitting] = useState(false)
 
@@ -75,7 +76,8 @@ export default function VoiceProfileCreate() {
 
   const durationValid = audio?.duration >= 1 && audio?.duration <= 120
   const durationRecommended = audio?.duration >= 6 && audio?.duration <= 30
-  const formReady = !!audio && durationValid && name.trim() && transcript.trim() && consent && !audioProcessing
+  const additionalReady = additionalReferences.every(reference => reference.audio && reference.transcript.trim())
+  const formReady = !!audio && durationValid && name.trim() && transcript.trim() && additionalReady && consent && !audioProcessing
 
   const readiness = useMemo(() => ({
     audio: !!audio && durationValid,
@@ -108,6 +110,23 @@ export default function VoiceProfileCreate() {
     }
   }
 
+  const handleAdditionalAudio = async (index, sample) => {
+    if (!sample) {
+      setAdditionalReferences(current => current.map((reference, itemIndex) => itemIndex === index ? { ...reference, audio: null } : reference))
+      return
+    }
+    setAudioProcessing(true)
+    try {
+      const normalized = await normalizeAudioSample(sample)
+      if (normalized.duration < 1 || normalized.duration > 120) throw new Error(t('voiceCreate.audio.durationError'))
+      setAdditionalReferences(current => current.map((reference, itemIndex) => itemIndex === index ? { ...reference, audio: normalized } : reference))
+    } catch (err) {
+      addToast(err.message || t('voiceCreate.audio.decodeError'), 'error')
+    } finally {
+      setAudioProcessing(false)
+    }
+  }
+
   const submit = async (event) => {
     event.preventDefault()
     if (!formReady) return
@@ -120,6 +139,10 @@ export default function VoiceProfileCreate() {
       formData.append('transcript', transcript.trim())
       formData.append('consent_confirmed', 'true')
       formData.append('audio', audio.blob, 'reference.wav')
+      additionalReferences.forEach((reference, index) => {
+        formData.append('transcript', reference.transcript.trim())
+        formData.append('audio', reference.audio.blob, `reference-${index + 2}.wav`)
+      })
       const profile = await voiceProfilesApi.create(formData)
       addToast(t('voiceCreate.toasts.created', { name: profile.name }), 'success')
       navigate(`/app/voice-library?selected=${encodeURIComponent(profile.id)}`)
@@ -133,7 +156,7 @@ export default function VoiceProfileCreate() {
   return (
     <main className="voice-create-page">
       <UnsavedChangesGuard
-        when={!submitting && !!(audio || name || description || language || transcript || consent)}
+        when={!submitting && !!(audio || additionalReferences.length || name || description || language || transcript || consent)}
       />
       <PageHeader
         eyebrow={t('voiceCreate.eyebrow')}
@@ -173,6 +196,21 @@ export default function VoiceProfileCreate() {
                 </div>
               </div>
             )}
+            {additionalReferences.map((reference, index) => (
+              <div className="voice-create-preview" key={index}>
+                <div className="voice-create-label-row">
+                  <strong>{t('voiceCreate.references.additional', { number: index + 2 })}</strong>
+                  <button type="button" className="btn btn-secondary btn-sm" onClick={() => {
+                    if (reference.audio?.objectUrl) URL.revokeObjectURL(reference.audio.dataUrl)
+                    setAdditionalReferences(current => current.filter((_, itemIndex) => itemIndex !== index))
+                  }}>{t('voiceCreate.references.remove')}</button>
+                </div>
+                <MediaInput mode="audio" label={t('voiceCreate.audio.label')} value={reference.audio} onChange={(sample) => handleAdditionalAudio(index, sample)} maxBytes={MAX_AUDIO_BYTES} preferBlob idPrefix={`voice-profile-${index + 2}`} />
+                <label className="form-label" htmlFor={`voice-profile-transcript-${index + 2}`}>{t('voiceCreate.fields.transcript')}</label>
+                <textarea id={`voice-profile-transcript-${index + 2}`} className="textarea" rows={3} maxLength={4000} value={reference.transcript} onChange={(event) => setAdditionalReferences(current => current.map((item, itemIndex) => itemIndex === index ? { ...item, transcript: event.target.value } : item))} required />
+              </div>
+            ))}
+            {additionalReferences.length < 9 && <button type="button" className="btn btn-secondary" onClick={() => setAdditionalReferences(current => [...current, { audio: null, transcript: '' }])}><i className="fas fa-plus" aria-hidden="true" /> {t('voiceCreate.references.add')}</button>}
           </section>
 
           <section className="voice-create-section" aria-labelledby="voice-details-heading">
diff --git a/core/services/nodes/file_staging_client.go b/core/services/nodes/file_staging_client.go
index bfc202c8205d..a7a13daf7882 100644
--- a/core/services/nodes/file_staging_client.go
+++ b/core/services/nodes/file_staging_client.go
@@ -2,6 +2,7 @@ package nodes
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -37,6 +38,38 @@ type FileStagingClient struct {
 	remoteModelPath string // set during LoadModel from staged ModelPath
 }
 
+type ttsReference struct {
+	Audio string `json:"audio"`
+	Text  string `json:"text"`
+}
+
+func (f *FileStagingClient) stageTTSReferences(ctx context.Context, reqID string, in *pb.TTSRequest) error {
+	raw := in.Params["multi_reference_cond"]
+	if raw == "" {
+		return nil
+	}
+	var references []ttsReference
+	if err := json.Unmarshal([]byte(raw), &references); err != nil {
+		return fmt.Errorf("decode TTS references: %w", err)
+	}
+	for index := range references {
+		if !isFilePath(references[index].Audio) {
+			continue
+		}
+		backendPath, _, err := f.stageInputFile(ctx, reqID, references[index].Audio, "inputs")
+		if err != nil {
+			return fmt.Errorf("staging TTS reference %d: %w", index+1, err)
+		}
+		references[index].Audio = backendPath
+	}
+	encoded, err := json.Marshal(references)
+	if err != nil {
+		return fmt.Errorf("encode TTS references: %w", err)
+	}
+	in.Params["multi_reference_cond"] = string(encoded)
+	return nil
+}
+
 // NewFileStagingClient creates a new file staging wrapper.
 func NewFileStagingClient(inner grpc.Backend, stager FileStager, nodeID string) *FileStagingClient {
 	return &FileStagingClient{
@@ -263,6 +296,9 @@ func (f *FileStagingClient) TTS(ctx context.Context, in *pb.TTSRequest, opts ...
 		}
 		in.Voice = backendPath
 	}
+	if err := f.stageTTSReferences(ctx, reqID, in); err != nil {
+		return nil, err
+	}
 
 	// Handle output destination
 	frontendDst := in.Dst
@@ -302,6 +338,9 @@ func (f *FileStagingClient) TTSStream(ctx context.Context, in *pb.TTSRequest, fn
 		}
 		in.Voice = backendPath
 	}
+	if err := f.stageTTSReferences(ctx, reqID, in); err != nil {
+		return err
+	}
 
 	return f.Backend.TTSStream(ctx, in, fn, opts...)
 }
diff --git a/core/services/nodes/file_staging_tts_test.go b/core/services/nodes/file_staging_tts_test.go
index a4e4f57f4042..3d6540ea3651 100644
--- a/core/services/nodes/file_staging_tts_test.go
+++ b/core/services/nodes/file_staging_tts_test.go
@@ -2,6 +2,7 @@ package nodes
 
 import (
 	"context"
+	"encoding/json"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -63,4 +64,18 @@ var _ = Describe("FileStagingClient TTS references", func() {
 		Expect(stager.ensureCalls).To(BeEmpty())
 		Expect(backend.ttsRequest.Voice).To(Equal("serena"))
 	})
+
+	It("stages every multi-reference personality clip", func(ctx SpecContext) {
+		backend := &capturingTTSBackend{}
+		stager := &fakeFileStager{}
+		client := NewFileStagingClient(backend, stager, "worker-1")
+		request := &pb.TTSRequest{Params: map[string]string{"multi_reference_cond": `[{"audio":"/data/one.wav","text":"one"},{"audio":"/data/two.wav","text":"two"}]`}}
+		_, err := client.TTS(ctx, request)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(stager.ensureCalls).To(HaveLen(2))
+		var references []map[string]string
+		Expect(json.Unmarshal([]byte(backend.ttsRequest.Params["multi_reference_cond"]), &references)).To(Succeed())
+		Expect(references[0]["audio"]).To(HavePrefix("/remote/ephemeral/"))
+		Expect(references[1]["audio"]).To(HavePrefix("/remote/ephemeral/"))
+	})
 })
diff --git a/core/services/voiceprofile/store.go b/core/services/voiceprofile/store.go
index aff8268fde8e..01cc9f29ae57 100644
--- a/core/services/voiceprofile/store.go
+++ b/core/services/voiceprofile/store.go
@@ -30,6 +30,7 @@ const (
 	// MaxAudioBytes caps a stored reference clip at 50 MiB. The HTTP and MCP
 	// surfaces share this service-level limit so neither can bypass it.
 	MaxAudioBytes int64 = 50 * 1024 * 1024
+	MaxReferences       = 10
 
 	MinAudioDuration = time.Second
 	MaxAudioDuration = 2 * time.Minute
@@ -63,18 +64,25 @@ type AudioMetadata struct {
 	MIMEType             string `json:"mime_type"`
 }
 
+// ReferenceMetadata describes one ordered audio/transcript pair in a profile.
+type ReferenceMetadata struct {
+	Transcript string        `json:"transcript"`
+	Audio      AudioMetadata `json:"audio"`
+}
+
 // Profile is the public, path-free representation of a saved cloned voice.
 type Profile struct {
-	ID                 string        `json:"id"`
-	Name               string        `json:"name"`
-	Description        string        `json:"description,omitempty"`
-	Language           string        `json:"language,omitempty"`
-	Transcript         string        `json:"transcript"`
-	Voice              string        `json:"voice"`
-	ConsentConfirmedAt time.Time     `json:"consent_confirmed_at"`
-	CreatedAt          time.Time     `json:"created_at"`
-	UpdatedAt          time.Time     `json:"updated_at"`
-	Audio              AudioMetadata `json:"audio"`
+	ID                 string              `json:"id"`
+	Name               string              `json:"name"`
+	Description        string              `json:"description,omitempty"`
+	Language           string              `json:"language,omitempty"`
+	Transcript         string              `json:"transcript"`
+	Voice              string              `json:"voice"`
+	ConsentConfirmedAt time.Time           `json:"consent_confirmed_at"`
+	CreatedAt          time.Time           `json:"created_at"`
+	UpdatedAt          time.Time           `json:"updated_at"`
+	Audio              AudioMetadata       `json:"audio"`
+	References         []ReferenceMetadata `json:"references,omitempty"`
 }
 
 // CreateInput contains the administrator-provided profile metadata.
@@ -86,6 +94,12 @@ type CreateInput struct {
 	ConsentConfirmed bool
 }
 
+// ReferenceInput contains one reference clip and its exact transcript.
+type ReferenceInput struct {
+	Transcript string
+	Audio      io.Reader
+}
+
 // Store persists voice profiles below one root-confined directory. A Store is
 // safe for concurrent use.
 type Store struct {
@@ -179,12 +193,31 @@ func (s *Store) openRoot() (*os.Root, error) {
 
 // Create validates and atomically persists a profile and its WAV clip.
 func (s *Store) Create(ctx context.Context, input CreateInput, audio io.Reader) (Profile, error) {
+	return s.CreateWithReferences(ctx, input, []ReferenceInput{{Transcript: input.Transcript, Audio: audio}})
+}
+
+// CreateWithReferences validates and atomically persists an ordered set of
+// reference clips. The first pair also populates the legacy Transcript and
+// Audio fields so existing clients keep working.
+func (s *Store) CreateWithReferences(ctx context.Context, input CreateInput, references []ReferenceInput) (Profile, error) {
 	input = normalizeInput(input)
+	if len(references) == 0 || len(references) > MaxReferences {
+		return Profile{}, fmt.Errorf("%w: between 1 and %d references are required", ErrInvalidInput, MaxReferences)
+	}
+	for index := range references {
+		references[index].Transcript = strings.TrimSpace(references[index].Transcript)
+	}
+	input.Transcript = references[0].Transcript
 	if err := validateInput(input); err != nil {
 		return Profile{}, err
 	}
-	if audio == nil {
-		return Profile{}, fmt.Errorf("%w: audio is required", ErrInvalidInput)
+	for _, reference := range references {
+		if reference.Audio == nil {
+			return Profile{}, fmt.Errorf("%w: audio is required", ErrInvalidInput)
+		}
+		if reference.Transcript == "" || !utf8.ValidString(reference.Transcript) || utf8.RuneCountInString(reference.Transcript) > maxTranscriptRunes {
+			return Profile{}, fmt.Errorf("%w: each transcript must be valid UTF-8, non-empty, and at most %d characters", ErrInvalidInput, maxTranscriptRunes)
+		}
 	}
 
 	s.mu.Lock()
@@ -208,34 +241,36 @@ func (s *Store) Create(ctx context.Context, input CreateInput, audio io.Reader)
 		}
 	}()
 
-	audioPath := filepath.Join(tempDir, audioFileName)
-	dst, err := root.OpenFile(audioPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
-	if err != nil {
-		return Profile{}, fmt.Errorf("voiceprofile: create reference audio: %w", err)
-	}
-
-	written, copyErr := copyWithContext(ctx, dst, io.LimitReader(audio, MaxAudioBytes+1))
-	if syncErr := dst.Sync(); copyErr == nil && syncErr != nil {
-		copyErr = syncErr
-	}
-	if closeErr := dst.Close(); copyErr == nil && closeErr != nil {
-		copyErr = closeErr
-	}
-	if copyErr != nil {
-		return Profile{}, fmt.Errorf("voiceprofile: store reference audio: %w", copyErr)
-	}
-	if written > MaxAudioBytes {
-		return Profile{}, ErrAudioTooLarge
-	}
-
-	storedAudio, err := root.Open(audioPath)
-	if err != nil {
-		return Profile{}, fmt.Errorf("voiceprofile: reopen reference audio: %w", err)
-	}
-	audioMeta, validateErr := validateWAV(storedAudio, written)
-	_ = storedAudio.Close()
-	if validateErr != nil {
-		return Profile{}, validateErr
+	referenceMetadata := make([]ReferenceMetadata, 0, len(references))
+	for index, reference := range references {
+		audioPath := filepath.Join(tempDir, referenceAudioFileName(index))
+		dst, err := root.OpenFile(audioPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
+		if err != nil {
+			return Profile{}, fmt.Errorf("voiceprofile: create reference audio: %w", err)
+		}
+		written, copyErr := copyWithContext(ctx, dst, io.LimitReader(reference.Audio, MaxAudioBytes+1))
+		if syncErr := dst.Sync(); copyErr == nil && syncErr != nil {
+			copyErr = syncErr
+		}
+		if closeErr := dst.Close(); copyErr == nil && closeErr != nil {
+			copyErr = closeErr
+		}
+		if copyErr != nil {
+			return Profile{}, fmt.Errorf("voiceprofile: store reference audio: %w", copyErr)
+		}
+		if written > MaxAudioBytes {
+			return Profile{}, ErrAudioTooLarge
+		}
+		storedAudio, err := root.Open(audioPath)
+		if err != nil {
+			return Profile{}, fmt.Errorf("voiceprofile: reopen reference audio: %w", err)
+		}
+		audioMeta, validateErr := validateWAV(storedAudio, written)
+		_ = storedAudio.Close()
+		if validateErr != nil {
+			return Profile{}, validateErr
+		}
+		referenceMetadata = append(referenceMetadata, ReferenceMetadata{Transcript: reference.Transcript, Audio: audioMeta})
 	}
 
 	now := s.now().UTC()
@@ -249,7 +284,8 @@ func (s *Store) Create(ctx context.Context, input CreateInput, audio io.Reader)
 		ConsentConfirmedAt: now,
 		CreatedAt:          now,
 		UpdatedAt:          now,
-		Audio:              audioMeta,
+		Audio:              referenceMetadata[0].Audio,
+		References:         referenceMetadata,
 	}
 	if err := writeJSON(root, filepath.Join(tempDir, metadataFileName), profile); err != nil {
 		return Profile{}, err
@@ -262,6 +298,13 @@ func (s *Store) Create(ctx context.Context, input CreateInput, audio io.Reader)
 	return profile, nil
 }
 
+func referenceAudioFileName(index int) string {
+	if index == 0 {
+		return audioFileName
+	}
+	return fmt.Sprintf("reference-%d.wav", index+1)
+}
+
 // List returns every readable profile, newest first. One damaged entry is
 // skipped and logged rather than making the entire library unavailable.
 func (s *Store) List(_ context.Context) ([]Profile, error) {
@@ -345,29 +388,47 @@ func (s *Store) OpenAudio(_ context.Context, id string) (*os.File, Profile, erro
 // LeaseAudio creates a request-scoped hard link to the immutable clip. This
 // keeps an in-flight local or remote-worker synthesis safe if an administrator
 // deletes the library entry concurrently. The caller must invoke release.
-func (s *Store) LeaseAudio(_ context.Context, id string) (Profile, string, func(), error) {
-	if err := validateID(id); err != nil {
+func (s *Store) LeaseAudio(ctx context.Context, id string) (Profile, string, func(), error) {
+	profile, paths, release, err := s.LeaseAudios(ctx, id)
+	if err != nil {
 		return Profile{}, "", nil, err
 	}
+	return profile, paths[0], release, nil
+}
+
+// LeaseAudios creates request-scoped links for every ordered profile reference.
+func (s *Store) LeaseAudios(_ context.Context, id string) (Profile, []string, func(), error) {
+	if err := validateID(id); err != nil {
+		return Profile{}, nil, nil, err
+	}
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
 	root, err := s.openRoot()
 	if err != nil {
-		return Profile{}, "", nil, err
+		return Profile{}, nil, nil, err
 	}
 	defer func() { _ = root.Close() }()
 
 	profile, err := readProfile(root, id)
 	if err != nil {
-		return Profile{}, "", nil, err
-	}
-	source := filepath.Join(id, audioFileName)
-	lease := filepath.Join(s.leaseDir, uuid.NewString()+".wav")
-	if err := root.Link(source, lease); err != nil {
-		if err := copyWithinRoot(root, source, lease); err != nil {
-			return Profile{}, "", nil, fmt.Errorf("voiceprofile: lease reference audio: %w", err)
+		return Profile{}, nil, nil, err
+	}
+	leases := make([]string, 0, len(profile.References))
+	paths := make([]string, 0, len(profile.References))
+	for index := range profile.References {
+		source := filepath.Join(id, referenceAudioFileName(index))
+		lease := filepath.Join(s.leaseDir, uuid.NewString()+".wav")
+		if err := root.Link(source, lease); err != nil {
+			if err := copyWithinRoot(root, source, lease); err != nil {
+				for _, created := range leases {
+					_ = root.Remove(created)
+				}
+				return Profile{}, nil, nil, fmt.Errorf("voiceprofile: lease reference audio: %w", err)
+			}
 		}
+		leases = append(leases, lease)
+		paths = append(paths, filepath.Join(s.baseDir, lease))
 	}
 
 	var once sync.Once
@@ -379,12 +440,14 @@ func (s *Store) LeaseAudio(_ context.Context, id string) (Profile, string, func(
 				return
 			}
 			defer func() { _ = leaseRoot.Close() }()
-			if removeErr := leaseRoot.Remove(lease); removeErr != nil && !errors.Is(removeErr, fs.ErrNotExist) {
-				xlog.Warn("Failed to release voice profile audio", "error", removeErr)
+			for _, lease := range leases {
+				if removeErr := leaseRoot.Remove(lease); removeErr != nil && !errors.Is(removeErr, fs.ErrNotExist) {
+					xlog.Warn("Failed to release voice profile audio", "error", removeErr)
+				}
 			}
 		})
 	}
-	return profile, filepath.Join(s.baseDir, lease), release, nil
+	return profile, paths, release, nil
 }
 
 // Delete removes one profile. Existing audio leases remain valid until their
@@ -518,6 +581,9 @@ func readProfile(root *os.Root, id string) (Profile, error) {
 		return Profile{}, errors.New("voiceprofile: metadata id does not match directory")
 	}
 	profile.Voice = Reference(id)
+	if len(profile.References) == 0 {
+		profile.References = []ReferenceMetadata{{Transcript: profile.Transcript, Audio: profile.Audio}}
+	}
 	return profile, nil
 }
 
diff --git a/core/services/voiceprofile/store_test.go b/core/services/voiceprofile/store_test.go
index 11f5607b70b2..6380dd8457a4 100644
--- a/core/services/voiceprofile/store_test.go
+++ b/core/services/voiceprofile/store_test.go
@@ -119,4 +119,27 @@ var _ = Describe("Store", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(audioInfo.Mode().Perm()).To(Equal(os.FileMode(0o600)))
 	})
+
+	It("stores and leases ordered reference pairs", func(ctx SpecContext) {
+		created, err := store.CreateWithReferences(ctx, voiceprofile.CreateInput{
+			Name: "Bilingual narrator", ConsentConfirmed: true,
+		}, []voiceprofile.ReferenceInput{
+			{Transcript: "First reference.", Audio: bytes.NewReader(pcmWAV(time.Second))},
+			{Transcript: "Second reference.", Audio: bytes.NewReader(pcmWAV(2 * time.Second))},
+		})
+		Expect(err).NotTo(HaveOccurred())
+		Expect(created.Transcript).To(Equal("First reference."))
+		Expect(created.References).To(HaveLen(2))
+		Expect(created.References[1].Transcript).To(Equal("Second reference."))
+
+		profile, paths, release, err := store.LeaseAudios(ctx, created.ID)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(profile.References).To(HaveLen(2))
+		Expect(paths).To(HaveLen(2))
+		Expect(paths[0]).To(BeAnExistingFile())
+		Expect(paths[1]).To(BeAnExistingFile())
+		release()
+		Expect(paths[0]).NotTo(BeAnExistingFile())
+		Expect(paths[1]).NotTo(BeAnExistingFile())
+	})
 })
diff --git a/docs/content/features/text-to-audio.md b/docs/content/features/text-to-audio.md
index 8ff355a73f1f..787594cd39a6 100644
--- a/docs/content/features/text-to-audio.md
+++ b/docs/content/features/text-to-audio.md
@@ -35,11 +35,11 @@ Returns an `audio/wav` file.
 Administrators can manage reusable voice-cloning references from **Operate → Voice Library** in the LocalAI WebUI. The library replaces per-model filesystem and YAML setup for supported cloning backends:
 
 1. Select **Create voice** and upload or record a clear reference clip.
-2. Enter the exact words spoken in the clip. The transcript is sent to backends that require reference text.
+2. Enter the exact words spoken in the clip. Add more audio/transcript pairs when the personality needs more examples.
 3. Confirm that you have permission to clone the voice, then save the profile.
 4. Open **Text to Speech**, choose a model marked **Cloning ready**, and select the saved voice.
 
-The browser converts uploads and recordings to mono, 24 kHz, 16-bit PCM WAV so the same profile works across compatible backends. Clips must be between 1 and 120 seconds and no larger than 50 MiB; 6-30 seconds of clean, single-speaker audio is recommended. Profile audio is private biometric source material: LocalAI stores it below its configured data path, serves previews only to authenticated TTS users, and never returns its filesystem path.
+The browser converts uploads and recordings to mono, 24 kHz, 16-bit PCM WAV so the same profile works across compatible backends. A profile can contain up to ten ordered references. Each clip must be between 1 and 120 seconds and no larger than 50 MiB; 6-30 seconds of clean audio is recommended. Profile audio is private biometric source material: LocalAI stores it below its configured data path, serves previews only to authenticated TTS users, and never returns its filesystem path.
 
 ### Voice profile API
 
@@ -63,6 +63,18 @@ curl http://localhost:8080/api/voice-profiles \
   -F 'audio=@reference.wav;type=audio/wav'
 ```
 
+Repeat `transcript` and `audio` in matching order to create a multi-reference personality:
+
+```bash
+curl http://localhost:8080/api/voice-profiles \
+  -F 'name=Documentary personality' \
+  -F 'transcript=The first exact transcript.' \
+  -F 'audio=@reference-1.wav;type=audio/wav' \
+  -F 'transcript=The second exact transcript.' \
+  -F 'audio=@reference-2.wav;type=audio/wav' \
+  -F 'consent_confirmed=true'
+```
+
 The response includes an opaque voice reference such as `localai://voice-profiles/550e8400-e29b-41d4-a716-446655440000`. Pass that value as `voice` to either TTS-compatible endpoint:
 
 ```bash
@@ -122,7 +134,7 @@ Reference selection follows this order:
 3. The model's `tts.audio_path` reference-audio fallback.
 4. A backend-specific default voice or option.
 
-When a saved profile is selected, LocalAI supplies both its private WAV and exact transcript for that request. It does not rewrite the model YAML or copy the recording into the model directory.
+When a saved profile is selected, LocalAI supplies its ordered private WAV and transcript pairs to Fish Speech and audio.cpp. Other cloning backends receive the first pair, which preserves their existing single-reference behavior. LocalAI does not rewrite the model YAML or copy recordings into the model directory.
 
 #### Supported backend and model variants
 
diff --git a/pkg/mcp/localaitools/dto.go b/pkg/mcp/localaitools/dto.go
index a8e734c847ce..684b1d575425 100644
--- a/pkg/mcp/localaitools/dto.go
+++ b/pkg/mcp/localaitools/dto.go
@@ -201,12 +201,18 @@ type VoiceProfile = voiceprofile.Profile
 // portability); the service enforces the same 50 MiB and duration limits as
 // the browser upload route.
 type CreateVoiceProfileRequest struct {
-	Name             string `json:"name"              jsonschema:"Display name for the reusable voice profile."`
-	Description      string `json:"description,omitempty" jsonschema:"Optional note describing tone, source, or intended use."`
-	Language         string `json:"language,omitempty" jsonschema:"Optional BCP-47-style language tag such as en-US."`
-	Transcript       string `json:"transcript"        jsonschema:"Exact transcript of the words spoken in the reference clip."`
-	AudioBase64      string `json:"audio_base64"      jsonschema:"Base64-encoded 16-bit PCM WAV reference, preferably mono 24 kHz, 1-120 seconds and at most 50 MiB decoded."`
-	ConsentConfirmed bool   `json:"consent_confirmed" jsonschema:"Must be true to confirm authorization to clone this voice."`
+	Name             string                               `json:"name"              jsonschema:"Display name for the reusable voice profile."`
+	Description      string                               `json:"description,omitempty" jsonschema:"Optional note describing tone, source, or intended use."`
+	Language         string                               `json:"language,omitempty" jsonschema:"Optional BCP-47-style language tag such as en-US."`
+	Transcript       string                               `json:"transcript"        jsonschema:"Exact transcript of the words spoken in the reference clip."`
+	AudioBase64      string                               `json:"audio_base64"      jsonschema:"Base64-encoded 16-bit PCM WAV reference, preferably mono 24 kHz, 1-120 seconds and at most 50 MiB decoded."`
+	ConsentConfirmed bool                                 `json:"consent_confirmed" jsonschema:"Must be true to confirm authorization to clone this voice."`
+	References       []CreateVoiceProfileReferenceRequest `json:"references,omitempty" jsonschema:"Optional ordered audio/transcript pairs. When set, these replace the legacy audio_base64 and transcript fields."`
+}
+
+type CreateVoiceProfileReferenceRequest struct {
+	Transcript  string `json:"transcript" jsonschema:"Exact transcript of this reference clip."`
+	AudioBase64 string `json:"audio_base64" jsonschema:"Base64-encoded 16-bit PCM WAV reference."`
 }
 
 // DeleteVoiceProfileRequest identifies the profile to remove.
diff --git a/pkg/mcp/localaitools/inproc/client.go b/pkg/mcp/localaitools/inproc/client.go
index 1d80c30dffc2..ee8859ceba0c 100644
--- a/pkg/mcp/localaitools/inproc/client.go
+++ b/pkg/mcp/localaitools/inproc/client.go
@@ -742,23 +742,30 @@ func (c *Client) ListVoiceProfiles(ctx context.Context) ([]localaitools.VoicePro
 }
 
 func (c *Client) CreateVoiceProfile(ctx context.Context, req localaitools.CreateVoiceProfileRequest) (*localaitools.VoiceProfile, error) {
-	if req.AudioBase64 == "" {
-		return nil, errors.New("audio_base64 is required")
-	}
-	if base64.StdEncoding.DecodedLen(len(req.AudioBase64)) > int(voiceprofile.MaxAudioBytes) {
-		return nil, voiceprofile.ErrAudioTooLarge
+	referenceRequests := req.References
+	if len(referenceRequests) == 0 {
+		referenceRequests = []localaitools.CreateVoiceProfileReferenceRequest{{Transcript: req.Transcript, AudioBase64: req.AudioBase64}}
+	}
+	references := make([]voiceprofile.ReferenceInput, 0, len(referenceRequests))
+	for _, reference := range referenceRequests {
+		if reference.AudioBase64 == "" {
+			return nil, errors.New("audio_base64 is required")
+		}
+		if base64.StdEncoding.DecodedLen(len(reference.AudioBase64)) > int(voiceprofile.MaxAudioBytes) {
+			return nil, voiceprofile.ErrAudioTooLarge
+		}
+		references = append(references, voiceprofile.ReferenceInput{Transcript: reference.Transcript, Audio: base64.NewDecoder(base64.StdEncoding, strings.NewReader(reference.AudioBase64))})
 	}
 	store, err := c.voiceProfileStore()
 	if err != nil {
 		return nil, err
 	}
-	profile, err := store.Create(ctx, voiceprofile.CreateInput{
+	profile, err := store.CreateWithReferences(ctx, voiceprofile.CreateInput{
 		Name:             req.Name,
 		Description:      req.Description,
 		Language:         req.Language,
-		Transcript:       req.Transcript,
 		ConsentConfirmed: req.ConsentConfirmed,
-	}, base64.NewDecoder(base64.StdEncoding, strings.NewReader(req.AudioBase64)))
+	}, references)
 	if err != nil {
 		return nil, err
 	}
diff --git a/swagger/docs.go b/swagger/docs.go
index b399f73e8ac3..f992c0914edc 100644
--- a/swagger/docs.go
+++ b/swagger/docs.go
@@ -8215,6 +8215,12 @@ const docTemplate = `{
                 "name": {
                     "type": "string"
                 },
+                "references": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/voiceprofile.ReferenceMetadata"
+                    }
+                },
                 "transcript": {
                     "type": "string"
                 },
@@ -8225,6 +8231,17 @@ const docTemplate = `{
                     "type": "string"
                 }
             }
+        },
+        "voiceprofile.ReferenceMetadata": {
+            "type": "object",
+            "properties": {
+                "audio": {
+                    "$ref": "#/definitions/voiceprofile.AudioMetadata"
+                },
+                "transcript": {
+                    "type": "string"
+                }
+            }
         }
     },
     "securityDefinitions": {
diff --git a/swagger/swagger.json b/swagger/swagger.json
index b04ebca6d597..1f7409150c11 100644
--- a/swagger/swagger.json
+++ b/swagger/swagger.json
@@ -8212,6 +8212,12 @@
                 "name": {
                     "type": "string"
                 },
+                "references": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/voiceprofile.ReferenceMetadata"
+                    }
+                },
                 "transcript": {
                     "type": "string"
                 },
@@ -8222,6 +8228,17 @@
                     "type": "string"
                 }
             }
+        },
+        "voiceprofile.ReferenceMetadata": {
+            "type": "object",
+            "properties": {
+                "audio": {
+                    "$ref": "#/definitions/voiceprofile.AudioMetadata"
+                },
+                "transcript": {
+                    "type": "string"
+                }
+            }
         }
     },
     "securityDefinitions": {
diff --git a/swagger/swagger.yaml b/swagger/swagger.yaml
index f0e40bbe050f..8bacf82ec6b6 100644
--- a/swagger/swagger.yaml
+++ b/swagger/swagger.yaml
@@ -2986,6 +2986,10 @@ definitions:
         type: string
       name:
         type: string
+      references:
+        items:
+          $ref: '#/definitions/voiceprofile.ReferenceMetadata'
+        type: array
       transcript:
         type: string
       updated_at:
@@ -2993,6 +2997,13 @@ definitions:
       voice:
         type: string
     type: object
+  voiceprofile.ReferenceMetadata:
+    properties:
+      audio:
+        $ref: '#/definitions/voiceprofile.AudioMetadata'
+      transcript:
+        type: string
+    type: object
 info:
   contact:
     name: LocalAI