Skip to main content
Glama
loudreader

mcp-loudkit

Official
by loudreader
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

loudkit

Text-to-speech that runs on your own hardware.

CI License Model Model Spaces Open in Colab loudkit MCP server score on Glama

loudkit has 28 voices in ten languages, clones a voice from about ten seconds of audio, and has native SDKs for Python, Swift, Go, Rust and TypeScript. After the first model download it runs offline. It needs no account, sends no telemetry and has no usage fees.

LoudReader, a reading app, uses loudkit as its speech engine. loudkit is licensed under Apache-2.0.

Hear the voices | Try the online demo | Open in Colab | Model | Documentation

Quickstart

pip install "loudkit[torch,audio,hub]"
loudkit speak --voice joe "Hello from loudkit." --play

The first run downloads the 747 MB model and the 28 voices. After that, it runs offline. speak writes out.wav by default, and --play plays it with the system player. Use -o hello.wav to choose the file name. Other English voices work the same way, for example --voice kathleen or --voice henry. A voice reads text in its own language unless you pass --language.

Related MCP server: mcp-ai-voice

Python

import loudkit as lk

engine = lk.load("loudreader/loudr-1")
voice = engine.voice("joe")

engine.synthesize("Hello from loudkit.", voice, seed=7).save("hello.wav")

engine.voices() lists the 28 names. All 28 voices are in both model downloads and load by name. synthesize splits long text into chunks and returns one waveform. engine.stream(...) yields the same audio chunk by chunk, so playback can start early.

Read Getting started next.

Swift, Go, Rust and TypeScript

Each port loads the model by name. The first call downloads and verifies it, and later calls run offline. The snippets need version 0.1.1 of each package.

Swift (CoreML, macOS 14 or iOS 17). Add .package(url: "https://github.com/loudreader/loudkit", from: "0.1.1") to Package.swift. Guide.

import LoudKit

let engine = try await Engine.load("loudreader/loudr-1")
let voice = try engine.voice(named: "joe")
try engine.synthesize("Hello from loudkit.", voice: voice, seed: 7).saveWav("hello.wav")

Go (ONNX Runtime). go get github.com/loudreader/loudkit/go@v0.1.1. Guide.

eng, err := loudkit.Load("loudreader/loudr-1")
if err != nil { log.Fatal(err) }
defer eng.Close()
v, err := eng.Voice("joe")
if err != nil { log.Fatal(err) }
res, err := eng.Synthesize("Hello from loudkit.", v, loudkit.Options{Seed: 7})
if err != nil { log.Fatal(err) }
if err := res.SaveWav("hello.wav"); err != nil { log.Fatal(err) }

Rust (ONNX Runtime). cargo add loudkit@0.1.1. Guide.

use loudkit::{Engine, Options};

let mut engine = Engine::load("loudreader/loudr-1")?;
let voice = engine.voice("joe")?;
let options = Options { seed: 7, ..Default::default() };
engine.synthesize("Hello from loudkit.", &voice, &options)?.save_wav("hello.wav")?;

TypeScript (ONNX Runtime, Node 20). npm install loudkit@0.1.1. Guide.

import { Engine } from "loudkit";

const engine = await Engine.load("loudreader/loudr-1");
const voice = engine.voice("joe");
(await engine.synthesize("Hello from loudkit.", voice, { seed: 7 })).saveWav("hello.wav");
await engine.close();

Go and Rust need libonnxruntime on the machine (brew install onnxruntime, or a build from the ONNX Runtime releases); the guides say where each port looks for it. All five implementations pass the same conformance fixture. The identity contract states where their speech tokens match and where they can differ.

Two models

loudreader/loudr-1 is the default. loudreader/loudr-1-turbo is faster and sounds slightly less natural. Both run on every backend and in all five SDKs. Select the model with the string you pass to load. See Choosing a model.

Voices

The voice gallery plays all 28 voices next to the recording each was enrolled from. The ten languages are English, Spanish, French, German, Italian, Polish, Portuguese, Dutch, Swedish and Danish. English has ten voices, and each other language has two. VOICES.md records the source, licence and consent basis of each voice. The voices come from recordings donated for speech technology, or from CC0 and CC-BY corpora.

Only English has been evaluated by ear. The other nine languages have automated checks but no native-speaker review. If you speak one of them, please listen and report what sounds wrong.

Clone a voice

Use five to ten seconds of one speaker, from a recording you own or have permission to use:

pip install "loudkit[torch,audio,enroll,hub]"
loudkit clone my-recording.wav --checkpoint loudreader/loudr-1 --name my-voice --language en
loudkit speak --voice voices/my-voice.safetensors "Now in a cloned voice." -o cloned.wav

