v2025.12.5: Simplify sentence breaking, consolidate download scripts

## Sentence Breaking
- Remove multi-backend architecture (ICU, wtpsplit, regex fallback)
- Use pysbd exclusively for sentence segmentation
- Remove Protocol, WtpSplitBreaker, ICUBreaker, RegexBreaker, SentenceBreakerFactory
- Single SentenceBreaker class with pysbd

## Download Scripts
- Delete download_models.sh (bash)
- Delete download_models.ps1 (PowerShell)
- Keep only download_models.py (cross-platform, most reliable)

## Footer
- Add version number (v2025.12.5)
- Add JSON schema link (github.com/CLK-AL/HebrewNLP)
- Add full credits: Dicta, thewh1teagle, Piper, pysbd

## README
- Update to v2025.12.5
- Document single download script (download_models.py)
- Remove multi-backend sentence breaking section
- Add rhasspy/piper-voices to credits
- Clarify thewh1teagle credit (diacritization + Hebrew voice)
- Simplify Quick Start to two options (standard + UV)

## Files Changed
- app.py: Simplified sentence breaker, updated footer
- README.md: Updated documentation
- Deleted: download_models.sh, download_models.ps1

.gitignore

@@ -0,0 +1,2 @@
+/.streamlit/
+/onnx/

.idea/.gitignore

@@ -0,0 +1,5 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/dictabert-joint-phonikud-tts.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+      <excludeFolder url="file://$MODULE_DIR$/.venv1" />
+      <excludeFolder url="file://$MODULE_DIR$/.venv2" />
+      <excludeFolder url="file://$MODULE_DIR$/.cache/huggingface/download" />
+      <excludeFolder url="file://$MODULE_DIR$/.streamlit" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.12 (hebrew-unified-nlp)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/dictionaries/project.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="project">
+    <words>
+      <w>libsndfile</w>
+    </words>
+  </dictionary>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.13 (hebrew-unified-nlp)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (hebrew-unified-nlp)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/dictabert-joint-phonikud-tts.iml" filepath="$PROJECT_DIR$/.idea/dictabert-joint-phonikud-tts.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

Dockerfile

@@ -1,23 +1,41 @@
 FROM ghcr.io/astral-sh/uv:python3.11-bookworm-slim
 
-RUN useradd -m -u 1000 user
-
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    graphviz \
+    libsndfile1 \
+    espeak-ng \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 
-# Use system Python environment (recommended for containers)
-ENV UV_SYSTEM_PYTHON=1
-
+# Copy project files
+COPY pyproject.toml .
 COPY requirements.txt .
-RUN uv pip install --no-cache -r requirements.txt
-
-COPY . .
 
-# Setup user
-RUN chown -R user:user /app
-USER user
-ENV HOME=/app
+# Install dependencies with UV (much faster than pip)
+RUN uv pip install --system -r requirements.txt
+
+# Create onnx directories and download models
+RUN mkdir -p onnx/piper-voices && \
+    wget -q -O onnx/phonikud-1.0.int8.onnx \
+        https://huggingface.co/thewh1teagle/phonikud-onnx/resolve/main/phonikud-1.0.int8.onnx && \
+    wget -q -O onnx/piper-voices/he_IL-phonikud.onnx \
+        https://huggingface.co/thewh1teagle/phonikud-tts-checkpoints/resolve/main/model.onnx && \
+    wget -q -O onnx/piper-voices/he_IL-phonikud.onnx.json \
+        https://huggingface.co/thewh1teagle/phonikud-tts-checkpoints/resolve/main/model.config.json && \
+    wget -q -O onnx/piper-voices/en_US-ryan-high.onnx \
+        https://huggingface.co/rhasspy/piper-voices/resolve/main/en/en_US/ryan/high/en_US-ryan-high.onnx && \
+    wget -q -O onnx/piper-voices/en_US-ryan-high.onnx.json \
+        https://huggingface.co/rhasspy/piper-voices/resolve/main/en/en_US/ryan/high/en_US-ryan-high.onnx.json
+
+# Copy application
+COPY app.py schema.json ./
 
 EXPOSE 7860
-CMD ["uv", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+CMD ["streamlit", "run", "app.py"]

README.md

@@ -1,10 +1,254 @@
 ---
-title: Text to speech in Hebrew
-emoji: 🐢
-colorFrom: red
-colorTo: green
-sdk: docker
-sdk_version: "4.44.0"
+title: Hebrew Unified NLP
+emoji: 🇮🇱
+colorFrom: blue
+colorTo: white
+sdk: streamlit
+sdk_version: 1.40.0
 app_file: app.py
 pinned: false
----
+license: mit
+models:
+  - dicta-il/dictabert-joint
+  - thewh1teagle/phonikud-onnx
+  - thewh1teagle/phonikud-tts-checkpoints
+  - rhasspy/piper-voices
+---
+
+# 🇮🇱 Hebrew Unified NLP v2025.12.5
+
+A comprehensive Hebrew NLP pipeline with multilingual TTS, bilingual UI (English/Hebrew), and per-sentence parallel processing.
+
+## Features
+
+- **Morphological Analysis**: DictaBERT-Joint for POS tagging, dependency parsing, NER, segmentation
+- **Phonetic Processing**: Phonikud for Hebrew diacritization (nikud) and phoneme generation
+- **Multilingual TTS**: 37 Piper voices (36 English + 1 Hebrew) with per-sentence language detection
+- **Bilingual UI**: Full English/Hebrew interface with RTL support and translated labels
+- **Parallel Processing**: Async pipeline with configurable workers for batch processing
+- **Rich Output**: SVG dependency trees, aligned audio playlist, structured JSON
+
+## Project Structure
+
+```
+hebrew-unified-nlp/
+├── app.py                    # Main Streamlit application
+├── schema.json               # JSON output schema (v2025.12.5)
+├── requirements.txt          # Python dependencies
+├── Dockerfile                # Container deployment
+├── download_models.py        # Cross-platform model download script
+└── onnx/
+    ├── phonikud-1.0.int8.onnx    # Hebrew diacritization model
+    └── piper-voices/
+        ├── he_IL-phonikud.onnx       # Hebrew TTS voice
+        ├── he_IL-phonikud.onnx.json
+        ├── en_US-ryan-high.onnx      # Default English voice
+        ├── en_US-ryan-high.onnx.json
+        └── ...                        # Additional English voices
+```
+
+## ⚠️ Python Version Requirement
+
+**Requires Python 3.10 - 3.12** (phonikud doesn't support Python 3.13 yet)
+
+## Quick Start
+
+### Standard Setup
+
+```bash
+# Create virtual environment
+python -m venv .venv
+.venv\Scripts\activate  # Windows
+source .venv/bin/activate  # Linux/Mac
+
+# Install system dependencies (Linux only)
+sudo apt install graphviz libsndfile1 espeak-ng  # Ubuntu/Debian
+
+# Install Python dependencies
+pip install -r requirements.txt
+
+# Download essential models (phonikud + Hebrew + English voice)
+python download_models.py --essential
+
+# Or download all 36 English voices
+python download_models.py
+
+# Run
+streamlit run app.py
+```
+
+### With UV Package Manager (Faster)
+
+```bash
+# Install UV
+curl -LsSf https://astral.sh/uv/install.sh | sh  # Linux/Mac
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"  # Windows
+
+# Create venv with Python 3.11
+uv venv --python 3.11
+source .venv/bin/activate  # or .venv\Scripts\activate on Windows
+
+# Install dependencies (10x faster than pip)
+uv pip install -r requirements.txt
+
+# Download models
+python download_models.py --essential
+
+# Run
+streamlit run app.py
+```
+
+## Download Models
+
+```bash
+python download_models.py              # All 36 English voices + Hebrew
+python download_models.py --essential  # Minimal: phonikud + Hebrew + en_US-ryan-high
+```
+
+The script uses HuggingFace Hub, skips existing files, and works on all platforms.
+
+## Available Voices
+
+### Hebrew
+- `he_IL-phonikud` - Hebrew voice with proper nikud support
+
+### English (36 voices)
+**British (en_GB):**
+alan, alba, aru, cori, jenny_dioco, northern_english_male, semaine, southern_english_female, vctk
+
+**American (en_US):**
+amy, arctic, bryce, danny, hfc_female, hfc_male, joe, john, kathleen, kusal, kristin, l2arctic, lessac, libritts, libritts_r, ljspeech, norman, ryan
+
+Each voice has quality variants: low, medium, high (not all variants available for all voices).
+
+## JSON Output Format
+
+```json
+{
+  "meta": {
+    "version": "2025.12.5",
+    "timestamp": "2025-12-05T14:30:00Z",
+    "models": {
+      "phonikud": "phonikud-1.0.int8",
+      "piper": "he_IL-phonikud / en_US-ryan-high",
+      "dictabert": "dicta-il/dictabert-joint"
+    },
+    "processing_time_ms": 245.5,
+    "sentence_count": 3,
+    "parallel_workers": 4,
+    "sentence_breaker": "pysbd"
+  },
+  "input": {
+    "text": "הילד הלך לבית הספר. He walked home.",
+    "language": "mixed"
+  },
+  "translations": {
+    "pos": { "NOUN": {"en": "Noun", "he": "שם עצם"}, "..." : "..." },
+    "dep": { "nsubj": {"en": "Subject", "he": "נושא"}, "..." : "..." },
+    "ner": { "PER": {"en": "Person", "he": "אדם"}, "..." : "..." },
+    "morph": { "Masc": {"en": "Masculine", "he": "זכר"}, "..." : "..." }
+  },
+  "sentences": [
+    {
+      "index": 0,
+      "text": "הילד הלך לבית הספר.",
+      "language": "he",
+      "phonetics": {
+        "diacritized": "הַיֶּלֶד הָלַךְ לְבֵית הַסֵּפֶר.",
+        "phonemes": "h a j e l e d | h a l a x | l e v e j t | h a s e f e r"
+      },
+      "tokens": ["..."],
+      "ner_entities": [],
+      "speech": {
+        "format": "wav",
+        "sample_rate": 22050,
+        "duration_ms": 1847,
+        "voice": "he_IL-phonikud",
+        "data_uri": "data:audio/wav;base64,..."
+      }
+    },
+    {
+      "index": 1,
+      "text": "He walked home.",
+      "language": "en",
+      "speech": {
+        "format": "wav",
+        "sample_rate": 22050,
+        "duration_ms": 1200,
+        "voice": "en_US-ryan-high",
+        "data_uri": "data:audio/wav;base64,..."
+      }
+    }
+  ]
+}
+```
+
+## API Usage
+
+```python
+from app import AsyncHebrewNLP
+import asyncio
+
+# Initialize
+nlp = AsyncHebrewNLP(hf_token="YOUR_TOKEN", max_workers=4)
+
+# Async processing with multilingual TTS
+async def analyze():
+    result = await nlp.process(
+        "הילד הלך לבית הספר. He walked home.",
+        include_audio=True,
+        en_voice="en_US-ryan-high",  # English voice selection
+        compute_mst=True
+    )
+    return result
+
+result = asyncio.run(analyze())
+
+# Or sync wrapper
+result = nlp.process_sync("הילד הלך לבית הספר.")
+
+# Access results
+print(f"Sentences: {result['meta']['sentence_count']}")
+for sent in result['sentences']:
+    print(f"[{sent['index']}] ({sent['language']}) {sent['text']}")
+    if sent['language'] == 'he':
+        print(f"    Nikud: {sent['phonetics']['diacritized']}")
+```
+
+## Performance
+
+| Sentences | Sequential | Parallel (4 workers) | Speedup |
+|-----------|------------|---------------------|---------|
+| 1 | ~120ms | ~120ms | 1x |
+| 4 | ~480ms | ~150ms | 3.2x |
+| 10 | ~1200ms | ~350ms | 3.4x |
+
+## Docker
+
+```bash
+docker build -t hebrew-nlp .
+docker run -p 8501:8501 hebrew-nlp
+```
+
+The Dockerfile pre-downloads essential models (phonikud + Hebrew voice + en_US-ryan-high).
+
+## Bilingual UI
+
+The interface supports both English and Hebrew with a language toggle in the sidebar. All labels are translated including:
+- Part-of-speech tags (NOUN → שם עצם)
+- Dependency relations (nsubj → נושא)
+- NER entity types (PER → אדם)
+- Morphological features (Masc → זכר, Sing → יחיד)
+- Prefix types (DEF → ה׳ הידיעה)
+
+## Credits
+
+- [Dicta](https://dicta.org.il/) - DictaBERT-Joint model
+- [thewh1teagle](https://github.com/thewh1teagle) - Phonikud diacritization & Hebrew TTS voice
+- [Piper](https://github.com/rhasspy/piper) - Neural TTS engine
+- [rhasspy/piper-voices](https://huggingface.co/rhasspy/piper-voices) - English TTS voices
+- [pysbd](https://github.com/nipunsadvilkar/pySBD) - Sentence boundary detection
+
+## License
+
+MIT

app.py

@@ -1,78 +1,1509 @@
 """
-uv sync
-uv pip install Flask>=3.1.2
-wget https://huggingface.co/thewh1teagle/phonikud-onnx/resolve/main/phonikud-1.0.int8.onnx
-wget https://huggingface.co/thewh1teagle/phonikud-tts-checkpoints/resolve/main/model.onnx
-wget https://huggingface.co/thewh1teagle/phonikud-tts-checkpoints/resolve/main/model.config.json
-uv run ./examples/space_v1/app.py
+Hebrew Unified NLP - Async Parallel Pipeline 2025.12.5
+======================================================
+
+Architecture:
+    Text → pysbd Sentence Breaker → async.gather([process(s) for s in sentences]) → JSON Array
 """
 
-from flask import Flask, render_template, request, jsonify
-from phonikud_tts import Phonikud, phonemize, Piper
-import soundfile as sf
+import streamlit as st
+import json
 import base64
-import io
-import argparse
+import asyncio
+from io import BytesIO
+from typing import Optional
+from datetime import datetime, timezone
+from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor
+import time
+import re
+
+import numpy as np
+import soundfile as sf
+from graphviz import Digraph
+from transformers import AutoModel, AutoTokenizer
+import torch
+
+# Phonikud TTS
+from phonikud_tts import Phonikud, phonemize, Piper
+
+
+def detect_script(text: str) -> str:
+    """Detect primary script of text: 'he' for Hebrew, 'en' for Latin/English."""
+    he_count = 0
+    en_count = 0
+    for char in text:
+        code = ord(char)
+        # Hebrew: U+0590-U+05FF
+        if 0x0590 <= code <= 0x05FF:
+            he_count += 1
+        # Latin: A-Z, a-z
+        elif (0x0041 <= code <= 0x005A) or (0x0061 <= code <= 0x007A):
+            en_count += 1
+    return "he" if he_count >= en_count else "en"
+
+
+# ============================================================================
+# Piper Voices (rhasspy/piper-voices + phonikud-tts)
+# ============================================================================
+
+PIPER_VOICES = {
+    # Hebrew (phonikud-tts) - special handling
+    "he_IL-phonikud": ("he_IL", "phonikud", None),
+    # en_GB
+    "en_GB-alan-low": ("en_GB", "alan", "low"),
+    "en_GB-alan-medium": ("en_GB", "alan", "medium"),
+    "en_GB-alba-medium": ("en_GB", "alba", "medium"),
+    "en_GB-aru-medium": ("en_GB", "aru", "medium"),
+    "en_GB-cori-medium": ("en_GB", "cori", "medium"),
+    "en_GB-cori-high": ("en_GB", "cori", "high"),
+    "en_GB-jenny_dioco-medium": ("en_GB", "jenny_dioco", "medium"),
+    "en_GB-northern_english_male-medium": ("en_GB", "northern_english_male", "medium"),
+    "en_GB-semaine-medium": ("en_GB", "semaine", "medium"),
+    "en_GB-southern_english_female-low": ("en_GB", "southern_english_female", "low"),
+    "en_GB-vctk-medium": ("en_GB", "vctk", "medium"),
+    # en_US
+    "en_US-amy-low": ("en_US", "amy", "low"),
+    "en_US-amy-medium": ("en_US", "amy", "medium"),
+    "en_US-arctic-medium": ("en_US", "arctic", "medium"),
+    "en_US-bryce-medium": ("en_US", "bryce", "medium"),
+    "en_US-danny-low": ("en_US", "danny", "low"),
+    "en_US-hfc_female-medium": ("en_US", "hfc_female", "medium"),
+    "en_US-hfc_male-medium": ("en_US", "hfc_male", "medium"),
+    "en_US-joe-medium": ("en_US", "joe", "medium"),
+    "en_US-john-medium": ("en_US", "john", "medium"),
+    "en_US-kathleen-low": ("en_US", "kathleen", "low"),
+    "en_US-kristin-medium": ("en_US", "kristin", "medium"),
+    "en_US-kusal-medium": ("en_US", "kusal", "medium"),
+    "en_US-l2arctic-medium": ("en_US", "l2arctic", "medium"),
+    "en_US-lessac-high": ("en_US", "lessac", "high"),
+    "en_US-lessac-low": ("en_US", "lessac", "low"),
+    "en_US-lessac-medium": ("en_US", "lessac", "medium"),
+    "en_US-libritts-high": ("en_US", "libritts", "high"),
+    "en_US-libritts_r-medium": ("en_US", "libritts_r", "medium"),
+    "en_US-ljspeech-high": ("en_US", "ljspeech", "high"),
+    "en_US-ljspeech-medium": ("en_US", "ljspeech", "medium"),
+    "en_US-norman-medium": ("en_US", "norman", "medium"),
+    "en_US-ryan-high": ("en_US", "ryan", "high"),
+    "en_US-ryan-low": ("en_US", "ryan", "low"),
+    "en_US-ryan-medium": ("en_US", "ryan", "medium"),
+}
+
+
+class PiperVoiceManager:
+    """Lazy-load Piper voices on demand (Hebrew and English)."""
+
+    def __init__(self, cache_dir: str = "./onnx/piper-voices"):
+        from pathlib import Path
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self._loaded = {}
+
+    def get(self, voice_name: str) -> Piper:
+        """Get voice, download if needed."""
+        if voice_name in self._loaded:
+            return self._loaded[voice_name]
+
+        if voice_name not in PIPER_VOICES:
+            raise ValueError(f"Unknown voice: {voice_name}")
+
+        region, speaker, quality = PIPER_VOICES[voice_name]
+
+        model_path = self.cache_dir / f"{voice_name}.onnx"
+        config_path = self.cache_dir / f"{voice_name}.onnx.json"
+
+        # Download if needed
+        if not model_path.exists():
+            from huggingface_hub import hf_hub_download
+            import shutil
+
+            if voice_name == "he_IL-phonikud":
+                # Hebrew voice from phonikud-tts-checkpoints
+                downloaded_model = hf_hub_download(
+                    repo_id="thewh1teagle/phonikud-tts-checkpoints",
+                    filename="model.onnx",
+                    local_dir=self.cache_dir / "_temp",
+                )
+                downloaded_config = hf_hub_download(
+                    repo_id="thewh1teagle/phonikud-tts-checkpoints",
+                    filename="model.config.json",
+                    local_dir=self.cache_dir / "_temp",
+                )
+            else:
+                # English voices from rhasspy/piper-voices
+                subdir = f"en/{region}/{speaker}/{quality}"
+                downloaded_model = hf_hub_download(
+                    repo_id="rhasspy/piper-voices",
+                    filename=f"{subdir}/{voice_name}.onnx",
+                    local_dir=self.cache_dir / "_temp",
+                )
+                downloaded_config = hf_hub_download(
+                    repo_id="rhasspy/piper-voices",
+                    filename=f"{subdir}/{voice_name}.onnx.json",
+                    local_dir=self.cache_dir / "_temp",
+                )
+
+            # Move to cache root with consistent naming
+            shutil.move(downloaded_model, model_path)
+            shutil.move(downloaded_config, config_path)
+
+            # Clean up temp dir
+            temp_dir = self.cache_dir / "_temp"
+            if temp_dir.exists():
+                shutil.rmtree(temp_dir)
+
+        self._loaded[voice_name] = Piper(str(model_path), str(config_path))
+        return self._loaded[voice_name]
+
+
+# ============================================================================
+# Label Translations (Single Source of Truth)
+# ============================================================================
+
+LABEL_TRANSLATIONS = {
+    "pos": {
+        "NOUN": {"en": "Noun", "he": "שם עצם"},
+        "VERB": {"en": "Verb", "he": "פועל"},
+        "ADJ": {"en": "Adjective", "he": "שם תואר"},
+        "ADV": {"en": "Adverb", "he": "תואר הפועל"},
+        "PRON": {"en": "Pronoun", "he": "כינוי"},
+        "DET": {"en": "Determiner", "he": "מגדיר"},
+        "ADP": {"en": "Adposition", "he": "מילת יחס"},
+        "CCONJ": {"en": "Coord. Conj.", "he": "מילת קישור"},
+        "SCONJ": {"en": "Subord. Conj.", "he": "מילת זיקה"},
+        "NUM": {"en": "Number", "he": "מספר"},
+        "PUNCT": {"en": "Punctuation", "he": "פיסוק"},
+        "PROPN": {"en": "Proper Noun", "he": "שם פרטי"},
+        "AUX": {"en": "Auxiliary", "he": "עזר"},
+        "INTJ": {"en": "Interjection", "he": "קריאה"},
+        "PART": {"en": "Particle", "he": "מילית"},
+        "SYM": {"en": "Symbol", "he": "סמל"},
+        "X": {"en": "Other", "he": "אחר"}
+    },
+    "dep": {
+        "nsubj": {"en": "Subject", "he": "נושא"},
+        "obj": {"en": "Object", "he": "מושא"},
+        "iobj": {"en": "Indirect Obj.", "he": "מושא עקיף"},
+        "root": {"en": "Root", "he": "שורש"},
+        "csubj": {"en": "Clausal Subj.", "he": "נושא משפטי"},
+        "compound": {"en": "Compound", "he": "צירוף"},
+        "compound:smixut": {"en": "Smixut", "he": "סמיכות"},
+        "amod": {"en": "Adj. Mod.", "he": "תואר"},
+        "advmod": {"en": "Adv. Mod.", "he": "תואר פועל"},
+        "nummod": {"en": "Num. Mod.", "he": "מספר"},
+        "nmod": {"en": "Noun Mod.", "he": "שם נלווה"},
+        "nmod:poss": {"en": "Possessive", "he": "שייכות"},
+        "nmod:npmod": {"en": "NP Modifier", "he": "צירוף שמני"},
+        "nmod:tmod": {"en": "Temporal", "he": "זמן"},
+        "det": {"en": "Determiner", "he": "מגדיר"},
+        "case": {"en": "Case", "he": "יחוס"},
+        "case:acc": {"en": "Accusative", "he": "יחוס מושא"},
+        "case:gen": {"en": "Genitive", "he": "יחוס שייכות"},
+        "mark": {"en": "Marker", "he": "סמן"},
+        "cc": {"en": "Coord.", "he": "קישור"},
+        "conj": {"en": "Conjunct", "he": "צירוף"},
+        "punct": {"en": "Punctuation", "he": "פיסוק"},
+        "cop": {"en": "Copula", "he": "אוגד"},
+        "aux": {"en": "Auxiliary", "he": "עזר"},
+        "xcomp": {"en": "Open Comp.", "he": "משלים"},
+        "ccomp": {"en": "Clausal Comp.", "he": "משפט משלים"},
+        "advcl": {"en": "Adv. Clause", "he": "משפט תואר"},
+        "acl": {"en": "Adj. Clause", "he": "משפט תואר שם"},
+        "acl:relcl": {"en": "Rel. Clause", "he": "משפט זיקה"},
+        "appos": {"en": "Apposition", "he": "תמורה"},
+        "parataxis": {"en": "Parataxis", "he": "צירוף"},
+        "dep": {"en": "Dependency", "he": "תלות"},
+        "obl": {"en": "Oblique", "he": "נסיבה"},
+        "vocative": {"en": "Vocative", "he": "פנייה"},
+        "expl": {"en": "Expletive", "he": "מילוי"},
+        "dislocated": {"en": "Dislocated", "he": "מוקדם"},
+        "discourse": {"en": "Discourse", "he": "שיח"},
+        "fixed": {"en": "Fixed", "he": "קבוע"},
+        "flat": {"en": "Flat", "he": "שטוח"},
+        "flat:name": {"en": "Name", "he": "שם"}
+    },
+    "ner": {
+        "PER": {"en": "Person", "he": "אדם"},
+        "LOC": {"en": "Location", "he": "מקום"},
+        "GPE": {"en": "Geo-Political", "he": "מקום"},
+        "ORG": {"en": "Organization", "he": "ארגון"},
+        "TIME": {"en": "Time", "he": "זמן"},
+        "DATE": {"en": "Date", "he": "תאריך"},
+        "MISC": {"en": "Misc.", "he": "אחר"}
+    },
+    "prefix": {
+        "ADP": {"en": "Preposition", "he": "יחוס"},
+        "DET": {"en": "Definite", "he": "הידוע"},
+        "CCONJ": {"en": "Conjunction", "he": "חיבור"},
+        "SCONJ": {"en": "Subordinate", "he": "זיקה"},
+        "ADV": {"en": "Adverb", "he": "תואר"},
+        "CONJ": {"en": "Conjunction", "he": "חיבור"},
+        "PREP": {"en": "Preposition", "he": "יחוס"},
+        "DEF": {"en": "Definite", "he": "הידוע"},
+        "REL": {"en": "Relative", "he": "זיקה"},
+        "TEMP": {"en": "Temporal", "he": "זמן"}
+    },
+    "special": {
+        "[UNK]": {"en": "[Unknown]", "he": "[לא ידוע]"},
+        "[BLANK]": {"en": "[Blank]", "he": "[ריק]"},
+        "[PAD]": {"en": "[Padding]", "he": "[ריפוד]"},
+        "[CLS]": {"en": "[Start]", "he": "[התחלה]"},
+        "[SEP]": {"en": "[Separator]", "he": "[הפרדה]"},
+        "[MASK]": {"en": "[Mask]", "he": "[מסכה]"}
+    },
+    "morph": {
+        # Gender
+        "Masc": {"en": "Masculine", "he": "זכר"},
+        "Fem": {"en": "Feminine", "he": "נקבה"},
+        # Number
+        "Sing": {"en": "Singular", "he": "יחיד"},
+        "Plur": {"en": "Plural", "he": "רבים"},
+        "Dual": {"en": "Dual", "he": "זוגי"},
+        # Person
+        "1": {"en": "1st", "he": "ראשון"},
+        "2": {"en": "2nd", "he": "שני"},
+        "3": {"en": "3rd", "he": "שלישי"},
+        # Tense
+        "Past": {"en": "Past", "he": "עבר"},
+        "Present": {"en": "Present", "he": "הווה"},
+        "Future": {"en": "Future", "he": "עתיד"},
+        "Imp": {"en": "Imperative", "he": "ציווי"},
+        "Inf": {"en": "Infinitive", "he": "מקור"},
+        # Voice
+        "Act": {"en": "Active", "he": "פעיל"},
+        "Pass": {"en": "Passive", "he": "סביל"},
+        # Definiteness
+        "Def": {"en": "Definite", "he": "מיודע"},
+        "Ind": {"en": "Indefinite", "he": "סתמי"},
+        # Case
+        "Nom": {"en": "Nominative", "he": "נושא"},
+        "Acc": {"en": "Accusative", "he": "מושא"},
+        "Gen": {"en": "Genitive", "he": "שייכות"},
+        # Construct state
+        "Construct": {"en": "Construct", "he": "סמיכות"},
+        "Free": {"en": "Free", "he": "נפרד"}
+    }
+}
+
+
+def get_label(category: str, code: str, lang: str) -> str:
+    """Get translated label from LABEL_TRANSLATIONS.
+
+    Args:
+        category: One of 'pos', 'dep', 'ner', 'prefix', 'special', 'morph'
+        code: The code to translate (e.g., 'NOUN', 'nsubj', 'PER', 'Masc')
+        lang: Target language ('en' or 'he')
+
+    Returns:
+        Translated label, or original code if not found
+    """
+    cat_dict = LABEL_TRANSLATIONS.get(category, {})
+    code_dict = cat_dict.get(code, {})
+    return code_dict.get(lang, code)
+
+
+def translate_special_tokens(text: str, lang: str) -> str:
+    """Replace special tokens like [UNK] with translations."""
+    for code, translations in LABEL_TRANSLATIONS["special"].items():
+        text = text.replace(code, translations.get(lang, code))
+    return text
+
+
+def strip_punctuation(text: str) -> str:
+    """Remove punctuation from text, keeping Hebrew letters, diacritics, Latin, digits, spaces.
+
+    Preserves:
+    - Hebrew letters: U+05D0-U+05EA
+    - Hebrew cantillation/accents: U+0591-U+05AF
+    - Hebrew diacritics (niqqud): U+05B0-U+05BD, U+05BF, U+05C1-U+05C2, U+05C4-U+05C5, U+05C7
+    - Hebrew geresh (׳) and gershayim (״): U+05F3-U+05F4 (for acronyms like צה"ל)
+    - Regular quotes " ' used in acronyms
+    - Latin letters, digits, spaces
+
+    Removes: punctuation like . , ! ? ; : - ־ ׃ | etc.
+    """
+    import re
+    # Keep Hebrew letters, diacritics, cantillation, geresh/gershayim, quotes for acronyms, Latin, digits, spaces
+    result = re.sub(r'[^\u05D0-\u05EA\u0591-\u05AF\u05B0-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05F3\u05F4"\'A-Za-z0-9\s]', '', text)
+    # Clean up multiple spaces
+    return re.sub(r'\s+', ' ', result).strip()
+
+
+# ============================================================================
+# Sentence Breaker (pysbd)
+# ============================================================================
+
+class SentenceBreaker:
+    """pysbd - Python Sentence Boundary Disambiguation"""
+
+    SUPPORTED = {'es', 'fa', 'ar', 'sk', 'hy', 'am', 'en', 'fr', 'ru', 'my',
+                 'hi', 'pl', 'it', 'ja', 'de', 'zh', 'kk', 'nl', 'da', 'el',
+                 'mr', 'bg', 'ur'}
+
+    def __init__(self, language: str = "he"):
+        import pysbd
+        lang = language if language in self.SUPPORTED else "en"
+        self._segmenter = pysbd.Segmenter(language=lang, clean=False)
+        self._actual_lang = lang
+
+    @property
+    def name(self) -> str:
+        if self._actual_lang and self._actual_lang != "he":
+            return f"pysbd-{self._actual_lang}"
+        return "pysbd"
+
+    def break_sentences(self, text: str) -> list[str]:
+        if not text.strip():
+            return []
+        sentences = self._segmenter.segment(text)
+        return [s.strip() for s in sentences if s.strip()]
+
+
+# ============================================================================
+# Async Parallel Processor
+# ============================================================================
+
+def generate_tree_svg(tokens: list, rtl: bool = True) -> str:
+    """Generate SVG string for dependency tree (no UI translation, raw labels)."""
+    if not tokens:
+        return ""
+
+    dot = Digraph(engine='dot', format='svg')
+    dot.attr('graph', rankdir='LR', rank='same', size=f'{len(tokens)},5', dpi='300')
+    dot.attr('node', fontname='Arial')
+
+    n = len(tokens)
+
+    # Create nodes with nikud (diacritized text)
+    for i, tok in enumerate(tokens):
+        word = tok.get("nikud", tok.get("token", ""))
+        dot.node(str(i), word)
+
+    # Layout direction
+    if rtl:
+        # RTL: first word on right
+        for i in range(n - 1):
+            dot.edge(str(i + 1), str(i), style='invis')
+    else:
+        # LTR: first word on left
+        for i in range(n - 1):
+            dot.edge(str(i), str(i + 1), style='invis')
+
+    # Dependency edges
+    for i, tok in enumerate(tokens):
+        syntax = tok.get("syntax", {})
+        head_idx = syntax.get("dep_head_idx", -1)
+        dep_func = syntax.get("dep_func", "")
+
+        if head_idx >= 0:
+            dot.edge(str(head_idx), str(i), label=dep_func, constraint='False')
+
+    return dot.pipe(format='svg').decode('utf-8')
+
+
+@dataclass
+class SentenceResult:
+    """Result for a single sentence"""
+    index: int
+    text: str
+    phonetics: dict
+    tokens: list
+    ner_entities: list
+    audio: Optional[dict] = None
+
+
+class AsyncHebrewNLP:
+    """Async parallel Hebrew NLP pipeline"""
+
+    VERSION = "2025.12.5"
+
+    def __init__(
+        self,
+        phonikud_model: str = "./onnx/phonikud-1.0.int8.onnx",
+        dictabert_model: str = "dicta-il/dictabert-joint",
+        hf_token: Optional[str] = None,
+        max_workers: int = 4,
+    ):
+        self.sentence_breaker = SentenceBreaker()
+
+        # Auto-download phonikud model if not found
+        from pathlib import Path
+        phonikud_path = Path(phonikud_model)
+        if not phonikud_path.exists():
+            phonikud_path.parent.mkdir(parents=True, exist_ok=True)
+            from huggingface_hub import hf_hub_download
+            hf_hub_download(
+                repo_id="thewh1teagle/phonikud-onnx",
+                filename="phonikud-1.0.int8.onnx",
+                local_dir=phonikud_path.parent,
+            )
+
+        self.phonikud = Phonikud(str(phonikud_path))
+        self.piper = PiperVoiceManager()  # Unified voice manager (Hebrew + English, lazy-load)
+
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            dictabert_model, token=hf_token
+        )
+        self.dictabert = AutoModel.from_pretrained(
+            dictabert_model, token=hf_token, trust_remote_code=True
+        )
+        self.dictabert.eval()
+
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+
+        self._model_info = {
+            "phonikud": phonikud_path.name.replace(".onnx", ""),
+            "piper": "piper-voices (he_IL + en)",
+            "dictabert": dictabert_model
+        }
+
+    async def process(
+        self,
+        text: str,
+        include_audio: bool = True,
+        compute_mst: bool = True,
+        tts_params: Optional[dict] = None,
+        en_voice: str = "en_US-ryan-high",
+    ) -> dict:
+        start_time = time.perf_counter()
+
+        tts_params = tts_params or {
+            "length_scale": 1.20,
+            "noise_scale": 0.640,
+            "noise_w": 1.0
+        }
+
+        sentences = self.sentence_breaker.break_sentences(text)
+
+        if not sentences:
+            return self._empty_result(text, start_time)
+
+        loop = asyncio.get_event_loop()
+
+        tasks = [
+            loop.run_in_executor(
+                self.executor,
+                self._process_sentence,
+                idx, sentence, compute_mst, include_audio, tts_params, en_voice
+            )
+            for idx, sentence in enumerate(sentences)
+        ]
+
+        sentence_results = await asyncio.gather(*tasks)
+
+        processing_time = (time.perf_counter() - start_time) * 1000
+
+        return {
+            "meta": {
+                "version": self.VERSION,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "models": self._model_info,
+                "processing_time_ms": round(processing_time, 2),
+                "sentence_count": len(sentences),
+                "parallel_workers": self.executor._max_workers,
+                "sentence_breaker": self.sentence_breaker.name
+            },
+            "translations": LABEL_TRANSLATIONS,
+            "input": {
+                "text": text,
+                "language": "he"
+            },
+            "sentences": [self._sentence_to_dict(r) for r in sentence_results]
+        }
+
+    def process_sync(
+        self,
+        text: str,
+        include_audio: bool = True,
+        compute_mst: bool = True,
+        tts_params: Optional[dict] = None,
+        en_voice: str = "en_US-ryan-high",
+    ) -> dict:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(
+                self.process(text, include_audio, compute_mst, tts_params, en_voice)
+            )
+        finally:
+            loop.close()
+
+    def _process_sentence(
+        self,
+        index: int,
+        sentence: str,
+        compute_mst: bool,
+        include_audio: bool,
+        tts_params: dict,
+        en_voice: str = "en_US-ryan-high"
+    ) -> SentenceResult:
+        # Detect language for this sentence
+        lang = detect_script(sentence)
+
+        if lang == 'he':
+            # Hebrew: use phonikud for diacritics and phonemes
+            diacritized = self.phonikud.add_diacritics(sentence)
+            phonemes = phonemize(diacritized)
+            diacritized = diacritized.replace('|', '')  # Remove pipe markers after phonemize
+        else:
+            # English/other: no diacritics or phonemes
+            diacritized = sentence
+            phonemes = ''
+
+        with torch.no_grad():
+            dictabert_result = self.dictabert.predict(
+                [sentence],  # Use original sentence for DictaBERT
+                self.tokenizer,
+                compute_syntax_mst=compute_mst,
+                output_style='json'
+            )[0]
+
+        tokens = self._enrich_tokens(
+            dictabert_result.get('tokens', []),
+            diacritized,
+            phonemes
+        )
+
+        audio = None
+        if include_audio:
+            # Hebrew uses phonemes, English uses text
+            speech_text = phonemes if lang == 'he' else sentence
+            audio = self._generate_audio(speech_text, tts_params, lang, en_voice)
+
+        return SentenceResult(
+            index=index,
+            text=sentence,
+            phonetics={"diacritized": diacritized, "phonemes": phonemes},
+            tokens=tokens,
+            ner_entities=dictabert_result.get('ner_entities', []),
+            audio=audio
+        )
+
+    def _enrich_tokens(
+        self,
+        dictabert_tokens: list,
+        diacritized: str,
+        phonemes: str
+    ) -> list:
+        """Enrich tokens with nikud and phonemes - align by skipping punctuation."""
+        # Split nikud words, also splitting on hyphens and slashes within words
+        nikud_words = []
+        for word in diacritized.split():
+            # Split on - and / but keep them as separate elements
+            import re
+            parts = re.split(r'([-/])', word)
+            for part in parts:
+                if part:  # Skip empty strings
+                    nikud_words.append(part)
+
+        phoneme_parts = phonemes.split(" | ") if " | " in phonemes else phonemes.split()
+
+        enriched = []
+        nikud_idx = 0  # Separate index for nikud words
+        phoneme_idx = 0  # Separate index for phonemes
+
+        for tok in dictabert_tokens:
+            token_text = tok.get('token', '')
+            pos = tok.get('morph', {}).get('pos', '')
+
+            # Treat PUNCT and SYM as punctuation (don't consume nikud words)
+            if pos in ('PUNCT', 'SYM'):
+                # Punctuation/symbol token - use original token
+                nikud = token_text
+                # Skip nikud_idx if it points to matching punctuation/symbol
+                if nikud_idx < len(nikud_words) and nikud_words[nikud_idx] == token_text:
+                    nikud_idx += 1
+                token_phonemes = ''
+            else:
+                # Content token - get nikud from list
+                if nikud_idx < len(nikud_words):
+                    nikud = strip_punctuation(nikud_words[nikud_idx])
+                    nikud_idx += 1
+                else:
+                    nikud = token_text
+
+                # Get phonemes
+                if phoneme_idx < len(phoneme_parts):
+                    token_phonemes = phoneme_parts[phoneme_idx]
+                    phoneme_idx += 1
+                else:
+                    token_phonemes = ''
+
+            # Fallback if nikud became empty
+            if not nikud:
+                nikud = token_text
+
+            enriched.append({
+                "id": len(enriched) + 1,
+                "token": token_text,
+                "nikud": nikud,
+                "phonemes": token_phonemes,
+                "seg": tok.get('seg', []),
+                "lex": tok.get('lex', ''),
+                "offsets": tok.get('offsets', {}),
+                "morph": tok.get('morph', {}),
+                "syntax": tok.get('syntax', {})
+            })
+
+        return enriched
+
+    def _generate_audio(self, text: str, tts_params: dict, lang: str = 'he', en_voice: str = "en_US-ryan-high") -> dict:
+        """Generate speech audio for Hebrew (phonemes) or English (text)."""
+        if lang == 'he':
+            voice_name = "he_IL-phonikud"
+            is_phonemes = True
+        else:
+            voice_name = en_voice
+            is_phonemes = False
+
+        piper = self.piper.get(voice_name)
+
+        samples, rate = piper.create(
+            text,
+            is_phonemes=is_phonemes,
+            length_scale=tts_params.get('length_scale', 1.20),
+            noise_scale=tts_params.get('noise_scale', 0.640),
+            noise_w=tts_params.get('noise_w', 1.0)
+        )
+        samples = np.clip(samples * 2.0, -1.0, 1.0)
+
+        buf = BytesIO()
+        sf.write(buf, samples, rate, format="WAV")
+        buf.seek(0)
+        b64 = base64.b64encode(buf.read()).decode()
+
+        return {
+            "format": "wav",
+            "sample_rate": rate,
+            "duration_ms": round(len(samples) / rate * 1000, 2),
+            "data_uri": f"data:audio/wav;base64,{b64}"
+        }
+
+    def _sentence_to_dict(self, result: SentenceResult) -> dict:
+        lang = detect_script(result.text)  # Detect per sentence
+        return {
+            "index": result.index,
+            "lang": lang,
+            "text": result.text,
+            "phonetics": result.phonetics,
+            "tokens": result.tokens,
+            "ner_entities": result.ner_entities,
+            "audio": result.audio,
+            "tree_svg": generate_tree_svg(result.tokens, rtl=(lang == "he"))
+        }
+
+    def _empty_result(self, text: str, start_time: float) -> dict:
+        return {
+            "meta": {
+                "version": self.VERSION,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "models": self._model_info,
+                "processing_time_ms": round((time.perf_counter() - start_time) * 1000, 2),
+                "sentence_count": 0,
+                "parallel_workers": self.executor._max_workers,
+                "sentence_breaker": self.sentence_breaker.name
+            },
+            "input": {"text": text, "language": "he"},
+            "sentences": []
+        }
+
+
+# ============================================================================
+# Visualization Functions
+# ============================================================================
+
+def display_sentence_tree(tokens: list, sentence_idx: int, rtl: bool = None):
+    if not tokens:
+        return
+
+    dot = Digraph(engine='dot', format='svg')
+    dot.attr('graph', rankdir='LR', rank='same', size=f'{len(tokens)},5', dpi='300')
+    dot.attr('node', fontname='Arial')
+
+    n = len(tokens)
+
+    # Use passed rtl param, or fall back to UI language
+    if rtl is None:
+        rtl_mode = st.session_state.get('ui_lang', 'he') == 'he'
+    else:
+        rtl_mode = rtl
+
+    # Get UI language for translations
+    ui_lang = st.session_state.get('ui_lang', 'he')
 
-app = Flask(__name__)
-phonikud = Phonikud("phonikud-1.0.int8.onnx")
-piper = Piper("model.onnx", "model.config.json")
+    # Create nodes with nikud (diacritized text)
+    for i, tok in enumerate(tokens):
+        word = tok.get("nikud", tok.get("token", ""))
+        word = translate_special_tokens(word, ui_lang)
+        dot.node(str(i), word)
 
-# Get commit information safely
-def get_phonikud_commit():
+    if rtl_mode:
+        # RTL: Invisible edges high->low puts first word on RIGHT
+        for i in range(n - 1):
+            dot.edge(str(i + 1), str(i), style='invis')
+    else:
+        # LTR: Invisible edges low->high puts first word on LEFT
+        for i in range(n - 1):
+            dot.edge(str(i), str(i + 1), style='invis')
+
+    # Dependency edges with translated labels
+    for i, tok in enumerate(tokens):
+        syntax = tok.get("syntax", {})
+        head_idx = syntax.get("dep_head_idx", -1)
+        dep_func = syntax.get("dep_func", "")
+
+        if head_idx >= 0:
+            label = get_label("dep", dep_func, ui_lang)
+            dot.edge(str(head_idx), str(i), label=label, constraint='False')
+
+    st.markdown(
+        f"""<div style="height:200px; overflow:auto; border:1px solid #ddd; 
+             border-radius:8px; padding:8px; background:#fafafa;">
+            <img src="data:image/svg+xml;base64,{base64.b64encode(dot.pipe(format='svg')).decode()}"
+                style="display:block; margin:auto; max-height:180px;">
+        </div>""", unsafe_allow_html=True)
+
+
+def display_tokens_table(tokens: list):
+    if not tokens:
+        return
+
+    # Get UI language
+    ui_lang = "he" if is_rtl() else "en"
+
+    rows = []
+    for tok in tokens:
+        morph = tok.get('morph', {})
+        syntax = tok.get('syntax', {})
+        pos = morph.get('pos', '-')
+        rel = syntax.get('dep_func', '-')
+        prefixes = morph.get('prefixes', [])
+
+        # Get token values
+        token_text = tok['token']
+        nikud_text = tok['nikud']
+        phonemes_text = tok['phonemes']
+        lemma_text = tok['lex']
+
+        # Translate special tokens and labels based on UI language
+        token_text = translate_special_tokens(token_text, ui_lang)
+        nikud_text = translate_special_tokens(nikud_text, ui_lang)
+        lemma_text = translate_special_tokens(lemma_text, ui_lang)
+
+        display_pos = get_label("pos", pos, ui_lang)
+        display_rel = get_label("dep", rel, ui_lang)
+        display_prefixes = ', '.join(get_label("prefix", p, ui_lang) for p in prefixes) or '-'
+
+        rows.append({
+            "#": tok['id'],
+            t("token"): token_text,
+            t("nikud"): nikud_text,
+            t("phonemes"): phonemes_text,
+            t("lemma"): lemma_text,
+            t("pos"): display_pos,
+            t("prefixes"): display_prefixes,
+            t("head"): syntax.get('dep_head_idx', -1) + 1,
+            t("rel"): display_rel
+        })
+
+    st.dataframe(rows, width="stretch")
+
+
+def display_ner_entities(entities: list):
+    if not entities:
+        st.info(t("no_entities"))
+        return
+
+    # Dark theme colors with light text
+    colors = {
+        'PER': '#c2185b', 'LOC': '#2e7d32', 'ORG': '#1565c0',
+        'GPE': '#2e7d32', 'TIME': '#f57c00', 'DATE': '#f57c00', 'MISC': '#616161'
+    }
+
+    # Get UI language
+    ui_lang = "he" if is_rtl() else "en"
+
+    html = ""
+    for ent in entities:
+        label = ent.get('label', 'MISC')
+        phrase = ent.get('phrase', '')
+        color = colors.get(label, '#616161')
+        display_label = get_label("ner", label, ui_lang)
+        html += f"""<span style="background:{color}; color:white; padding:4px 8px; 
+                     border-radius:4px; margin:2px; display:inline-block; font-weight:500;">
+                     {phrase} <small>[{display_label}]</small></span>"""
+
+    st.markdown(html, unsafe_allow_html=True)
+
+
+# ============================================================================
+# Internationalization (i18n)
+# ============================================================================
+
+TRANSLATIONS = {
+    "he": {
+        "title": "🇮🇱 עיבוד שפה עברית מאוחד",
+        "subtitle": "צינור מקבילי אסינכרוני | שבירת משפטים חוצה-פלטפורמה | ארכיטקטורת Map-Reduce",
+        "settings": "⚙️ הגדרות",
+        "language": "🌐 שפה",
+        "compute_mst": "צור עץ תחבירי",
+        "generate_audio": "צור דיבור",
+        "tts_params": "הגדרות דיבור",
+        "en_voice": "🇬🇧 קול אנגלית",
+        "speed": "מהירות",
+        "noise": "רעש",
+        "noise_w": "רעש W",
+        "sentence_pause": "השהיה בין משפטים (שניות)",
+        "sentence_breaker": "מפצל משפטים",
+        "available_backends": "מנועים זמינים",
+        "load_example": "📚 טען דוגמה:",
+        "enter_text": "הזן טקסט (תמיכה במספר משפטים):",
+        "placeholder": "הקלד טקסט...",
+        "analyze": "🔍 נתח",
+        "processing": "מעבד משפטים במקביל...",
+        "enter_text_warning": "אנא הזן טקסט לניתוח.",
+        "sentences": "משפטים",
+        "processing_time": "זמן עיבוד",
+        "workers": "עובדים",
+        "breaker": "מפצל",
+        "sentence": "משפט",
+        "original": "מקור:",
+        "nikud": "ניקוד:",
+        "phonemes": "פונמות:",
+        "dep_tree": "🌳 עץ תלויות",
+        "all_trees": "🌳 כל העצים",
+        "sentence_json": "📄 JSON משפט",
+        "morphology": "🔠 מורפולוגיה",
+        "ner": "🏷️ ישויות",
+        "audio": "🔊 אודיו",
+        "speech": "🔊 דיבור",
+        "no_audio": "אין אודיו - הפעל 'צור דיבור' בהגדרות",
+        "duration": "משך",
+        "json_output": "📄 JSON",
+        "full_json": "פלט JSON מלא",
+        "download_json": "⬇️ הורד JSON",
+        "no_entities": "אין ישויות",
+        "models_not_loaded": "המודלים לא נטענו.",
+        "token": "טוקן",
+        "lemma": "למה",
+        "pos": "חלק דיבר",
+        "prefixes": "תחיליות",
+        "head": "ראש",
+        "rel": "יחס",
+        "play_all": "נגן הכל",
+        "stop": "עצור",
+        "playing": "מנגן משפט",
+        "finished": "✓ סיום",
+        "stopped": "נעצר",
+        "download_all_audio": "הורד הכל (WAV)",
+        "download_audio_files": "הורד קבצי אודיו",
+        "breaking_sentences": "מפצל משפטים...",
+        "processing_sentence": "מעבד משפט",
+        "finalizing": "מסיים...",
+        "done": "✓ הסתיים",
+        "no_sentences": "לא נמצאו משפטים",
+        "loading_models": "טוען מודלים...",
+        "loading_dictabert": "טוען DictaBERT...",
+        "loading_phonikud": "טוען Phonikud...",
+        "loading_piper": "טוען Piper TTS...",
+    },
+    "en": {
+        "title": "🇮🇱 Hebrew Unified NLP",
+        "subtitle": "Async Parallel Pipeline | Cross-Platform Sentence Breaking | Map-Reduce Architecture",
+        "settings": "⚙️ Settings",
+        "language": "🌐 Language",
+        "compute_mst": "Create Syntax Tree",
+        "generate_audio": "Generate Audio",
+        "tts_params": "TTS Parameters",
+        "en_voice": "🇬🇧 English Voice",
+        "speed": "Speed",
+        "noise": "Noise",
+        "noise_w": "Noise W",
+        "sentence_pause": "Pause between sentences (sec)",
+        "sentence_breaker": "Sentence Breaker",
+        "available_backends": "Available backends",
+        "load_example": "📚 Load Example:",
+        "enter_text": "Enter text (multiple sentences supported):",
+        "placeholder": "Enter text...",
+        "analyze": "🔍 Analyze",
+        "processing": "Processing sentences in parallel...",
+        "enter_text_warning": "Please enter some text to analyze.",
+        "sentences": "Sentences",
+        "processing_time": "Processing",
+        "workers": "Workers",
+        "breaker": "Breaker",
+        "sentence": "Sentence",
+        "original": "Original:",
+        "nikud": "Nikud:",
+        "phonemes": "Phonemes:",
+        "dep_tree": "🌳 Dependency Tree",
+        "all_trees": "🌳 All Trees",
+        "sentence_json": "📄 Sentence JSON",
+        "morphology": "🔠 Morphology",
+        "ner": "🏷️ Named Entities",
+        "audio": "🔊 Audio",
+        "speech": "🔊 Speech",
+        "no_audio": "No audio - enable 'Generate speech' in settings",
+        "duration": "Duration",
+        "json_output": "📄 JSON",
+        "full_json": "Full JSON Output",
+        "download_json": "⬇️ Download JSON",
+        "no_entities": "No named entities",
+        "models_not_loaded": "Models not loaded.",
+        "token": "Token",
+        "lemma": "Lemma",
+        "pos": "POS",
+        "prefixes": "Prefixes",
+        "head": "Head",
+        "rel": "Rel",
+        "play_all": "Play All",
+        "stop": "Stop",
+        "playing": "Playing sentence",
+        "finished": "✓ Finished",
+        "stopped": "Stopped",
+        "download_all_audio": "Download All (WAV)",
+        "download_audio_files": "Download Audio Files",
+        "breaking_sentences": "Breaking sentences...",
+        "processing_sentence": "Processing sentence",
+        "finalizing": "Finalizing...",
+        "done": "✓ Done",
+        "no_sentences": "No sentences found",
+        "loading_models": "Loading models...",
+        "loading_dictabert": "Loading DictaBERT...",
+        "loading_phonikud": "Loading Phonikud...",
+        "loading_piper": "Loading Piper TTS...",
+    }
+}
+
+def t(key: str) -> str:
+    """Get translated string for current language"""
+    lang = st.session_state.get('ui_lang', 'he')
+    return TRANSLATIONS.get(lang, TRANSLATIONS['en']).get(key, key)
+
+def is_rtl() -> bool:
+    """Check if current language is RTL"""
+    return st.session_state.get('ui_lang', 'he') == 'he'
+
+
+# ============================================================================
+# Streamlit App
+# ============================================================================
+
+st.set_page_config(
+    page_title="Hebrew Unified NLP",
+    page_icon="🇮🇱",
+    layout="wide"
+)
+
+# Initialize language
+if 'ui_lang' not in st.session_state:
+    st.session_state['ui_lang'] = 'he'
+
+# Dynamic RTL/LTR CSS based on language
+if is_rtl():
+    st.markdown("""
+    <style>
+        /* Text inputs RTL */
+        textarea { direction: rtl !important; text-align: right !important; font-family: 'David', 'Noto Sans Hebrew', sans-serif !important; }
+        input[type="text"] { direction: rtl !important; text-align: right !important; }
+        
+        /* Tables RTL */
+        .stDataFrame td, .stDataFrame th { direction: rtl !important; text-align: right !important; }
+        
+        /* Main container RTL */
+        .main .block-container { direction: rtl; }
+        
+        /* All text elements RTL */
+        h1, h2, h3, p, label, .stMarkdown, .stText { direction: rtl !important; text-align: right !important; }
+        
+        /* Sidebar RTL */
+        [data-testid="stSidebar"] { direction: rtl; }
+        [data-testid="stSidebar"] label { direction: rtl !important; text-align: right !important; display: block !important; }
+        [data-testid="stSidebar"] .stMarkdown { direction: rtl !important; text-align: right !important; }
+        [data-testid="stSidebar"] h1, [data-testid="stSidebar"] h2, [data-testid="stSidebar"] h3 { direction: rtl !important; text-align: right !important; }
+        
+        /* Selectbox and other widget labels */
+        .stSelectbox label, .stTextArea label, .stSlider label, .stCheckbox label { 
+            direction: rtl !important; 
+            text-align: right !important; 
+            display: block !important;
+            width: 100% !important;
+        }
+        
+        /* Selectbox dropdown RTL */
+        .stSelectbox > div > div { direction: rtl !important; text-align: right !important; }
+        .stSelectbox [data-baseweb="select"] { direction: rtl !important; }
+        .stSelectbox [data-baseweb="select"] > div { direction: rtl !important; text-align: right !important; }
+        [data-baseweb="popover"] { direction: rtl !important; }
+        [data-baseweb="menu"] { direction: rtl !important; }
+        [role="listbox"] { direction: rtl !important; }
+        [role="option"] { direction: rtl !important; text-align: right !important; }
+        
+        /* Metrics RTL */
+        [data-testid="stMetricLabel"] { direction: rtl !important; text-align: right !important; }
+        
+        /* Expander headers RTL */
+        .streamlit-expanderHeader { direction: rtl !important; text-align: right !important; }
+        [data-testid="stExpander"] { direction: rtl !important; }
+        [data-testid="stExpander"] summary { direction: rtl !important; text-align: right !important; }
+        [data-testid="stExpander"] summary span { direction: rtl !important; }
+        details summary { direction: rtl !important; text-align: right !important; justify-content: flex-end !important; }
+        
+        /* Tabs RTL */
+        .stTabs [data-baseweb="tab-list"] { direction: rtl; }
+    </style>
+    """, unsafe_allow_html=True)
+else:
+    st.markdown("""
+    <style>
+        textarea { direction: ltr !important; text-align: left !important; }
+        input[type="text"] { direction: ltr !important; text-align: left !important; }
+    </style>
+    """, unsafe_allow_html=True)
+
+st.title(t("title"))
+st.markdown(t("subtitle"))
+
+
+@st.cache_resource
+def load_models_cached():
     try:
-        metadata = phonikud.get_metadata()
-        return metadata.get("commit", None)
+        hf_token = st.secrets.get("HF_TOKEN", None)
     except Exception:
-        return None
-
-phonikud_commit = get_phonikud_commit()
-
-@app.route("/")
-def index():
-    return render_template("index.html", phonikud_commit=phonikud_commit)
-
-@app.route("/generate", methods=["POST"])
-def generate():
-    mode = request.form["mode"]
-    text = request.form.get("text", "")
-    phonemes = request.form.get("phonemes", "")
-
-    if mode == "text":
-        with_diacritics = phonikud.add_diacritics(text)
-        phonemes = phonemize(with_diacritics)
-    elif mode == "diacritics":
-        with_diacritics = text
-        phonemes = phonemize(with_diacritics)
-    else:
-        with_diacritics = None
-
-    samples, sample_rate = piper.create(phonemes, is_phonemes=True, length_scale=1.20, noise_scale=0.640, noise_w=1.0) # noise_w=0.8, noise_scale=0.667
-    
-    # Volume up
-    volume_factor = 2
-    samples = samples * volume_factor
-    samples = samples.clip(-1.0, 1.0)  # Ensure values are still in valid [-1, 1] range
-    
-    buffer = io.BytesIO()
-    sf.write(buffer, samples, sample_rate, format="WAV")
-    buffer.seek(0)
-    b64_audio = base64.b64encode(buffer.read()).decode("utf-8")
-    data_uri = f"data:audio/wav;base64,{b64_audio}"
-
-    return jsonify({
-        "diacritics": with_diacritics,
-        "phonemes": phonemes,
-        "audio": data_uri
-    })
-
-@app.route("/audio/<filename>")
-def serve_audio(filename):
-    return app.send_static_file(filename)
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--host', default='0.0.0.0')
-    parser.add_argument('--port', type=int, default=7860)
-    args = parser.parse_args()
-    app.run(debug=True, host=args.host, port=args.port)
+        hf_token = None
+    return AsyncHebrewNLP(hf_token=hf_token, max_workers=4)
+
+
+# Load models with progress
+if 'models_loaded' not in st.session_state:
+    st.session_state['models_loaded'] = False
+    st.session_state['nlp'] = None
+
+if not st.session_state['models_loaded']:
+    try:
+        progress = st.progress(0, text=t("loading_models"))
+        progress.progress(20, text=t("loading_dictabert"))
+        nlp = load_models_cached()
+        progress.progress(60, text=t("loading_phonikud"))
+        progress.progress(80, text=t("loading_piper"))
+        progress.progress(100, text=t("done"))
+        progress.empty()
+
+        st.session_state['nlp'] = nlp
+        st.session_state['models_loaded'] = True
+        models_loaded = True
+    except Exception as e:
+        models_loaded = False
+        st.error(f"Failed to load models: {e}")
+else:
+    nlp = st.session_state['nlp']
+    models_loaded = True
+
+if models_loaded:
+    # Sidebar
+    with st.sidebar:
+        st.header(t("settings"))
+
+        # Language selector - radio buttons
+        lang_options = {"🇮🇱 עברית": "he", "🇬🇧 English": "en"}
+        current_lang = st.session_state.get('ui_lang', 'he')
+
+        def change_language():
+            selected = st.session_state.get('lang_radio', '🇮🇱 עברית')
+            new_lang = lang_options[selected]
+            old_lang = st.session_state.get('ui_lang', 'he')
+            st.session_state['ui_lang'] = new_lang
+            # Reset text and example when language changes
+            if new_lang != old_lang:
+                st.session_state['example_idx'] = 0
+                if new_lang == 'he':
+                    st.session_state['text_input'] = "הילד הלך לבית הספר. הוא למד מתמטיקה ועברית. בערב הוא חזר הביתה."
+                else:
+                    st.session_state['text_input'] = "The boy went to school. He studied math and Hebrew. In the evening he came home."
+                # Clear results when language changes
+                if 'result' in st.session_state:
+                    del st.session_state['result']
+
+        st.radio(
+            t("language"),
+            list(lang_options.keys()),
+            index=0 if current_lang == "he" else 1,
+            key="lang_radio",
+            on_change=change_language,
+            horizontal=True
+        )
+
+        st.divider()
+
+        compute_mst = st.checkbox(t("compute_mst"), value=True)
+        include_audio = st.checkbox(t("generate_audio"), value=True)
+
+        st.subheader(t("tts_params"))
+
+        # English voice selector (filter PIPER_VOICES for en_* voices)
+        en_voices = sorted([v for v in PIPER_VOICES.keys() if v.startswith("en_")])
+        default_voice = "en_US-ryan-high"
+        try:
+            default_idx = en_voices.index(default_voice)
+        except ValueError:
+            default_idx = 0  # Fallback to first voice
+        en_voice = st.selectbox(
+            t("en_voice"),
+            en_voices,
+            index=default_idx
+        )
+
+        length_scale = st.slider(t("speed"), 0.5, 2.0, 1.20, 0.05)
+        noise_scale = st.slider(t("noise"), 0.0, 1.0, 0.640, 0.01)
+        noise_w = st.slider(t("noise_w"), 0.0, 2.0, 1.0, 0.1)
+        sentence_pause = st.slider(t("sentence_pause"), 0.1, 1.0, 0.5, 0.1)
+
+    # ========== MAIN INPUT SECTION ==========
+
+    # Example options (bilingual)
+    example_options_he = [
+        "הילד הלך לבית הספר. הוא למד מתמטיקה ועברית. בערב הוא חזר הביתה.",
+        "דוד בן-גוריון נולד בפלונסק. הוא עלה לארץ ישראל בשנת 1906. בשנת 1948 הכריז על הקמת המדינה.",
+        "השמש זורחת במזרח. היא שוקעת במערב. זה קורה כל יום.",
+    ]
+
+    example_options_en = [
+        "The boy went to school. He studied math and Hebrew. In the evening he came home.",
+        "David Ben-Gurion was born in Plonsk. He immigrated to Israel in 1906. In 1948 he declared the establishment of the state.",
+        "The sun rises in the east. It sets in the west. This happens every day.",
+    ]
+
+    # Switch examples based on UI language
+    example_options = example_options_he if is_rtl() else example_options_en
+
+    # Callback to load example
+    def load_example():
+        idx = st.session_state.get('example_idx', 0)
+        # Get examples for current language
+        examples = example_options_he if st.session_state.get('ui_lang', 'he') == 'he' else example_options_en
+        if idx < len(examples):
+            st.session_state['text_input'] = examples[idx]
+
+    # Initialize text input
+    if 'text_input' not in st.session_state:
+        st.session_state['text_input'] = example_options[0]
+
+    # Check if currently processing
+    is_processing = st.session_state.get('processing', False)
+
+    # Example selector - single label approach (disabled while processing)
+    st.selectbox(
+        t('load_example'),
+        range(len(example_options)),
+        format_func=lambda i: example_options[i][:50] + "...",
+        key="example_idx",
+        on_change=load_example,
+        disabled=is_processing
+    )
+
+    # Text input (disabled while processing)
+    text = st.text_area(
+        t('enter_text'),
+        height=200,
+        placeholder=t("placeholder"),
+        key="text_input",
+        disabled=is_processing
+    )
+
+    # Analyze button (disabled while processing)
+    if st.button(t("analyze"), type="primary", width="stretch", disabled=is_processing):
+        if text.strip():
+            st.session_state['processing'] = True
+            st.rerun()
+        else:
+            st.warning(t("enter_text_warning"))
+
+    # Process with progress bar
+    if st.session_state.get('processing', False) and text.strip():
+        progress_bar = st.progress(0, text=t("processing"))
+        status_text = st.empty()
+
+        try:
+            # Step 1: Break sentences
+            progress_bar.progress(10, text=t("breaking_sentences"))
+            sentences = nlp.sentence_breaker.break_sentences(text)
+
+            if not sentences:
+                st.warning(t("no_sentences"))
+                st.session_state['processing'] = False
+                st.rerun()
+
+            # Step 2: Process each sentence
+            sentence_results = []
+            for idx, sentence in enumerate(sentences):
+                progress_pct = 10 + int(80 * (idx + 1) / len(sentences))
+                status_text.text(f"{t('processing_sentence')} {idx + 1}/{len(sentences)}")
+                progress_bar.progress(progress_pct, text=f"{t('processing_sentence')} {idx + 1}/{len(sentences)}")
+
+                result = nlp._process_sentence(
+                    idx, sentence, compute_mst, include_audio,
+                    {
+                        "length_scale": length_scale,
+                        "noise_scale": noise_scale,
+                        "noise_w": noise_w
+                    },
+                    en_voice=en_voice
+                )
+                sentence_results.append(result)
+
+            # Step 3: Build final result
+            progress_bar.progress(95, text=t("finalizing"))
+
+            result = {
+                "meta": {
+                    "version": nlp.VERSION,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "models": nlp._model_info,
+                    "processing_time_ms": 0,
+                    "sentence_count": len(sentences),
+                    "parallel_workers": nlp.executor._max_workers,
+                    "sentence_breaker": nlp.sentence_breaker.name
+                },
+                "translations": LABEL_TRANSLATIONS,
+                "input": {"text": text, "language": "he"},
+                "sentences": [nlp._sentence_to_dict(r) for r in sentence_results]
+            }
+
+            progress_bar.progress(100, text=t("done"))
+            st.session_state['result'] = result
+
+        except Exception as e:
+            st.error(f"Error: {e}")
+        finally:
+            st.session_state['processing'] = False
+            st.rerun()
+
+    # ========== RESULTS SECTION ==========
+
+    if 'result' in st.session_state:
+        result = st.session_state['result']
+
+        # Metrics
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric(t("sentences"), result['meta']['sentence_count'])
+        with col2:
+            st.metric(t("processing_time"), f"{result['meta']['processing_time_ms']:.0f}ms")
+        with col3:
+            st.metric(t("workers"), result['meta']['parallel_workers'])
+
+        # Text direction based on UI language
+        text_dir = "rtl" if is_rtl() else "ltr"
+        text_align = "right" if is_rtl() else "left"
+
+        # Tabs: Speech, All Trees, JSON, then sentence numbers
+        if result['sentences']:
+            tabs = st.tabs([t("speech"), t("all_trees"), t("json_output")] + [str(s['index']+1) for s in result['sentences']])
+
+            # Speech tab (first)
+            with tabs[0]:
+                # Get audio with sentence text to check punctuation
+                # Extract base64 from data_uri (format: data:audio/wav;base64,{b64})
+                audio_data_list = [
+                    (i, s['audio']['data_uri'].split(',', 1)[1], s['text'])
+                    for i, s in enumerate(result['sentences'])
+                    if s.get('audio') and s['audio'].get('data_uri')
+                ]
+
+                if audio_data_list:
+                    st.subheader(f"🎵 {t('play_all')}")
+
+                    # Combine all WAV files into one with silence between sentences
+                    try:
+                        import wave
+                        import io
+                        import struct
+
+                        combined_audio = io.BytesIO()
+                        combined_writer = None
+                        sample_rate = None
+                        n_channels = None
+                        sample_width = None
+
+                        for file_idx, (idx, b64_data, sent_text) in enumerate(audio_data_list):
+                            wav_bytes = base64.b64decode(b64_data)
+                            wav_io = io.BytesIO(wav_bytes)
+
+                            with wave.open(wav_io, 'rb') as wav_reader:
+                                if combined_writer is None:
+                                    combined_audio = io.BytesIO()
+                                    combined_writer = wave.open(combined_audio, 'wb')
+                                    n_channels = wav_reader.getnchannels()
+                                    sample_width = wav_reader.getsampwidth()
+                                    sample_rate = wav_reader.getframerate()
+                                    combined_writer.setnchannels(n_channels)
+                                    combined_writer.setsampwidth(sample_width)
+                                    combined_writer.setframerate(sample_rate)
+
+                                # Write audio frames
+                                combined_writer.writeframes(wav_reader.readframes(wav_reader.getnframes()))
+
+                                # Add silence based on punctuation (not after last)
+                                if file_idx < len(audio_data_list) - 1:
+                                    sent_text_stripped = sent_text.strip()
+                                    pause_duration = 0
+
+                                    # Full pause for . ! ? or \n
+                                    if sent_text_stripped.endswith(('.', '!', '?', '。')) or '\n' in sent_text:
+                                        pause_duration = sentence_pause
+                                    # Half pause for comma
+                                    elif sent_text_stripped.endswith(','):
+                                        pause_duration = sentence_pause * 0.5
+
+                                    if pause_duration > 0:
+                                        silence_frames = int(sample_rate * pause_duration)
+                                        silence_bytes = b'\x00' * (silence_frames * n_channels * sample_width)
+                                        combined_writer.writeframes(silence_bytes)
+
+                        if combined_writer:
+                            combined_writer.close()
+                            combined_audio.seek(0)
+                            combined_b64 = base64.b64encode(combined_audio.read()).decode()
+                            combined_uri = f"data:audio/wav;base64,{combined_b64}"
+
+                            st.audio(combined_uri, format="audio/wav")
+
+                            # Download combined WAV
+                            combined_audio.seek(0)
+                            st.download_button(
+                                f"⬇️ {t('download_all_audio')}",
+                                combined_audio.read(),
+                                file_name="all_sentences.wav",
+                                mime="audio/wav"
+                            )
+                    except Exception as e:
+                        st.warning(f"Could not combine audio: {e}")
+
+                    st.divider()
+
+                    # Individual WAV download links
+                    st.subheader(f"📥 {t('download_audio_files')}")
+                    cols = st.columns(min(len(audio_data_list), 4))
+                    for i, (idx, b64_data, _) in enumerate(audio_data_list):
+                        wav_bytes = base64.b64decode(b64_data)
+                        with cols[i % 4]:
+                            st.download_button(
+                                f"🔊 {idx + 1}",
+                                wav_bytes,
+                                file_name=f"sentence_{idx + 1}.wav",
+                                mime="audio/wav",
+                                key=f"wav_download_{idx}"
+                            )
+                else:
+                    st.info(t("no_audio"))
+
+            # All Trees tab (second)
+            with tabs[1]:
+                st.subheader(f"🌳 {t('all_trees')}")
+                for i, sentence_result in enumerate(result['sentences']):
+                    sent_lang = sentence_result.get('lang', 'he')
+                    st.markdown(f"**{i+1}:** {sentence_result['text']}")
+                    display_sentence_tree(sentence_result['tokens'], i, rtl=(sent_lang == "he"))
+                    if i < len(result['sentences']) - 1:
+                        st.divider()
+
+            # JSON tab (third)
+            with tabs[2]:
+                st.subheader(t("full_json"))
+
+                display_result = json.loads(json.dumps(result))
+                for sent in display_result.get('sentences', []):
+                    if sent.get('audio'):
+                        sent['audio']['data_uri'] = '[truncated]'
+
+                st.download_button(
+                    t("download_json"),
+                    json.dumps(result, ensure_ascii=False, indent=2),
+                    file_name="hebrew_nlp_result.json",
+                    mime="application/json",
+                    width="stretch"
+                )
+
+                st.json(display_result)
+
+            # Sentence tabs
+            for i, sentence_result in enumerate(result['sentences']):
+                with tabs[i + 3]:  # +3 because Speech, All Trees, JSON are first
+                    # Per-sentence direction based on detected lang
+                    sent_lang = sentence_result.get('lang', 'he')
+                    sent_dir = "rtl" if sent_lang == "he" else "ltr"
+                    sent_align = "right" if sent_lang == "he" else "left"
+
+                    st.markdown(f"### {i+1}")
+
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.markdown(f"**{t('original')}**")
+                        st.markdown(f"<div dir='{sent_dir}' style='font-size:1.2em; text-align:{sent_align};'>{sentence_result['text']}</div>",
+                                   unsafe_allow_html=True)
+                    with col2:
+                        st.markdown(f"**{t('nikud')}**")
+                        st.markdown(f"<div dir='{sent_dir}' style='font-size:1.2em; text-align:{sent_align};'>{sentence_result['phonetics']['diacritized']}</div>",
+                                   unsafe_allow_html=True)
+
+                    # Audio above phonemes
+                    if sentence_result.get('audio'):
+                        with st.expander(t("audio"), expanded=True):
+                            st.audio(sentence_result['audio']['data_uri'])
+                            st.caption(f"{t('duration')}: {sentence_result['audio']['duration_ms']:.0f}ms")
+
+                    st.markdown(f"**{t('phonemes')}**")
+                    st.code(sentence_result['phonetics']['phonemes'], language=None)
+
+                    with st.expander(t("dep_tree"), expanded=True):
+                        display_sentence_tree(sentence_result['tokens'], i, rtl=(sent_lang == "he"))
+
+                    with st.expander(t("morphology"), expanded=True):
+                        display_tokens_table(sentence_result['tokens'])
+
+                    with st.expander(t("ner"), expanded=True):
+                        display_ner_entities(sentence_result['ner_entities'])
+
+                    # Sentence JSON
+                    with st.expander(t("sentence_json"), expanded=True):
+                        # Create sentence JSON without audio data
+                        sentence_json = json.loads(json.dumps(sentence_result))
+                        if sentence_json.get('audio'):
+                            sentence_json['audio']['data_uri'] = '[truncated]'
+
+                        st.download_button(
+                            t("download_json"),
+                            json.dumps(sentence_result, ensure_ascii=False, indent=2),
+                            file_name=f"sentence_{i+1}.json",
+                            mime="application/json",
+                            width="stretch",
+                            key=f"dl_json_{i}"
+                        )
+
+                        st.json(sentence_json)
+
+else:
+    st.warning(t("models_not_loaded"))
+    st.code("""
+# Install dependencies:
+pip install pysbd huggingface-hub
+
+# All models are downloaded automatically on first use to ./onnx/:
+# - phonikud-1.0.int8.onnx (from thewh1teagle/phonikud-onnx)
+# - piper-voices/he_IL-phonikud.onnx (from thewh1teagle/phonikud-tts-checkpoints)
+# - piper-voices/en_US-ryan-high.onnx, etc. (from rhasspy/piper-voices)
+# - DictaBERT cached by HuggingFace transformers
+    """, language="bash")
+
+# Footer
+st.divider()
+st.markdown(f"""
+<div style='text-align:center; color:gray; font-size:0.9em;'>
+    v{AsyncHebrewNLP.VERSION} (<a href="https://github.com/CLK-AL/HebrewNLP/blob/main/schema.json">schema</a>) |
+    Async Parallel Pipeline | Cross-Platform |
+    <a href="https://dicta.org.il/">Dicta</a> (<a href="https://huggingface.co/dicta-il/dictabert-joint">DictaBERT</a>) |
+    <a href="https://github.com/thewh1teagle">thewh1teagle</a> (<a href="https://github.com/thewh1teagle/phonikud">Phonikud</a>) |
+    <a href="https://github.com/rhasspy/piper">Piper</a> (<a href="https://huggingface.co/rhasspy/piper-voices">voices</a>) |
+    <a href="https://github.com/nipunsadvilkar/pySBD">pysbd</a>
+</div>
+""", unsafe_allow_html=True)

download_models.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""
+Download all ONNX models for Hebrew Unified NLP
+
+Usage:
+    python download_models.py              # Download all 36 voices
+    python download_models.py --essential  # Download essential only (phonikud + Hebrew + ryan-high)
+"""
+
+import sys
+import shutil
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+
+ONNX_DIR = Path("./onnx")
+PIPER_DIR = ONNX_DIR / "piper-voices"
+
+# All available English voices
+EN_VOICES = {
+    # en_GB
+    "en_GB-alan-low": ("en_GB", "alan", "low"),
+    "en_GB-alan-medium": ("en_GB", "alan", "medium"),
+    "en_GB-alba-medium": ("en_GB", "alba", "medium"),
+    "en_GB-aru-medium": ("en_GB", "aru", "medium"),
+    "en_GB-cori-medium": ("en_GB", "cori", "medium"),
+    "en_GB-cori-high": ("en_GB", "cori", "high"),
+    "en_GB-jenny_dioco-medium": ("en_GB", "jenny_dioco", "medium"),
+    "en_GB-northern_english_male-medium": ("en_GB", "northern_english_male", "medium"),
+    "en_GB-semaine-medium": ("en_GB", "semaine", "medium"),
+    "en_GB-southern_english_female-low": ("en_GB", "southern_english_female", "low"),
+    "en_GB-vctk-medium": ("en_GB", "vctk", "medium"),
+    # en_US
+    "en_US-amy-low": ("en_US", "amy", "low"),
+    "en_US-amy-medium": ("en_US", "amy", "medium"),
+    "en_US-arctic-medium": ("en_US", "arctic", "medium"),
+    "en_US-bryce-medium": ("en_US", "bryce", "medium"),
+    "en_US-danny-low": ("en_US", "danny", "low"),
+    "en_US-hfc_female-medium": ("en_US", "hfc_female", "medium"),
+    "en_US-hfc_male-medium": ("en_US", "hfc_male", "medium"),
+    "en_US-joe-medium": ("en_US", "joe", "medium"),
+    "en_US-john-medium": ("en_US", "john", "medium"),
+    "en_US-kathleen-low": ("en_US", "kathleen", "low"),
+    "en_US-kristin-medium": ("en_US", "kristin", "medium"),
+    "en_US-kusal-medium": ("en_US", "kusal", "medium"),
+    "en_US-l2arctic-medium": ("en_US", "l2arctic", "medium"),
+    "en_US-lessac-high": ("en_US", "lessac", "high"),
+    "en_US-lessac-low": ("en_US", "lessac", "low"),
+    "en_US-lessac-medium": ("en_US", "lessac", "medium"),
+    "en_US-libritts-high": ("en_US", "libritts", "high"),
+    "en_US-libritts_r-medium": ("en_US", "libritts_r", "medium"),
+    "en_US-ljspeech-high": ("en_US", "ljspeech", "high"),
+    "en_US-ljspeech-medium": ("en_US", "ljspeech", "medium"),
+    "en_US-norman-medium": ("en_US", "norman", "medium"),
+    "en_US-ryan-high": ("en_US", "ryan", "high"),
+    "en_US-ryan-low": ("en_US", "ryan", "low"),
+    "en_US-ryan-medium": ("en_US", "ryan", "medium"),
+}
+
+
+def download_file(repo_id: str, filename: str, dest_path: Path):
+    """Download a file from HuggingFace Hub to destination."""
+    if dest_path.exists():
+        print(f"  [skip] {dest_path.name} already exists")
+        return False
+
+    print(f"  [download] {filename}...")
+    downloaded = hf_hub_download(repo_id=repo_id, filename=filename)
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy(downloaded, dest_path)
+    print(f"  [done] {dest_path.name}")
+    return True
+
+
+def download_phonikud():
+    """Download Phonikud ONNX model."""
+    print("\n=== Phonikud Model ===")
+    download_file(
+        "thewh1teagle/phonikud-onnx",
+        "phonikud-1.0.int8.onnx",
+        ONNX_DIR / "phonikud-1.0.int8.onnx"
+    )
+
+
+def download_hebrew_voice():
+    """Download Hebrew Piper voice."""
+    print("\n=== Hebrew Voice (he_IL-phonikud) ===")
+    download_file(
+        "thewh1teagle/phonikud-tts-checkpoints",
+        "model.onnx",
+        PIPER_DIR / "he_IL-phonikud.onnx"
+    )
+    download_file(
+        "thewh1teagle/phonikud-tts-checkpoints",
+        "model.config.json",
+        PIPER_DIR / "he_IL-phonikud.onnx.json"
+    )
+
+
+def download_english_voice(voice_name: str):
+    """Download an English Piper voice."""
+    region, speaker, quality = EN_VOICES[voice_name]
+    subdir = f"en/{region}/{speaker}/{quality}"
+
+    download_file(
+        "rhasspy/piper-voices",
+        f"{subdir}/{voice_name}.onnx",
+        PIPER_DIR / f"{voice_name}.onnx"
+    )
+    download_file(
+        "rhasspy/piper-voices",
+        f"{subdir}/{voice_name}.onnx.json",
+        PIPER_DIR / f"{voice_name}.onnx.json"
+    )
+
+
+def main():
+    essential_only = "--essential" in sys.argv
+
+    print("=" * 50)
+    print("Hebrew Unified NLP - Model Downloader")
+    print("=" * 50)
+
+    # Create directories
+    PIPER_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Essential downloads
+    download_phonikud()
+    download_hebrew_voice()
+
+    print("\n=== English Voice (en_US-ryan-high) ===")
+    download_english_voice("en_US-ryan-high")
+
+    if not essential_only:
+        print("\n=== All English Voices ===")
+        for voice in EN_VOICES:
+            if voice != "en_US-ryan-high":  # Already downloaded
+                print(f"\n  [{voice}]")
+                download_english_voice(voice)
+
+    # Summary
+    print("\n" + "=" * 50)
+    print("Download Complete!")
+    print("=" * 50)
+
+    total_size = sum(f.stat().st_size for f in ONNX_DIR.rglob("*") if f.is_file())
+    print(f"\nLocation: {ONNX_DIR.absolute()}")
+    print(f"Total size: {total_size / 1024 / 1024:.1f} MB")
+
+    files = list(PIPER_DIR.glob("*.onnx"))
+    print(f"Voices: {len(files)} ({len(files) - 1} English + 1 Hebrew)")
+
+
+if __name__ == "__main__":
+    main()

model.config.json

@@ -1,497 +0,0 @@
-{
-    "dataset": "",
-    "audio": {
-        "sample_rate": 22050,
-        "quality": "train"
-    },
-    "espeak": {
-        "voice": "he"
-    },
-    "language": {
-        "code": "he"
-    },
-    "inference": {
-        "noise_scale": 0.667,
-        "length_scale": 1,
-        "noise_w": 0.8
-    },
-    "phoneme_type": "raw",
-    "phoneme_map": {},
-    "phoneme_id_map": {
-        " ": [
-            3
-        ],
-        "!": [
-            4
-        ],
-        "\"": [
-            150
-        ],
-        "#": [
-            149
-        ],
-        "$": [
-            2
-        ],
-        "'": [
-            5
-        ],
-        "(": [
-            6
-        ],
-        ")": [
-            7
-        ],
-        ",": [
-            8
-        ],
-        "-": [
-            9
-        ],
-        ".": [
-            10
-        ],
-        "0": [
-            130
-        ],
-        "1": [
-            131
-        ],
-        "2": [
-            132
-        ],
-        "3": [
-            133
-        ],
-        "4": [
-            134
-        ],
-        "5": [
-            135
-        ],
-        "6": [
-            136
-        ],
-        "7": [
-            137
-        ],
-        "8": [
-            138
-        ],
-        "9": [
-            139
-        ],
-        ":": [
-            11
-        ],
-        ";": [
-            12
-        ],
-        "?": [
-            13
-        ],
-        "X": [
-            156
-        ],
-        "^": [
-            1
-        ],
-        "_": [
-            0
-        ],
-        "a": [
-            14
-        ],
-        "b": [
-            15
-        ],
-        "c": [
-            16
-        ],
-        "d": [
-            17
-        ],
-        "e": [
-            18
-        ],
-        "f": [
-            19
-        ],
-        "g": [
-            154
-        ],
-        "h": [
-            20
-        ],
-        "i": [
-            21
-        ],
-        "j": [
-            22
-        ],
-        "k": [
-            23
-        ],
-        "l": [
-            24
-        ],
-        "m": [
-            25
-        ],
-        "n": [
-            26
-        ],
-        "o": [
-            27
-        ],
-        "p": [
-            28
-        ],
-        "q": [
-            29
-        ],
-        "r": [
-            30
-        ],
-        "s": [
-            31
-        ],
-        "t": [
-            32
-        ],
-        "u": [
-            33
-        ],
-        "v": [
-            34
-        ],
-        "w": [
-            35
-        ],
-        "x": [
-            36
-        ],
-        "y": [
-            37
-        ],
-        "z": [
-            38
-        ],
-        "æ": [
-            39
-        ],
-        "ç": [
-            40
-        ],
-        "ð": [
-            41
-        ],
-        "ø": [
-            42
-        ],
-        "ħ": [
-            43
-        ],
-        "ŋ": [
-            44
-        ],
-        "œ": [
-            45
-        ],
-        "ǀ": [
-            46
-        ],
-        "ǁ": [
-            47
-        ],
-        "ǂ": [
-            48
-        ],
-        "ǃ": [
-            49
-        ],
-        "ɐ": [
-            50
-        ],
-        "ɑ": [
-            51
-        ],
-        "ɒ": [
-            52
-        ],
-        "ɓ": [
-            53
-        ],
-        "ɔ": [
-            54
-        ],
-        "ɕ": [
-            55
-        ],
-        "ɖ": [
-            56
-        ],
-        "ɗ": [
-            57
-        ],
-        "ɘ": [
-            58
-        ],
-        "ə": [
-            59
-        ],
-        "ɚ": [
-            60
-        ],
-        "ɛ": [
-            61
-        ],
-        "ɜ": [
-            62
-        ],
-        "ɞ": [
-            63
-        ],
-        "ɟ": [
-            64
-        ],
-        "ɠ": [
-            65
-        ],
-        "ɡ": [
-            66
-        ],
-        "ɢ": [
-            67
-        ],
-        "ɣ": [
-            68
-        ],
-        "ɤ": [
-            69
-        ],
-        "ɥ": [
-            70
-        ],
-        "ɦ": [
-            71
-        ],
-        "ɧ": [
-            72
-        ],
-        "ɨ": [
-            73
-        ],
-        "ɪ": [
-            74
-        ],
-        "ɫ": [
-            75
-        ],
-        "ɬ": [
-            76
-        ],
-        "ɭ": [
-            77
-        ],
-        "ɮ": [
-            78
-        ],
-        "ɯ": [
-            79
-        ],
-        "ɰ": [
-            80
-        ],
-        "ɱ": [
-            81
-        ],
-        "ɲ": [
-            82
-        ],
-        "ɳ": [
-            83
-        ],
-        "ɴ": [
-            84
-        ],
-        "ɵ": [
-            85
-        ],
-        "ɶ": [
-            86
-        ],
-        "ɸ": [
-            87
-        ],
-        "ɹ": [
-            88
-        ],
-        "ɺ": [
-            89
-        ],
-        "ɻ": [
-            90
-        ],
-        "ɽ": [
-            91
-        ],
-        "ɾ": [
-            92
-        ],
-        "ʀ": [
-            93
-        ],
-        "ʁ": [
-            94
-        ],
-        "ʂ": [
-            95
-        ],
-        "ʃ": [
-            96
-        ],
-        "ʄ": [
-            97
-        ],
-        "ʈ": [
-            98
-        ],
-        "ʉ": [
-            99
-        ],
-        "ʊ": [
-            100
-        ],
-        "ʋ": [
-            101
-        ],
-        "ʌ": [
-            102
-        ],
-        "ʍ": [
-            103
-        ],
-        "ʎ": [
-            104
-        ],
-        "ʏ": [
-            105
-        ],
-        "ʐ": [
-            106
-        ],
-        "ʑ": [
-            107
-        ],
-        "ʒ": [
-            108
-        ],
-        "ʔ": [
-            109
-        ],
-        "ʕ": [
-            110
-        ],
-        "ʘ": [
-            111
-        ],
-        "ʙ": [
-            112
-        ],
-        "ʛ": [
-            113
-        ],
-        "ʜ": [
-            114
-        ],
-        "ʝ": [
-            115
-        ],
-        "ʟ": [
-            116
-        ],
-        "ʡ": [
-            117
-        ],
-        "ʢ": [
-            118
-        ],
-        "ʦ": [
-            155
-        ],
-        "ʰ": [
-            145
-        ],
-        "ʲ": [
-            119
-        ],
-        "ˈ": [
-            120
-        ],
-        "ˌ": [
-            121
-        ],
-        "ː": [
-            122
-        ],
-        "ˑ": [
-            123
-        ],
-        "˞": [
-            124
-        ],
-        "ˤ": [
-            146
-        ],
-        "̃": [
-            141
-        ],
-        "̧": [
-            140
-        ],
-        "̩": [
-            144
-        ],
-        "̪": [
-            142
-        ],
-        "̯": [
-            143
-        ],
-        "̺": [
-            152
-        ],
-        "̻": [
-            153
-        ],
-        "β": [
-            125
-        ],
-        "ε": [
-            147
-        ],
-        "θ": [
-            126
-        ],
-        "χ": [
-            127
-        ],
-        "ᵻ": [
-            128
-        ],
-        "↑": [
-            151
-        ],
-        "↓": [
-            148
-        ],
-        "ⱱ": [
-            129
-        ]
-    },
-    "num_symbols": 256,
-    "num_speakers": 1,
-    "speaker_id_map": {},
-    "piper_version": "1.0.0"
-}

model.onnx

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

packages.txt

@@ -0,0 +1,3 @@
+graphviz
+libsndfile1
+espeak-ng

phonikud-1.0.int8.onnx

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

pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "hebrew-unified-nlp"
+version = "2.0.0"
+description = "Async parallel Hebrew NLP combining Phonikud TTS + DictaBERT-Joint"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10,<3.13"
+authors = [
+    { name = "TomAR" }
+]
+keywords = ["hebrew", "nlp", "tts", "phonikud", "dictabert", "morphology", "syntax"]
+
+dependencies = [
+    "phonikud-tts>=0.1.0",
+    "transformers>=4.40.0",
+    "torch>=2.0.0",
+    "streamlit>=1.40.0",
+    "graphviz>=0.20.0",
+    "arabic-reshaper>=3.0.0",
+    "python-bidi>=0.6.0",
+    "pysbd>=0.3.4",
+    "soundfile>=0.13.0",
+]
+
+[project.optional-dependencies]
+icu = ["PyICU>=2.12"]
+neural = ["wtpsplit>=2.0.0"]
+
+[project.urls]
+Homepage = "https://huggingface.co/spaces/YOUR_USERNAME/hebrew-unified-nlp"
+Repository = "https://github.com/YOUR_USERNAME/hebrew-unified-nlp"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

requirements.txt

@@ -1,5 +1,8 @@
 # This file was autogenerated by uv via the following command:
 #    uv export --no-hashes --no-emit-project
+#
+# IMPORTANT: Requires Python 3.10-3.12 (phonikud doesn't support 3.13 yet)
+#
 attrs==25.3.0
     # via
     #   csvw
@@ -74,10 +77,10 @@ packaging==25.0
     #   onnxruntime
 phonemizer-fork==3.3.2
     # via piper-onnx
-phonikud @ git+https://github.com/thewh1teagle/phonikud@23d3b887f1665ae831ec476be71573a9ca4a61c6
-    # via phonikud-tts
+# phonikud is installed via phonikud-tts
 phonikud-onnx==1.0.6
     # via phonikud-tts
+phonikud-tts>=0.1.0
 piper-onnx==1.0.6
     # via phonikud-tts
 protobuf==6.32.1
@@ -137,4 +140,27 @@ uritemplate==4.2.0
     # via csvw
 urllib3==2.5.0
     # via requests
-flask>=3.1.1
+
+# Web framework
+streamlit>=1.40.0
+
+# DictaBERT dependencies
+transformers>=4.40.0
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch>=2.0.0
+
+# Visualization
+graphviz>=0.20.0
+
+# RTL text handling
+arabic_reshaper>=3.0.0
+python-bidi>=0.6.0
+
+# Sentence breaking (choose one - pysbd recommended for cross-platform)
+pysbd>=0.3.4
+
+# Optional: ICU CLDR sentence breaking (Linux/Mac only, requires libicu-dev)
+# PyICU>=2.12
+
+# Optional: Neural sentence splitter
+# wtpsplit>=2.0.0

schema.json

@@ -0,0 +1,483 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/hebrew-unified-nlp/schema/v2.1.0",
+  "title": "HebrewUnifiedNLPResult",
+  "description": "Async parallel Hebrew/English NLP with cross-platform sentence breaking - outputs sentence array with per-sentence language detection",
+  "type": "object",
+  "required": [
+    "meta",
+    "input",
+    "sentences"
+  ],
+  "properties": {
+    "meta": {
+      "type": "object",
+      "description": "Processing metadata",
+      "required": [
+        "version",
+        "timestamp",
+        "sentence_count"
+      ],
+      "properties": {
+        "version": {
+          "type": "string",
+          "pattern": "^\\d+\\.\\d+\\.\\d+$",
+          "example": "2025.12.5"
+        },
+        "timestamp": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "models": {
+          "type": "object",
+          "properties": {
+            "phonikud": {
+              "type": "string",
+              "description": "Phonikud model name"
+            },
+            "piper": {
+              "type": "string",
+              "description": "Piper voice manager info"
+            },
+            "dictabert": {
+              "type": "string",
+              "description": "DictaBERT model path"
+            }
+          }
+        },
+        "processing_time_ms": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Total processing time for all sentences"
+        },
+        "sentence_count": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Number of sentences detected"
+        },
+        "parallel_workers": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Number of parallel workers used"
+        },
+        "sentence_breaker": {
+          "type": "string",
+          "description": "Sentence breaking backend used",
+          "enum": [
+            "pysbd",
+            "pysbd-en",
+            "icu",
+            "wtpsplit",
+            "regex"
+          ]
+        }
+      }
+    },
+    "translations": {
+      "type": "object",
+      "description": "Bilingual label translations (Hebrew/English)",
+      "properties": {
+        "pos": {
+          "type": "object",
+          "description": "Part-of-speech translations",
+          "additionalProperties": {
+            "$ref": "#/definitions/BilingualLabel"
+          }
+        },
+        "dep": {
+          "type": "object",
+          "description": "Dependency relation translations",
+          "additionalProperties": {
+            "$ref": "#/definitions/BilingualLabel"
+          }
+        },
+        "ner": {
+          "type": "object",
+          "description": "Named entity type translations",
+          "additionalProperties": {
+            "$ref": "#/definitions/BilingualLabel"
+          }
+        },
+        "prefix": {
+          "type": "object",
+          "description": "Prefix type translations",
+          "additionalProperties": {
+            "$ref": "#/definitions/BilingualLabel"
+          }
+        },
+        "special": {
+          "type": "object",
+          "description": "Special token translations",
+          "additionalProperties": {
+            "$ref": "#/definitions/BilingualLabel"
+          }
+        },
+        "morph": {
+          "type": "object",
+          "description": "Morphological feature value translations",
+          "additionalProperties": {
+            "$ref": "#/definitions/BilingualLabel"
+          }
+        }
+      }
+    },
+    "input": {
+      "type": "object",
+      "required": [
+        "text"
+      ],
+      "properties": {
+        "text": {
+          "type": "string",
+          "description": "Original input text (may contain multiple sentences)"
+        },
+        "language": {
+          "type": "string",
+          "description": "Primary input language",
+          "enum": [
+            "he",
+            "en"
+          ]
+        }
+      }
+    },
+    "sentences": {
+      "type": "array",
+      "description": "Array of sentence analysis results (parallel processed)",
+      "items": {
+        "$ref": "#/definitions/SentenceResult"
+      }
+    }
+  },
+  "definitions": {
+    "BilingualLabel": {
+      "type": "object",
+      "description": "Label with Hebrew and English translations",
+      "properties": {
+        "en": {
+          "type": "string"
+        },
+        "he": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "en",
+        "he"
+      ]
+    },
+    "SentenceResult": {
+      "type": "object",
+      "description": "Analysis result for a single sentence",
+      "required": [
+        "index",
+        "lang",
+        "text",
+        "phonetics",
+        "tokens"
+      ],
+      "properties": {
+        "index": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Sentence index in original text"
+        },
+        "lang": {
+          "type": "string",
+          "enum": [
+            "he",
+            "en"
+          ],
+          "description": "Detected language for this sentence"
+        },
+        "text": {
+          "type": "string",
+          "description": "Original sentence text"
+        },
+        "phonetics": {
+          "$ref": "#/definitions/Phonetics"
+        },
+        "tokens": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Token"
+          }
+        },
+        "ner_entities": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/NEREntity"
+          }
+        },
+        "speech": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/Speech"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "tree_svg": {
+          "type": "string",
+          "description": "SVG string of dependency tree visualization"
+        }
+      }
+    },
+    "Phonetics": {
+      "type": "object",
+      "description": "Phonikud output for sentence (Hebrew) or passthrough (English)",
+      "required": [
+        "diacritized",
+        "phonemes"
+      ],
+      "properties": {
+        "diacritized": {
+          "type": "string",
+          "description": "Sentence with nikud (Hebrew) or original text (English)"
+        },
+        "phonemes": {
+          "type": "string",
+          "description": "Phoneme sequence (Hebrew) or empty string (English)"
+        }
+      }
+    },
+    "Token": {
+      "type": "object",
+      "description": "Unified token: DictaBERT + Phonikud enrichment",
+      "required": [
+        "id",
+        "token"
+      ],
+      "properties": {
+        "id": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "1-indexed token position within sentence"
+        },
+        "token": {
+          "type": "string",
+          "description": "Surface form (DictaBERT)"
+        },
+        "nikud": {
+          "type": "string",
+          "description": "Diacritized form (Phonikud for Hebrew, original for English)"
+        },
+        "phonemes": {
+          "type": "string",
+          "description": "Token phonemes (Hebrew) or empty (English)"
+        },
+        "seg": {
+          "type": "array",
+          "description": "Morphological segmentation (DictaBERT)",
+          "items": {
+            "type": "string"
+          }
+        },
+        "lex": {
+          "type": "string",
+          "description": "Lemma (DictaBERT)"
+        },
+        "offsets": {
+          "type": "object",
+          "properties": {
+            "start": {
+              "type": "integer"
+            },
+            "end": {
+              "type": "integer"
+            }
+          }
+        },
+        "morph": {
+          "$ref": "#/definitions/Morphology"
+        },
+        "syntax": {
+          "$ref": "#/definitions/Syntax"
+        }
+      }
+    },
+    "Morphology": {
+      "type": "object",
+      "description": "DictaBERT morphological analysis",
+      "properties": {
+        "token": {
+          "type": "string"
+        },
+        "pos": {
+          "type": "string",
+          "enum": [
+            "ADJ",
+            "ADP",
+            "ADV",
+            "AUX",
+            "CCONJ",
+            "DET",
+            "INTJ",
+            "NOUN",
+            "NUM",
+            "PART",
+            "PRON",
+            "PROPN",
+            "PUNCT",
+            "SCONJ",
+            "SYM",
+            "VERB",
+            "X"
+          ]
+        },
+        "feats": {
+          "type": "object",
+          "properties": {
+            "Gender": {
+              "type": "string",
+              "enum": [
+                "Masc",
+                "Fem"
+              ]
+            },
+            "Number": {
+              "type": "string",
+              "enum": [
+                "Sing",
+                "Plur",
+                "Dual"
+              ]
+            },
+            "Person": {
+              "type": "string",
+              "enum": [
+                "1",
+                "2",
+                "3"
+              ]
+            },
+            "Tense": {
+              "type": "string",
+              "enum": [
+                "Past",
+                "Present",
+                "Future",
+                "Imp",
+                "Inf"
+              ]
+            },
+            "Voice": {
+              "type": "string",
+              "enum": [
+                "Act",
+                "Pass"
+              ]
+            },
+            "Definite": {
+              "type": "string",
+              "enum": [
+                "Def",
+                "Ind"
+              ]
+            },
+            "Case": {
+              "type": "string",
+              "enum": [
+                "Nom",
+                "Acc",
+                "Gen"
+              ]
+            },
+            "Construct": {
+              "type": "string",
+              "enum": [
+                "Construct",
+                "Free"
+              ]
+            }
+          },
+          "additionalProperties": true
+        },
+        "prefixes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "suffix": {
+          "type": "boolean"
+        }
+      }
+    },
+    "Syntax": {
+      "type": "object",
+      "description": "DictaBERT dependency syntax",
+      "properties": {
+        "word": {
+          "type": "string"
+        },
+        "dep_head_idx": {
+          "type": "integer",
+          "minimum": -1,
+          "description": "-1 for root"
+        },
+        "dep_func": {
+          "type": "string"
+        },
+        "dep_head": {
+          "type": "string"
+        }
+      }
+    },
+    "NEREntity": {
+      "type": "object",
+      "properties": {
+        "phrase": {
+          "type": "string",
+          "description": "Entity text"
+        },
+        "label": {
+          "type": "string",
+          "enum": [
+            "PER",
+            "LOC",
+            "GPE",
+            "ORG",
+            "TIME",
+            "DATE",
+            "MISC",
+            "MONEY",
+            "PERCENT"
+          ]
+        },
+        "start": {
+          "type": "integer"
+        },
+        "end": {
+          "type": "integer"
+        }
+      }
+    },
+    "Speech": {
+      "type": "object",
+      "description": "TTS audio for sentence",
+      "properties": {
+        "format": {
+          "type": "string",
+          "enum": [
+            "wav",
+            "mp3",
+            "ogg"
+          ]
+        },
+        "sample_rate": {
+          "type": "integer"
+        },
+        "duration_ms": {
+          "type": "number"
+        },
+        "data_uri": {
+          "type": "string",
+          "description": "Base64 data URI (data:audio/wav;base64,...)"
+        }
+      }
+    }
+  }
+}