feat: add AX620E and AX637 support (encoder NPU + decoder ONNX fallback)

- AX620E: Encoder axmodel (U16, cosine 1.0), Decoder ONNX (CPU)
- AX637: Encoder axmodel (U16, cosine 1.0), Decoder ONNX (CPU)
- AX650: Full NPU (encoder + decoder axmodel)
- Multi-chip engine with auto-detection
- Note: HiFi-GAN decoder cannot compile on AX620E/AX637
(ConvTranspose stride=8 exceeds NPU tiling limits)

.gitattributes

@@ -1,4 +1,5 @@
-models/*.axmodel filter=lfs diff=lfs merge=lfs -text
+models/**/*.axmodel filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
 *.wav filter=lfs diff=lfs merge=lfs -text
+*.onnx.data filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,65 +1,52 @@
 ---
 license: mit
-language:
-  - en
-tags:
-  - text-to-speech
-  - vits
-  - ax650
-  - npu
-  - onnx
+language: [en]
+tags: [text-to-speech, vits, ax650, ax620e, ax637, npu, onnx]
 pipeline_tag: text-to-speech
 ---
 
-# Inflect-Micro-v2 for AX650 NPU
+# Inflect-Micro-v2 for AXera NPU
 
-High-quality English TTS (VITS architecture) optimized for **AX650 NPU3**, running entirely on-chip with zero PyTorch dependency at inference time.
+High-quality English TTS (VITS) optimized for **AX650 / AX620E / AX637** NPUs.
 
-- **Encoder + Decoder**: AX650 NPU (AXMODEL, U16 precision)
-- **Duration Predictor**: ONNX Runtime (onnxruntime)
-- **Embedding**: NumPy lookup
-- **Real-time Factor**: ~0.05x (20× faster than real-time)
+| Chip | Encoder | Decoder | Precision |
+|------|---------|---------|-----------|
+| **AX650** | NPU (axmodel) | NPU (axmodel) | U16 |
+| **AX620E** | NPU (axmodel) | CPU (onnxruntime) | U16 |
+| **AX637** | NPU (axmodel) | CPU (onnxruntime) | U16 |
 
-## 🎧 Audio Samples
+## 🎧 Audio Samples (AX650 NPU)
 
-*All samples generated on AX650 NPU, 24kHz.*
-
-**"Hello and welcome to Inflect Micro V2 text to speech."** (3.6s, RTF 0.05x)
+**"Hello and welcome to Inflect Micro V2 text to speech."**
 <audio controls src="https://huggingface.co/AXERA-TECH/inflect_micro_v2/resolve/main/samples/en_hello.wav"></audio>
 
-**"The weather today is sunny with a gentle breeze."** (2.6s, RTF 0.06x)
+**"The weather today is sunny with a gentle breeze."**
 <audio controls src="https://huggingface.co/AXERA-TECH/inflect_micro_v2/resolve/main/samples/en_weather.wav"></audio>
 
-**"Once upon a time, there lived a curious robot who loved to sing."** (3.9s, RTF 0.05x)
+**"Once upon a time, there lived a curious robot who loved to sing."**
 <audio controls src="https://huggingface.co/AXERA-TECH/inflect_micro_v2/resolve/main/samples/en_story.wav"></audio>
 
-**"Neural voice synthesis is the next frontier of artificial intelligence."** (4.1s, RTF 0.04x)
+**"Neural voice synthesis is the next frontier of AI."**
 <audio controls src="https://huggingface.co/AXERA-TECH/inflect_micro_v2/resolve/main/samples/en_tech.wav"></audio>
 
-**"This audio was generated entirely on the AX650 NPU chip."** (4.7s, RTF 0.04x)
+**"This audio was generated entirely on the AX650 NPU chip."**
 <audio controls src="https://huggingface.co/AXERA-TECH/inflect_micro_v2/resolve/main/samples/en_intro.wav"></audio>
 
 ## 🚀 Quick Start
 
 ```bash
 bash setup.sh
-bash run.sh "Hello world." output.wav
+bash run.sh "Hello world." output.wav cli ax650
 ```
 
