CohereX

Speech transcription with word-level timestamps and speaker diarization, built on the Cohere Transcribe ASR model.

Cohere Transcribe produces accurate text but no timestamps, no speaker labels, and no language detection. CohereX adds those around it, reusing the WhisperX pipeline design.

Features

• Word-level timestamps from wav2vec2 forced alignment
• Speaker labels per word and segment (pyannote diarization)
• Voice activity detection (pyannote or silero) that drops silence before transcription
• 14 languages, with optional automatic detection
• Output as SRT, VTT, TXT, TSV, or JSON
• Runs the model in-process or offloads it to a vLLM server

Pipeline:

audio → VAD → Cohere Transcribe → wav2vec2 forced alignment → diarization → subtitles

Requirements

• Python 3.10–3.13
• FFmpeg on your PATH (used for audio decoding)
• A Hugging Face account with access to the gated models:
  • CohereLabs/cohere-transcribe-03-2026
  • CohereLabs/cohere-transcribe-arabic-07-2026 (only if you use the Arabic/English finetuned model)
  • pyannote/speaker-diarization-community-1 (only if you use --diarize)

Accept the model terms on their Hugging Face pages, then log in:

hf auth login

Install

pip install coherex

For automatic language detection, include the optional extra:

pip install "coherex[langid]"

To enable everything (language detection and the vLLM backend), use:

pip install "coherex[all]"

To work from source instead:

git clone https://github.com/bakrianoo/cohereX.git
cd cohereX
pip install -e .

GPU is strongly recommended. On CPU the model runs but is slow.

Quick start

Transcribe a file and write all output formats to out/:

coherex audio.mp3 --language en -o out/

Add speaker labels:

coherex audio.mp3 --language en --diarize -o out/

Let CohereX detect the language (needs the langid extra):

coherex audio.mp3 --language auto -o out/

Produce only an SRT with two lines per cue:

coherex audio.mp3 --language en -f srt --max_line_width 42 --max_line_count 2 -o out/

--language is required. Cohere Transcribe has no built-in language detection, and passing the wrong language produces a fluent but wrong transcription rather than an error. Use auto if you are unsure.

Supported languages

en, fr, de, es, it, pt, nl, pl, el, ar, ja, zh, vi, ko.

Automatic detection (--language auto) chooses from this set only.

Models

By default CohereX uses CohereLabs/cohere-transcribe-03-2026 (14 languages). Pass --model to use a different Cohere ASR model.

For Arabic, English, and Arabic-English code-switched audio, the finetuned CohereLabs/cohere-transcribe-arabic-07-2026 is more accurate:

coherex audio.mp3 --model CohereLabs/cohere-transcribe-arabic-07-2026 --language ar -o out/

CohereX reads the supported languages from the model itself, so --language is validated against whatever the chosen model accepts (en, ar for the Arabic model), and --language auto only probes those.

Serving with vLLM

By default the ASR model runs in-process (--backend local). For higher throughput you can run transcription on a vLLM server instead (pip install "coherex[vllm]"). Alignment and diarization still run locally either way.

Point CohereX at a server you already run:

coherex audio.mp3 --language en --backend vllm --vllm_url http://localhost:8000

Or let CohereX start its own vLLM server and shut it down automatically when the run finishes:

coherex audio.mp3 --language en --backend vllm

Add --vllm_api_key if the server requires one, and --vllm_args to pass extra vllm serve flags (e.g. --vllm_args "--gpu-memory-utilization 0.8").

Common options

Run coherex --help for the full list.

Python API

import coherex

model = coherex.load_model(device="cuda", compute_type="bfloat16", vad_method="pyannote")

# 1. Transcribe (segment-level timestamps from VAD)
result = model.transcribe("audio.mp3", language="en", batch_size=8)

# 2. Word-level timestamps
align_model, metadata = coherex.load_align_model("en", device="cuda")
result = coherex.align(result["segments"], align_model, metadata, "audio.mp3", "cuda")

# 3. Speaker labels
from coherex.diarize import DiarizationPipeline
diarizer = DiarizationPipeline(device="cuda")
speakers = diarizer("audio.mp3")
result = coherex.assign_word_speakers(speakers, result)

for seg in result["segments"]:
    print(seg["start"], seg["end"], seg.get("speaker"), seg["text"])

To detect the language from audio:

model = coherex.load_model(device="cuda")
language = coherex.detect_language(model, "audio.mp3")
result = model.transcribe("audio.mp3", language=language)

Output

JSON contains segments and a flat word_segments list, each word carrying start, end, score, and (with --diarize) speaker:

{
  "segments": [
    {
      "start": 0.83,
      "end": 6.33,
      "text": "This week, I traveled to Chicago...",
      "speaker": "SPEAKER_00",
      "words": [
        {"word": "This", "start": 0.83, "end": 1.01, "score": 0.98, "speaker": "SPEAKER_00"}
      ]
    }
  ],
  "word_segments": [
    {"word": "This", "start": 0.83, "end": 1.01, "score": 0.98, "speaker": "SPEAKER_00"}
  ],
  "language": "en"
}

Notes and limitations

• Language is required. There is no reliable failure mode for the wrong language — the model will transcribe confidently in whatever language you specify.
• VAD matters. Cohere Transcribe transcribes non-speech audio as hallucinated text, so the VAD step is on by default and should stay on for noisy input.
• 14 languages only, listed above.
• Alignment coverage. Word timestamps come from a per-language wav2vec2 model. If none is available for a language, run with --no_align to get segment-level timestamps instead.
• auto detection cost. It probes the model once per candidate language, so it is slower than passing a code directly. Prefer an explicit --language when you know it.

How it fits together

Only the ASR-specific pieces are unique to CohereX:

• asr.py — loads Cohere Transcribe and transcribes VAD chunks.
• transcribe.py — the end-to-end pipeline.
• langid.py — optional language detection.
• __main__.py — the command-line interface.

Alignment (alignment.py), diarization (diarize.py), VAD (vads/), subtitle formatting (SubtitlesProcessor.py), and the output writers (utils.py) follow WhisperX.

Credits

• Cohere Transcribe — the ASR model.
• WhisperX — the pipeline design and the alignment, diarization, VAD, and subtitle components.
• pyannote.audio — VAD and diarization.

License

Apache 2.0.