The result is a portable voice profile of about 150 KB. By default, loudkit clone cuts the recording at a pause and pads its end with silence. lk.enroll(...) in Python and enroll in each port keep the recording as given. To get the loudkit clone result from Python, pass end_in_silence=True to lk.enroll. See Cloning a voice and Responsible use.

Measured speed

path

hardware

loudr-1

loudr-1-turbo

split PyTorch engine*

Apple M3 Pro

3.29x

5.77x

Swift, native generator plus CoreML renderer

Apple M3 Pro

2.49x

3.44x

ONNX Runtime, CPU provider

Apple M3 Pro

1.14x

1.59x

PyTorch with CUDA graphs

RTX 3090

8.55x

13.05x

PyTorch with CUDA graphs

Jetson Orin Nano Super, 25 W

1.85x

2.50x

* "Split" is a device placement of the same model. The token generator runs on the CPU, and the renderer (mel decoder and vocoder) runs on the Apple GPU through MPS. Adjacent windows can overlap across the two devices.

Higher is faster, and 1.0x is real time. Every row was measured on 0.1.1 on 2026-09-06, for both models, with the same passage, voice and seed. The Apple rows come from one M3 Pro laptop in ordinary use, with no isolation from background load. The A100, L4 and T4 rows are on the benchmark page.

For batched workloads, the token generator reaches 16.7x aggregate throughput at batch 1 and 57.3x at batch 64 on the RTX 3090 with loudr-1, and 42.0x to 155.0x with loudr-1-turbo. The highest measured result is 223.6x, turbo on an A100 at batch 64 (85.3x with loudr-1), measured on 0.1.1. These figures come from research/bench_batch.py, which replays a recorded token sequence through the token generator. Sampling, prefill and rendering are outside the timed loop, so the figures are neither single-request latency nor end-to-end RTF. Full commands, hardware and caveats are in Benchmarks.

Integrations

These keep one loaded engine across many requests. The contracts are in Server and agents.

  • loudkit serve: an HTTP server with loudkit's own routes, Server-Sent Events streaming on /v1/synthesize/stream, and an OpenAI-compatible /v1/audio/speech that returns the whole utterance in one response. Agents that use OpenAI's speech API, such as Hermes Agent and OpenClaw, connect with configuration only.

  • loudkit serve --grpc: the same engine behind a typed schema with backpressure.

  • loudkit serve --mcp: an MCP server on stdio for agent hosts (preview).

  • A Speech Dispatcher module for Linux screen readers, in integrations/.

  • Docker images and compose for the server.

By default, a WAV saved from Python and a WAV reply from the server carry an unsigned, machine-readable note on how the audio was made. The note names the model, voice, seed and backend, and holds a checksum of the audio. loudkit verify reads it. The Go, Rust, JS and Swift ports write plain PCM without the note. The note is not C2PA: nothing signs it, and C2PA tools do not read it.

Scope

loudkit is an inference toolkit. It does not provide accounts, billing, multi-tenancy, model training or emotion control. For a public deployment, put your own authentication, rate limits and TLS in front of the server. The maintainers close issues and pull requests that ask for help with undisclosed impersonation, bypassing voice authentication, or stripping the note from generated audio. SUPPORTED.md lists what is supported.

Documentation

The documentation index lists the user guides: getting started (Python), one guide per port, choosing a model, cloning, long text and streaming, servers, troubleshooting and the two model cards. It also links the reference, platform and design pages. The model card covers lineage, limits and what each download contains.

Licence

The code and the loudr-1 and loudr-1-turbo releases are Apache-2.0. The tokenizer and speaker encoder keep their upstream MIT licence from Chatterbox. NOTICE lists every upstream component and licence.

Available Tools

3 tools
describeDescribe the engineA

The resolved algorithm and execution configuration. Log this whenever a synthesis surprises you: it is the line that tells you which mode was active.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It discloses that the tool returns the resolved algorithm and execution configuration, and frames it as a read-only diagnostic action ('Log this'). However, it doesn't describe what the output schema contains or any side effects, though the output schema exists and may cover return values.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core purpose, and the usage guidance is embedded efficiently. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter diagnostic tool with an output schema, the description is largely complete. It explains what the tool returns and when to use it. It could be slightly stronger by noting that it's read-only or non-mutating, but the absence of parameters and the diagnostic framing make that less critical.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, so there is no parameter semantics burden. The description adds meaning by explaining what the tool reports (resolved algorithm and execution configuration), which is useful context beyond the empty schema. Baseline 4 for 0 params is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Log this') and resource ('resolved algorithm and execution configuration'), and distinguishes it from siblings by framing it as a diagnostic/observability tool rather than a synthesis or voice-listing tool. It's not a perfect 5 because it doesn't explicitly name the sibling it is not, but the intent is clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit guidance on when to use it: 'Log this whenever a synthesis surprises you.' This is a clear context signal. It doesn't explicitly say when not to use it or name alternatives, but the sibling context (list_voices, synthesize) makes the usage boundary reasonably clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_voicesList voicesA