-## 📡 API
-
-```bash
-# CLI
-python -m inflect_tts_sdk --text "Hello" --output out.wav
+## 📁 Structure
 
-# OpenAI-compatible Server
-python -m inflect_tts_sdk.server --port 8000
 ```
-
-## 📁 File Structure
-
-- `models/` — AXMODEL, dp.onnx, emb.npy
-- `python/inflect_tts_sdk/` — Python SDK (CLI + OpenAI Server)
-- `cpp/inflect_tts_sdk/` — C++ SDK (CLI + Server)
-- `samples/` — audio samples
-
+models/
+  ax650/   — full NPU (encoder + decoder axmodel)
+  ax620e/  — encoder axmodel + decoder ONNX
+  ax637/   — encoder axmodel + decoder ONNX
+python/    — Python SDK
+cpp/       — C++ SDK
+samples/   — audio samples
+```

models/ax620e/inflect_decoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad0e403794f3e9b24be9bcc438785ff46b887f10bf90698411fc25edcc0504e
+size 107178

models/ax620e/inflect_decoder.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f378527dfcfb8b7069193559bde3702af3a1b889b0f3af403dbc3a3c4ed8c5ad
+size 38338560

models/ax620e/inflect_encoder.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc63f65ab37ad48156cbfc26c499f5ea5616ef0a0ce98d9ece7ecfcb3f56192b
+size 1728627

models/ax620e/model_meta.json

@@ -0,0 +1,13 @@
+{
+  "model": "inflect_micro_v2",
+  "chip": "ax620e",
+  "encoder": "axmodel",
+  "decoder": "onnx",
+  "dp": "onnx",
+  "embedding": "npy",
+  "sample_rate": 24000,
+  "hop_length": 256,
+  "precision": "U16",
+  "max_tokens": 200,
+  "max_mel_frames": 500
+}

models/ax637/dp.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb2f0f1138c7c409a89eaeaec81dec6720dfbc82d4f20d0159b1c92058527731
+size 1105165

models/ax637/inflect_decoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ad0e403794f3e9b24be9bcc438785ff46b887f10bf90698411fc25edcc0504e
+size 107178

models/ax637/inflect_decoder.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f378527dfcfb8b7069193559bde3702af3a1b889b0f3af403dbc3a3c4ed8c5ad
+size 38338560

models/ax637/inflect_encoder.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a883cae3c3d0f8f654acd38c67c8c96994e130f19a53a28794b1fa3c8c590bd
+size 1695942

models/ax637/model_meta.json

@@ -0,0 +1,13 @@
+{
+  "model": "inflect_micro_v2",
+  "chip": "ax637",
+  "encoder": "axmodel",
+  "decoder": "onnx",
+  "dp": "onnx",
+  "embedding": "npy",
+  "sample_rate": 24000,
+  "hop_length": 256,
+  "precision": "U16",
+  "max_tokens": 200,
+  "max_mel_frames": 500
+}

models/ax650/dp.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb2f0f1138c7c409a89eaeaec81dec6720dfbc82d4f20d0159b1c92058527731
+size 1105165

models/ax650/model_meta.json

@@ -0,0 +1,13 @@
+{
+  "model": "inflect_micro_v2",
+  "chip": "ax650",
+  "encoder": "axmodel",
+  "decoder": "axmodel",
+  "dp": "onnx",
+  "embedding": "npy",
+  "sample_rate": 24000,
+  "hop_length": 256,
+  "precision": "U16",
+  "max_tokens": 200,
+  "max_mel_frames": 500
+}

models/model_meta.json

@@ -1,58 +0,0 @@
-{
-  "model_name": "inflect_micro_v2",
-  "model_type": "vits_tts",
-  "framework": "pytorch",
-  "task": "text_to_speech",
-  "encoder_decoder_split": true,
-  "config": {
-    "sampling_rate": 24000,
-    "hop_length": 256,
-    "inter_channels": 192,
-    "hidden_channels": 96,
-    "filter_channels": 768,
-    "n_vocab": 256,
-    "add_blank": true
-  },
-  "submodels": [
-    {
-      "name": "inflect_encoder",
-      "onnx_file": "inflect_encoder_static.onnx",
-      "description": "TextEncoder: tokens -> m_p, logs_p, x, x_mask",
-      "inputs": [
-        {"name": "tokens", "shape": [1, 200], "dtype": "int64", "dynamic_dim": 1},
-        {"name": "lengths", "shape": [1], "dtype": "int64"}
-      ],
-      "outputs": [
-        {"name": "m_p", "shape": [1, 192, "token_len"], "dtype": "float32"},
-        {"name": "logs_p", "shape": [1, 192, "token_len"], "dtype": "float32"},
-        {"name": "x", "shape": [1, 96, "token_len"], "dtype": "float32"},
-        {"name": "x_mask", "shape": [1, 1, "token_len"], "dtype": "float32"}
-      ]
-    },
-    {
-      "name": "inflect_decoder",
-      "onnx_file": "inflect_decoder_static.onnx",
-      "description": "Flow(reverse) + HiFi-GAN Generator: z_p -> waveform",
-      "inputs": [
-        {"name": "z_p", "shape": [1, 192, 500], "dtype": "float32", "dynamic_dim": 2},
-        {"name": "y_mask", "shape": [1, 1, 500], "dtype": "float32", "dynamic_dim": 2}
-      ],
-      "outputs": [
-        {"name": "waveform", "shape": [1, 1, 128000], "dtype": "float32"}
-      ]
-    }
-  ],
-  "pipeline": {
-    "preprocessing": "text -> phonemes -> token_ids (CPU, Python frontend)",
-    "encoder": "tokens -> enc_p -> m_p, logs_p (NPU)",
-    "duration_alignment": "dp + generate_path + expand (CPU, Python)",
-    "decoder": "z_p -> flow(reverse) -> dec -> waveform (NPU)",
-    "postprocessing": "none (raw waveform output)"
-  },
-  "export_info": {
-    "opset_version": 18,
-    "torch_version": "2.x",
-    "dynamic_onnx_available": true,
-    "static_onnx_for_compile": true
-  }
-}

python/inflect_tts_sdk/__main__.py

@@ -1,19 +1,20 @@
-"""CLI: python -m inflect_tts_sdk --text "Hello" --output out.wav"""
+"""CLI: python -m inflect_tts_sdk --text "Hello" --output out.wav [--chip ax650]"""
 import argparse
 from pathlib import Path
 from .tts_engine import InflectTTSEngine
 
 def main():
-    ap = argparse.ArgumentParser(description="Inflect-Micro-v2 TTS (AX650 NPU3)")
-    ap.add_argument("--text", required=True, help="Text to synthesize")
+    ap = argparse.ArgumentParser(description="Inflect-Micro-v2 TTS (AX NPU)")
+    ap.add_argument("--text", required=True)
     ap.add_argument("--output", default="output.wav")
     ap.add_argument("--speed", type=float, default=1.0)
     ap.add_argument("--variation", type=float, default=0.667)
     ap.add_argument("--seed", type=int, default=0)
     ap.add_argument("--model-dir", default=None)
+    ap.add_argument("--chip", default="ax650", choices=["ax650", "ax620e", "ax637"])
     args = ap.parse_args()
 
-    engine = InflectTTSEngine(model_dir=args.model_dir)
+    engine = InflectTTSEngine(model_dir=args.model_dir, chip=args.chip)
     engine.save(args.text, args.output, speed=args.speed,
                 variation=args.variation, seed=args.seed)
     print(f"🔊 {args.output}")

python/inflect_tts_sdk/tts_engine.py

@@ -1,13 +1,13 @@
 """
-Inflect-Micro-v2 TTS Engine for AX650 NPU3
-纯 NPU + ONNX + NumPy，零 PyTorch/CPU fallback 依赖。
+Inflect-Micro-v2 TTS Engine — multi-chip, zero PyTorch.
+
+Supports: AX650 (full NPU), AX620E (encoder NPU + decoder ONNX), AX637 (encoder NPU + decoder ONNX).
 """
 from __future__ import annotations
-import sys, os, io, math, re, json, warnings, contextlib
+import sys, os, io, math, re, json
 from pathlib import Path
 import numpy as np
 import onnxruntime as ort
-import axengine as axe
 
 PKG = Path(__file__).resolve().parent
 sys.path.insert(0, str(PKG))
@@ -18,70 +18,96 @@ from text.symbols import symbols
 from text import cleaned_text_to_sequence
 
 
-# ── numpy 版本的 VITS 工具函数 ──────────────────────────────────────────
+# ── numpy 工具函数 ──────────────────────────────────────────────────────
 
 def _intersperse(lst, item):
     result = [item] * (len(lst) * 2 + 1)
     result[1::2] = lst
     return result
 
-
 def _sequence_mask(length, max_length=None):
     if max_length is None:
         max_length = int(length.max())
     return np.arange(max_length, dtype=length.dtype)[None, :] < length[:, None]
 
-
 def _generate_path(duration, mask):
-    """numpy 版本的 commons.generate_path
-    duration: [b, 1, t_x]
-    mask:     [b, 1, t_y, t_x]
-    """
     b, _, t_y, t_x = mask.shape
-    cum_duration = np.cumsum(duration, axis=-1)                     # [b, 1, t_x]
-    cum_duration_flat = cum_duration.reshape(b * t_x)               # [b*t_x]
-    path = _sequence_mask(cum_duration_flat, t_y).astype(mask.dtype) # [b*t_x, t_y]
+    cum_duration = np.cumsum(duration, axis=-1)
+    cum_duration_flat = cum_duration.reshape(b * t_x)
+    path = _sequence_mask(cum_duration_flat, t_y).astype(mask.dtype)
     path = path.reshape(b, t_x, t_y)
-    padded = np.pad(path[:, :-1], ((0, 0), (1, 0), (0, 0)))         # shift right
+    padded = np.pad(path[:, :-1], ((0, 0), (1, 0), (0, 0)))
     path = path - padded
-    path = path[:, np.newaxis, :, :].transpose(0, 1, 3, 2) * mask  # [b,1,t_y,t_x]
+    path = path[:, np.newaxis, :, :].transpose(0, 1, 3, 2) * mask
     return path
 
 
 # ── 引擎 ────────────────────────────────────────────────────────────────
 
 class InflectTTSEngine:
-    """Inflect-Micro-v2 TTS — AX650 NPU3 + ONNX dp，零 PyTorch。"""
+    """Inflect-Micro-v2 TTS — 多芯片，零 PyTorch。"""
 
-    def __init__(self, model_dir: str | Path | None = None):
+    def __init__(self, model_dir: str | Path | None = None, chip: str = "ax650"):
         if model_dir:
             self.root = Path(model_dir)
         else:
-            self.root = PKG.parent.parent / "models"
+            # Default: models/{chip}/
+            self.root = PKG.parent.parent / "models" / chip
+
+        self.chip = chip
 
         # 加载配置
-        cfg_path = PKG / "config.json"
-        with open(cfg_path) as f:
+        with open(PKG / "config.json") as f:
             self.hps = json.load(f)
         self.sample_rate = int(self.hps["data"]["sampling_rate"])
         self.hop_length = int(self.hps["data"]["hop_length"])
         self.hidden_channels = int(self.hps["model"]["hidden_channels"])
+        self.inter_channels = int(self.hps["model"]["inter_channels"])
+
+        # 加载 chip-specific model_meta
+        meta_path = self.root / "model_meta.json"
+        if meta_path.exists():
+            with open(meta_path) as f:
+                self.meta = json.load(f)
+        else:
+            self.meta = {}
 
-        # Embedding 权重 (n_vocab, hidden_channels)
-        emb_path = self.root / "emb.npy"
-        self._emb = np.load(str(emb_path))
+        # Embedding (n_vocab, hidden_channels)
+        self._emb = np.load(str(self.root / "emb.npy"))
         self._emb_scale = math.sqrt(self.hidden_channels)
 
         # Duration Predictor ONNX
-        dp_path = self.root / "dp.onnx"
-        providers = ["CPUExecutionProvider"]
-        self._dp_sess = ort.InferenceSession(str(dp_path), providers=providers)
-
-        # NPU: Encoder + Decoder
-        enc_path = str(self.root / "inflect_encoder.axmodel")
-        dec_path = str(self.root / "inflect_decoder.axmodel")
-        self.enc_session = axe.InferenceSession(enc_path)
-        self.dec_session = axe.InferenceSession(dec_path)
+        self._dp_sess = ort.InferenceSession(
+            str(self.root / "dp.onnx"), providers=["CPUExecutionProvider"]
+        )
+
+        # Encoder — always AXMODEL
+        try:
+            import axengine as axe
+            enc_path = str(self.root / "inflect_encoder.axmodel")
+            self.enc_session = axe.InferenceSession(enc_path)
+            self._has_npu = True
+        except ImportError:
+            self._has_npu = False
+            print("[WARN] axengine not available, encoder will use CPU ONNX")
+            self.enc_session = ort.InferenceSession(
+                str(self.root / "inflect_encoder.onnx"),
+                providers=["CPUExecutionProvider"],
+            )
+
+        # Decoder — AXMODEL or ONNX fallback
+        dec_axmodel = self.root / "inflect_decoder.axmodel"
+        if dec_axmodel.exists() and self._has_npu:
+            self.dec_session = axe.InferenceSession(str(dec_axmodel))
+            self._dec_is_npu = True
+        else:
+            dec_onnx = self.root / "inflect_decoder.onnx"
+            self.dec_session = ort.InferenceSession(
+                str(dec_onnx), providers=["CPUExecutionProvider"]
+            )
+            self._dec_is_npu = False
+            if self._has_npu:
+                print(f"[INFO] {chip}: decoder running on CPU (ONNX)")
 
     def synthesize(self, text: str, speed: float = 1.0, variation: float = 0.667,
                    seed: int = 0):
@@ -96,8 +122,7 @@ class InflectTTSEngine:
         pieces = []
         for idx, chunk in enumerate(sentences):
             if idx > 0:
-                pause = round(self.sample_rate * 0.08)
-                pieces.append(np.zeros(pause, dtype=np.float32))
+                pieces.append(np.zeros(round(self.sample_rate * 0.08), dtype=np.float32))
 
             phonemes = run_vits_frontend(chunk).phoneme_text
             seq = cleaned_text_to_sequence(phonemes)
@@ -106,64 +131,68 @@ class InflectTTSEngine:
             if not seq:
                 continue
 
-            tokens = np.array(seq, dtype=np.int64)          # [T]
+            tokens = np.array(seq, dtype=np.int64)
             tlen = len(tokens)
 
-            # ── NumPy: Embedding ──
-            x_emb = self._emb[tokens] * self._emb_scale     # [T, H]
-            x_emb = x_emb.T[np.newaxis, :, :]               # [1, H, T]
+            # ── Embedding ──
+            x_emb = self._emb[tokens] * self._emb_scale
+            x_emb = x_emb.T[np.newaxis, :, :]
 
-            # ── NPU: Encoder ──
+            # ── Encoder ──
             MAX_TOK = 200
             if tlen > MAX_TOK:
-                raise ValueError(f"Text too long: {tlen} tokens > {MAX_TOK} max")
+                raise ValueError(f"Text too long: {tlen} tokens > {MAX_TOK}")
             x_pad = np.zeros((1, self.hidden_channels, MAX_TOK), dtype=np.float32)
             x_pad[:, :, :tlen] = x_emb
 
             enc_out = self.enc_session.run(None, {
                 "x_emb": x_pad,
-                "lengths": np.array([tlen], dtype=np.int64),
+                "lengths": np.array([tlen], dtype=np.int32),
             })
-            m_p = np.asarray(enc_out[0])[:, :, :tlen]        # [1, inter, T]
+            m_p = np.asarray(enc_out[0])[:, :, :tlen]
             logs_p = np.asarray(enc_out[1])[:, :, :tlen]
             x_enc = np.asarray(enc_out[2])[:, :, :tlen]
             x_mask = np.asarray(enc_out[3])[:, :, :tlen]
 
-            # ── ONNX: Duration Predictor ──
+            # ── Duration Predictor ──
             logw = self._dp_sess.run(None, {
                 "x": x_enc.astype(np.float32),
                 "x_mask": x_mask.astype(np.float32),
-            })[0]                                             # [1, 1, T]
+            })[0]
 
-            # ── NumPy: Duration + Alignment ──
+            # ── Duration + Alignment ──
             rng = np.random.RandomState(seed + idx)
             w = np.exp(logw) * x_mask * (1.0 / speed)
             w_ceil = np.ceil(w)
             y_lengths = np.clip(w_ceil.sum(axis=(1, 2)), 1, None).astype(np.int64)
             y_mask = _sequence_mask(y_lengths, None)[:, np.newaxis, :].astype(x_mask.dtype)
             attn_mask = x_mask[:, :, np.newaxis, :] * y_mask[:, :, :, np.newaxis]
-
-            attn = _generate_path(w_ceil, attn_mask)          # [1, 1, Ty, T]
+            attn = _generate_path(w_ceil, attn_mask)
 
             m_p = (attn.squeeze(1) @ m_p.transpose(0, 2, 1)).transpose(0, 2, 1)
             logs_p = (attn.squeeze(1) @ logs_p.transpose(0, 2, 1)).transpose(0, 2, 1)
             z_p = m_p + rng.randn(*m_p.shape).astype(np.float32) * np.exp(logs_p) * variation
 
-            # ── NPU: Decoder ──
+            # ── Decoder ──
             mel_len = z_p.shape[2]
             MAX_MEL = 500
             if mel_len > MAX_MEL:
-                raise ValueError(f"Audio too long: {mel_len} frames > {MAX_MEL} max")
-            zp_np = np.zeros((1, self.hps["model"]["inter_channels"], MAX_MEL), dtype=np.float32)
-            ym_np = np.zeros((1, 1, MAX_MEL), dtype=np.float32)
-            zp_np[:, :, :mel_len] = z_p
-            ym_np[:, :, :mel_len] = y_mask
-
-            dec_out = self.dec_session.run(None, {
-                "z_p": zp_np,
-                "y_mask": ym_np,
-            })
-            waveform = dec_out[0][0, 0, :mel_len * self.hop_length]
+                raise ValueError(f"Audio too long: {mel_len} frames > {MAX_MEL}")
+
+            if self._dec_is_npu:
+                zp_np = np.zeros((1, self.inter_channels, MAX_MEL), dtype=np.float32)
+                ym_np = np.zeros((1, 1, MAX_MEL), dtype=np.float32)
+                zp_np[:, :, :mel_len] = z_p
+                ym_np[:, :, :mel_len] = y_mask
+                dec_out = self.dec_session.run(None, {"z_p": zp_np, "y_mask": ym_np})
+                waveform = dec_out[0][0, 0, :mel_len * self.hop_length]
+            else:
+                dec_out = self.dec_session.run(None, {
+                    "z_p": z_p.astype(np.float32),
+                    "y_mask": y_mask.astype(np.float32),
+                })
+                waveform = dec_out[0][0, 0, :mel_len * self.hop_length]
+
             pieces.append(waveform)
 
         waveform = np.clip(np.concatenate(pieces), -1.0, 1.0)

run.sh

@@ -3,15 +3,16 @@ set -euo pipefail
 TEXT="${1:-Hello world, this is Inflect Micro V2.}"
 OUTPUT="${2:-output.wav}"
 MODE="${3:-cli}"
+CHIP="${4:-ax650}"
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 cd "$SCRIPT_DIR/python"
 
 if [ "$MODE" = "server" ]; then
-    echo "🌐 Starting OpenAI TTS Server on port ${4:-8000}..."
-    python3 -m inflect_tts_sdk.server --port "${4:-8000}"
+    echo "🌐 Starting OpenAI TTS Server on port ${5:-8000}..."
+    python3 -m inflect_tts_sdk.server --port "${5:-8000}" --chip "$CHIP"
 else
     echo "🎤 ${TEXT}"
-    python3 -m inflect_tts_sdk --text "${TEXT}" --output "${OUTPUT}"
+    python3 -m inflect_tts_sdk --text "${TEXT}" --output "${OUTPUT}" --chip "$CHIP"
     echo "🔊 ${OUTPUT}"
 fi