Names of every voice profile the server can speak in.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only states the functional purpose and does not mention that the operation is read-only, requires no authentication, has no side effects, or any potential rate limits. For a listing tool, the absence of such context is a notable gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, tightly worded sentence with no extraneous content. It is front-loaded with the core function, achieving maximum brevity without sacrificing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless tool with an output schema, the description is largely complete for invocation purposes. The output schema presumably details the return format, and the description covers the what and scope. However, it lacks usage routing context, which is more appropriately addressed under usage guidelines, so this dimension is adequately covered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the input schema is empty. With no parameters to document, the description cannot add meaning beyond the schema, warranting the baseline score of 4. There is nothing to compensate for because there are no parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Names of every voice profile the server can speak in' clearly identifies the tool as a listing operation for voice profiles. The resource and scope are explicit, and it distinguishes itself from siblings 'synthesize' and 'describe' by its focus on enumeration rather than generation or analysis.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its siblings. It does not mention that it should be called before 'synthesize' to select a voice, nor does it state any exclusions or conditions. An agent receives no strategic context for choosing this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

synthesizeSynthesize speechA

Turn text into speech in a named voice. Returns the audio as base64 plus the audio duration and token count. format is "wav" by default; "flac" is the same samples, losslessly, at about a quarter the size: worth asking for when the reply is saved to a file rather than played. "mp3" and "opus" are lossy and smaller still, for a reply sent on to a chat or a phone. Same text, voice and seed give the same audio, and the same bytes in every format but ogg and opus, whose container carries a random stream serial. Omit language to read the text in the voice's own language; pass one only to read text in a language the voice was not enrolled in. speed is playback speed in [0.5, 2.0] with the pitch preserved: 1.0, the default, is an exact bypass. To read a long text as several calls without an audible restart at each join, pass the previous reply's continuation list back as previous_tokens. Check truncated: when true the utterance hit the token cap and the speech is cut off mid-sentence. A refusal comes back as error with error_kind "bad_request": something about this call to fix, and supported or available listing what would have worked, and code from the same frozen catalog the HTTP and gRPC doors name the condition with.

ParametersJSON Schema
NameRequiredDescriptionDefault
seedNo
textYes
speedNo
voiceYes
formatNowav
languageNo
previous_tokensNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A5/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses determinism (same text/voice/seed gives same audio), format-specific container quirks (random stream serial for ogg/opus), speed behavior with pitch preservation, continuation semantics, truncation detection, and a detailed error structure with `error_kind`, `supported`/`available`, and `code`. This is exemplary transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Although long, every sentence earns its place. The description leads with the core action and return value, then systematically covers formats, determinism, language, speed, continuation, truncation, and errors. There is no redundancy or fluff; the structure is logical and front-loaded with the most important facts.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (7 parameters, multiple formats, error cases, continuation), and the absence of any annotations, the description is remarkably complete. It explains what is returned, how parameters affect behavior, how to chain calls, and how to interpret errors. An output schema exists, so the return structure is likely further defined, but the description covers everything an agent needs to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must explain every parameter. It does: `format` with defaults and size trade-offs, `language` with default behavior, `speed` with range and pitch preservation, `previous_tokens` with its continuation purpose, and `seed` via the determinism statement. `text` and `voice` are self-evident but still implied. The description adds meaning beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a crisp verb+object pair ('Turn text into speech in a named voice') and then specifies the exact resource and the output shape (base64 audio, duration, token count). It clearly distinguishes itself from the siblings (list_voices, describe) by focusing on synthesis rather than enumeration or inspection.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use guidance for each format ('worth asking for when the reply is saved to a file rather than played', 'for a reply sent on to a chat or a phone'), explains when to omit or pass `language`, and describes the continuation mechanism for long texts. It even tells the caller to check `truncated` to detect cut-off speech. This is proactive, alternative-aware guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 3 tool updatesv0.1.1
    • First observeddescribe
    • First observedlist_voices
    • First observedsynthesize
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.2/5.0

Scored across 3 tools

Disambiguation5/5

Each tool has a clearly distinct responsibility: listing available voices, performing synthesis, and reporting configuration details. There is no overlap or ambiguity between their purposes.

Naming Consistency4/5

All tool names are lowercase imperative verbs, but list_voices follows a verb_noun pattern while synthesize and describe are standalone verbs. The naming is still readable and predictable, with only a minor structural inconsistency.

Tool Count5/5

Three tools is well-scoped for a text-to-speech server: discover voices, synthesize speech, and inspect configuration. Each tool earns its place without redundancy or bloat.

Completeness5/5

The surface covers the full core workflow: discovering available voices, generating audio from text, and inspecting the active configuration for debugging. No major gaps are apparent for the stated purpose.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers