Skip to main content
Glama

estonian-mcp

Claude is quite bad at Estonian, so this MCP is here to fix that. Give it a shot.

CI Smithery License: Apache 2.0 Python 3.11-3.13 MCP

A small Model Context Protocol server that exposes EstNLTK, the Estonian NLP toolkit, as tools any LLM client can call in real time, backed by EKI's orthography rules (Reeglid) and public-domain Riigi Teataja legislation. Hand it Estonian text, get back correct lemmas, morphology, POS tags, spell-check + suggestions, syllables, named entities, WordNet synonyms, fastText-based related words, a register hint, orthography/grammar checks, kantseliit and terminology-consistency checks for reports and academic prose, and, for legal texts, legalese simplification and canonical legal-usage lookups.

One-click install from Anthropic's official Connectors Directory, or self-host. See below.

If your AI agent has to draft, edit, or proofread Estonian, this wires in ground truth so it stops guessing on the mechanical layer (spelling, case forms, conjugation) and gives it real Estonian synonyms instead of inventing them.

It also covers the editorial layer, where a word can be correctly spelled, morphologically valid and still wrong: check_translationese for Estonian that keeps English sentence structure, check_officialese for bureaucratic Estonian in reports and academic prose, check_term_consistency for a document that names one thing three ways, and synonyms read as a word-fit check: its glosses carry domain constraints (korpus is specifically "kirjaliku või suulise teksti elektrooniline kogu", so a set of images is not one, however natural it sounds in ML jargon).

Benchmark: on TalTech's inflection_et gold dataset (a noun-phrase inflection benchmark; Lillepalu & Alumäe, arXiv:2510.21193), our morphology engine scores 99.1% first-candidate / 99.1% any-candidate over 1,400 items (first-candidate is 96.6% without the optional fastText model, which is what ranks a lemma's inflection types; any-candidate is 99.1% either way). The 13 answers it gets "wrong" are all ones where the benchmark itself contradicts EKI, so once those 13 are corrected the score is 100% / 100%; the 13 are listed with their EKI citations in data/inflection_et_eki_disputes.json. uv run python scripts/apply_eki_corrections.py rebuilds the dataset locally with those 13 rows corrected. The corrections live here; the data does not, because the dataset carries no licence and re-hosting it is not ours to do. Reproduce: uv run python scripts/eval_inflection.py. (We're a tool server, not a rankable LLM, so this scores our tools against published gold data.)

Second benchmark, wider and from real text: inflection_et covers four cases, so ten were never measured. Against Pert Lomp's käänamiskorpus (11,011 single-word rows over all fourteen cases, drawn from Riigikogu stenographs and ERR news and frequency-weighted, CC-BY-SA-4.0), the engine scores 99.3% first-candidate / 99.9% any-candidate. The gap between those two is the interesting part: Estonian forms most plural oblique cases two ways, and leading with the wrong one cost 11 points until 0.5.10 ordered a slot's variants by the paradigm's own genitive stem (raamatutele before the literary raamatuile). Reproduce: uv run python scripts/eval_kaanamiskorpus.py. The data is downloaded at run time, never vendored here, and the server never touches it.

Three ways to use it:

  1. 👉 One-click from Anthropic's Connectors Directory, the easiest path, no terminal, no install, no URL to paste. See Get started in 30 seconds below.

  2. One-click on Smithery, install from the estonian-mcp listing.

  3. Self-host, clone, run locally as stdio, or deploy your own container to Fly.io / any host. See Self-host (advanced).

What it does

Tool

What it does

tokenize(text)

Split text into sentences and words

analyze_morphology(text)

Lemma, POS, form, root and ending per word (punctuation left out), plus, where they apply, the form's Estonian name, clitic, compound parts, ambiguity count, usage flags (archaic / foreign / interjection / abbreviation / proper-noun) and an indeclinable flag

paradigm(word)

Full Vabamorf-generated inflection paradigm, 14 cases × 2 numbers for nominals (including ordinals, comparatives, superlatives and proper nouns, the last from Vabamorf's lexicon only), plus the short illative where a word has one (majja beside majasse), ~39 verb forms including the umbisikuline tegumood (kasutatakse, kasutati), with Estonian labels per form. A lemma with several inflection types (kott → koti or kota, two different words) returns one consistent table per type, corpus-ranked, rather than a merged one; pass an inflected form (koti) to select the type you mean. Proper nouns inflect from Vabamorf's lexicon (Tallinn → Tallinnasse); a name it lacks gets an empty table rather than invented forms, and a capitalised common word it has no name for (Pikk at the start of a sentence) gets the lowercase word's table

lemmatize(text)

Just the dictionary form per word (punctuation left out)

pos_tag(text)

Just the part-of-speech tag per word (punctuation left out)

spell_check(text)

Misspelled words with correction suggestions; an empty list means every word passed

syllabify(word)

Syllables with quantity + accent

named_entities(text)

People / places / organisations

synonyms(word)

Synsets from Estonian WordNet: synonymous lemmas and a definition per word sense, plus examples where WordNet has them

find_related_words(word)

Top-N semantically nearby words via fastText embeddings (semantically related, not always synonymous)

classify_register(text)

Coarse formal/colloquial register hint with matched markers, consistency flag for register-mixed text, plus structural signals (umbisikuline tegumood ratio, noun density) so dense officialese no longer scores "neutral"

check_style(text)

Style metrics, lemma-aware repetition, umbisikuline-tegumood ratio, sentence-length variance, hedging-word density

check_officialese(text)

Kantseliit check for non-legal prose (reports, academic, business), where check_legalese stays silent. Nominalisation density (hindamine → hindama), impersonal-voice ratio, clause stacking (mille käigus … ning …), Estonian-calibrated sentence length, admin filler (omab → on, mudeli poolt loodud → mudeli loodud), läbi viima in every form (viis läbi uuringu → korraldas / tegi, läbiviimine) with routes (Rada viib läbi metsa) left alone, translated stock phrases of letters (Palun leidke manuses, ärge kõhelge ühendust võtmast, sealhulgas, kuid mitte ainult) and the request Küsin täpsemalt, kas … (→ Palun täpsustage, …). A -mine noun's verb is a real one: läbivaatamine → läbi vaatama, riskihindamine → hindama

check_translationese(text)

English structure in Estonian, the patterns that make a text read as translated, each one EKI or an EKI-published author rewrites: teie andmed where the subject's own thing is oma andmed, lähtume me → lähtume, Kui ..., me saadame → saadame (the verb comes first after a fronted clause), saab olema → on, ettepanek võtmaks → võtta, Tagamaks → et tagada, Mitte leides → Leidmata, tänu with a bad cause → tõttu, minu arvamusel, a third of the sentences opening with Ma, and English habits of form: Hea Mari, → Hea Mari!, Tere Mari → Tere, Mari, Lugupidamisega, → Lugupidamisega, the serial comma (teed, ja), title case in headings. Accepted Estonian such as aset leidma, rolli mängima or Eile ma läksin is left alone

check_term_consistency(text, glossary?)

One referent, one term. Flags a document that calls the same thing andmestik on page 1 and teadusandmestik on page 2, via shared compound head or shared Estonian WordNet synset, with per-variant counts so you can standardise on the dominant one. With a domain glossary (the server's, or a per-call glossary), a variant that is the only one listed in its group is named the group's preferred form

check_redundancy(text)

Pleonasm check, flags semantic doubling like samuti ka (also+also), kõige optimaalsem (most+optimal), and fixed redundant phrases

check_object_case(text)

Käändeõpetus, flags direct-object case errors under negation and after partitive-only verbs (armastama, vihkama, vajama, …), and verb government: teavitama takes the person in the partitive, teatama in the allative (teavitas politseile → teavitas politseid or teatas politseile; kahtlasest tegevusest teavitamine Rahapesu Andmebüroole → teatamine)

check_abbreviation_hyphenation(text)

Lühendiortograafia, flags an ending that starts with l written straight onto an all-capital abbreviation (OÜle → OÜ-le, THIl → THI-l), where EKI finds the hyphen clearer; a letter whose name ends in a consonant also gets the stem vowel (ASle → AS-ile). Other hyphenless forms (ELi, APIga, MCPst) are as correct as the hyphenated ones and are not flagged, and chloride formulas (HCl) are not abbreviations

check_compound_familiarity(text)

Attestation check, for each compound noun, reports whether the lemma is in the corpus vocabulary, Estonian WordNet or the legal terms list, and returns the top fastText neighbours of each unattested one. Unattested is ordinary for specialist vocabulary and is not a rewrite signal; the narrow is_suspect flag needs an unattested lemma whose nearest real neighbour is still under 0.55 (mõtteliin-style translationese, literal English "train of thought" → real Estonian is mõttekäik). With a server glossary, each compound also carries in_domain_glossary

check_domain_terms(text, glossary?, suggest_cutoff?)

Domain-glossary check, for Estonian written about an organisation's own systems, where a compound should be the organisation's term or the thing's identifier. Reports compounds that are unattested AND not on the operator's glossary or identifier list (see Domain glossary): not the organisation's word, though not necessarily coined, since much ordinary Estonian is unattested, each with up to three glossary terms spelled alike (look-alikes, not synonyms) and the glossary term it is built on, if any (vagunireisitabel on vagunireis). The hosted server has no glossary of its own: pass your terms in glossary (up to 1,000), used for that call only

check_capitalization(text)

Algustäheortograafia check, flags wrongly capitalized weekdays, months, nationalities, and language/culture adjectives per EKI's Reeglid

check_compounds(text)

Liitsõnaõigekiri, flags common AI-generated splits of words that should be a single compound (kooli maja → koolimaja)

check_punctuation(text)

Kirjavahemärgid, flags missing commas before subordinating conjunctions (et, sest, kuna, kuid, vaid, nagu, …); a comma before a two-part connective (nii et, ilma et) passes, and nagu is flagged only before a clause with a verb. Also flags the comma that closes an embedded clause (Mees, kes seal seisis oli minu isa → seisis, oli), which EKI keeps even before ja when the main clause continues (Juhtisin projekti, mis kestis kaks aastat, ja koolitasin …)

check_hyphenation(word)

Poolitamine, line-break positions for an Estonian word at syllable boundaries, never fewer than 2 characters from either end. Compound seams are among them but not singled out

check_numbers(text)

Numbrite õigekirjutus, flags decimal separators (3.14 → 3,14) and thousands separators (1,250 → 1250, 1,000,000 → 1 000 000; keep 1,250 if the decimal 1,25 is meant). Skips times after kell, time ranges, dates, clause, section and version numbers (4.13., punkt 3.2, Python 3.12); a time without kell mid-sentence (väljub 8.47 ja) is still flagged. Also flags a tilde used as "about" before a number (~50 → u 50; EKI keeps the tilde for variants such as mina ~ ma), a month and year in digits (09.2016 → sept 2016, where it used to be called a decimal), a spaced range dash (2020 - 2024 → 2020-2024) and a suffix on the per cent sign (20%-line → 20% or 20-protsendiline)

check_legalese(text)

Legal plain-language aid, flags archaic kantseliit filler (käesolev → see, juhul kui → kui) and over-long sentences to simplify, while listing the terms of art that must be preserved so simplification doesn't change legal meaning

check_defined_terms(text)

Long-document structure, maps terms defined with (edaspidi „X“) or , edaspidi „X“, in any common quote style (an adverbial edaspidi before a quotation defines nothing), counts their exact-form uses (case-sensitive, so a term used only in inflected forms shows as defined-but-unused), lists § / lõige / punkt / artikkel cross-references, and flags defined-but-unused or doubly-defined terms (cap raised to 500k chars)

common_legal_usage(word)

Canonical legal collocations from an offline corpus index, how often a term occurs in legislation and the commonest lemmas of the nearest content word on each side (hagi → esitama hagi, kohustus → kohustuse täitmine), so the model uses real legalese instead of inventing it (bundled index: 5 core Riigi Teataja codes, obligations, civil procedure, property, penal, general; expandable, see Notes)

POS tag set: S=noun, H=proper noun, V=verb, A=adj (C=comparative, U=superlative, G=indeclinable), P=pron, D=adv, K=adp, J=conj, N=cardinal, O=ordinal, I=interj, Y=abbreviation or symbol (§, €), X=verb-bound word (plehku). Punctuation (Z) is left out of per-word output; tokenize keeps it.


Related MCP server: Võro MCP Server

✨ Get started in 30 seconds (no install)

This section is for everyone, including if you've never opened a terminal in your life. You'll be done before your tea is steeped.

estonian-mcp is in Anthropic's official Connectors Directory, so on most Claude apps you can add it with one click, no URL to paste, no config, no auth.

One-click from the Connectors Directory (Cowork, claude.ai, Claude Desktop)

  1. In your Claude app, open Settings → Connectors.

  2. Browse connectors (the directory) and search estonian, it shows up as the Estonian connector.

  3. Click Add / Connect. That's it, the server is public, so there's no authentication step.

  4. Start a new chat and write in Estonian, proofread an email, study a paragraph, draft a legal clause. Claude reaches for the tools whenever it needs to verify spelling, lemmas, morphology, or legal phrasing rather than guessing.

(On older Claude Desktop without a Connectors menu, use the stdio path in Self-host (advanced).)

Prefer to paste the URL? (or don't see it in the directory yet)

Any MCP-over-HTTPS client can also connect directly to the hosted server: we run it for you at https://estonian-mcp.fly.dev/mcp. In Settings → Connectors → Add custom connector, paste:

https://estonian-mcp.fly.dev/mcp

Leave every "Authentication" / "API key" / "Bearer token" field empty (the server is public, no token needed), then Save.

In Claude Code (CLI)

One command, no clone, no Python, no uv. Point Claude Code at the hosted server over HTTP:

claude mcp add --transport http estnltk https://estonian-mcp.fly.dev/mcp

Then run /mcp inside a session to confirm estnltk shows as connected. The tools are live immediately, ask Claude to proofread or lemmatize Estonian text and it'll reach for them.

Want a fully local, zero-network setup instead? See the stdio path in Self-host (advanced).

In Codex (CLI)

One command, the same hosted server over streamable HTTP:

codex mcp add estonian --url https://estonian-mcp.fly.dev/mcp

codex mcp list should then show it as enabled. Auth reads as "Unsupported", which is correct here: the server is public and wants no token. Ask Codex to proofread or lemmatize Estonian and it calls the tools directly.

In ChatGPT

ChatGPT reaches MCP servers through a custom connector, which lives behind developer mode. Turn that on in ChatGPT's settings, add a connector pointing at https://estonian-mcp.fly.dev/mcp with no authentication, then switch it on inside the chat that should use it. A saved connector is not active until it is selected in the conversation.

OpenAI has moved that toggle between Settings sections more than once, so follow their current developer mode article for the exact path rather than a menu name written down here.

One limit worth knowing: ChatGPT's deep research connectors expect a server to expose search and fetch tools. This server exposes 27 Estonian NLP tools and neither of those, so it belongs in the ordinary connector slot, not the deep research one.

Don't see your client here?

Any tool that supports MCP over HTTPS can connect, just point it at https://estonian-mcp.fly.dev/mcp with no auth. If your client only speaks stdio (Cursor, VS Code MCP, Continue, Zed), jump to the local-install path in Self-host.


💡 Pro tip, teach Claude your Estonian alongside the MCP

This MCP gives Claude correct linguistics: real lemmas, real case forms, real spelling. What it can't do is teach Claude your voice: the register, idioms, and tone you actually want when writing.

You handle the voice; the MCP handles the correctness. Layer them.

A few things to add to your Claude project / custom instructions / system prompt to get this right:

  • Set the register. "Always reply in formal officialese Estonian for legal and government topics, and in conversational Tallinn speech for chat replies. Never mix the two in one message."

  • Pin the dialect / region. "I'm from Tartu, prefer southern Estonian phrasings where there's a choice (e.g. 'kus sa lähed' rather than 'kuhu sa lähed' for casual speech)."

  • Show your tone with examples. Paste 3-4 short paragraphs of your own writing into the project instructions and ask Claude to match that voice. Real examples beat any abstract description.

  • Anchor common mistakes. "You always confuse kasutama (to use) with käsitlema (to handle / to deal with). Double-check those with the lemmatize tool before sending."

  • Direct the MCP explicitly when it matters. "Before sending any Estonian email, run spell_check on every word. Show me misspelled words with suggestions before drafting."

  • Use classify_register as a sanity check. "After drafting, run classify_register on the final text and warn me if it lands in 'formal' or 'colloquial' when I asked for the opposite." The classifier is coarse but reliably catches drift into officialese (käesolev, vastavalt, sätestama) or slang (mõnus, vinge, kuule).

  • Use synonyms to break repetition. "This newsletter uses kasutama four times. Look up synonyms via the MCP and suggest natural-sounding swaps." You'll get real Estonian alternatives with definitions, not invented ones.

  • Use find_related_words for richer rewrites. "What words pattern with kohv in Estonian? Use that to suggest three alternative phrasings for our café-launch ad copy." This is fastText-based, so it surfaces near-neighbours that aren't strict synonyms, useful when you want adjacent concepts, not just same-meaning swaps. (Quick rule of thumb: synonyms for "say the same thing differently"; find_related_words for "what else belongs in this conceptual space.")

The MCP catches misspelled words and invented case forms; your prompt drives the style. Together they make Claude actually useful for writing in Estonian, not just plausible-looking.


How to prompt it once it's connected

Most prompts don't need to mention the tools by name, Claude picks the right one. A few patterns that work especially well:

Proofread this Estonian email and use spell_check on any words
you're unsure about: <text>
Lemmatize this Estonian paragraph, then translate the lemmas to
English so I can study vocabulary: <text>
Analyze the morphology of this sentence and explain the case
markings: "Tallinnas elavad eestlased räägivad eesti keelt."
Extract the people and places from this Estonian news article,
then summarise in one paragraph.
This Estonian draft uses "kasutama" three times, look up synonyms
via the MCP and rewrite each occurrence with a natural-sounding
alternative that preserves the meaning.
Write this reply in Estonian, short, the way a native speaker would,
then run check_translationese on it and fix what holds: <text>
Classify the register of this draft. If it scores formal, soften
it for a casual newsletter audience. If it scores colloquial,
tighten it for a B2B email.

The model calls the tool, gets authoritative output, and bases its response on that, no more hallucinated lemmas or invented case forms.


All clients at a glance

Client

No-install path

Local-install path

Claude Cowork

✅ One click (directory)

✅ stdio via JSON

Claude Desktop

✅ One click (newer)

✅ stdio via JSON

claude.ai web

✅ One click (directory)

n/a

Claude Code (CLI)

✅ claude mcp add --transport http

✅ claude mcp add ... (stdio)

Codex (CLI)

✅ codex mcp add --url

✅ codex mcp add -- <command> (stdio)

ChatGPT

✅ Custom connector (developer mode)

n/a

Cursor

✅ Paste URL

✅ stdio via JSON

VS Code MCP / Continue / Zed

n/a

✅ stdio via JSON

For Claude apps the no-install path is one click from the Connectors Directory (search "estonian"). Codex takes the URL as a command, ChatGPT takes it as a custom connector once developer mode is on, and other MCP clients paste https://estonian-mcp.fly.dev/mcp in their Connectors UI. The local-install path clones the repo and points the client at python server.py.

Reducing permission prompts

Claude clients ask for confirmation before calling a tool from a custom/third-party connector, that's the client's security default, not something the server controls (there's no MCP field a server can send to suppress it). You'll especially see it right after adding or updating the connector, since the client re-checks tools it hasn't seen before.

Good news: all 28 tools are marked readOnlyHint: true (they only read text, never write or call out), so any well-behaved client can safely let you allow them once and stop asking:

  • Claude Desktop / Cowork / claude.ai, when the prompt appears, choose "Always allow" for the connector (or toggle it in the connector's settings). One time, then it's quiet.

  • Claude Code, run /permissions and allow the estonian-mcp tools, or allow the whole server at once.

Re-releasing or updating the connector can reset that "always allow" state (the client sees changed tools and re-asks), just allow it again. A verified listing in the Anthropic Connectors Directory also gets smoother permission UX than an unverified custom connector.


Self-host (advanced)

The hosted instance is convenient, but if you'd rather run your own (privacy, latency, custom auth, offline use), the same one-file server works locally and as a container.

Run locally as stdio (zero network)

Python 3.11.5 to 3.13. EstNLTK stops at 3.13, the Pillow it pulls in needs 3.11 for its security fixes, and the Soup Sieve it pulls in needs 3.11.5 for its.

git clone https://github.com/silly-geese/estonian-mcp.git
cd estonian-mcp
uv sync
uv run python scripts/fetch_resources.py   # required, see below
uv run python tests/test_smoke.py          # verify

Don't skip the fetch_resources.py step. uv sync installs Python packages, but three of the things the server needs are data, not Python distributions, so they can't live in uv.lock: NLTK's punkt_tab tokenizer, Estonian WordNet (~26 MB), and the fastText embeddings (~33 MB). Without them check_compounds and check_term_consistency raise, synonyms refuses to run, and check_term_consistency reports degraded: true. The script is idempotent, so re-running it is free.

The server never downloads anything itself: not at import, not on a tool call. That's the privacy promise: no outbound HTTP from the running process. Fetching is a separate step you run knowingly, and the Docker image does the equivalent at build time.

Then wire it into your client.

Claude Code:

claude mcp add estnltk -- /absolute/path/to/uv \
  --directory /absolute/path/to/estonian-mcp \
  run python server.py

Claude Desktop / Cowork (local mode), edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "estnltk": {
      "command": "/absolute/path/to/uv",
      "args": [
        "--directory", "/absolute/path/to/estonian-mcp",
        "run", "python", "server.py"
      ]
    }
  }
}

Cursor, same JSON shape in ~/.cursor/mcp.json.

Run as a remote server (HTTP)

The same server.py speaks streamable-http over the network. Two auth postures:

  • Public mode (ESTNLTK_MCP_PUBLIC_MODE=1), no bearer token, per-IP rate limit (default 300/min). This is how the silly-geese hosted instance runs.

  • Bearer mode (default), every request must carry Authorization: Bearer <token> (or Smithery's ?config=<base64>); per-token rate limit. Refuses to start without ESTNLTK_MCP_AUTH_TOKEN ≥16 chars.

Fly.io public deployment (matches silly-geese):

fly auth login
fly apps create my-estonian-mcp
# one-time: persistent volume for /metrics counters (~$0.15/month)
fly volumes create estonian_mcp_data --size 1 --region ams -a my-estonian-mcp
fly deploy

fly.toml already sets ESTNLTK_MCP_PUBLIC_MODE=1 and mounts the volume at /data, so no token needed and /metrics counters survive machine restarts. Endpoint: https://my-estonian-mcp.fly.dev/mcp.

Fly.io with bearer auth, remove ESTNLTK_MCP_PUBLIC_MODE from fly.toml's [env] block, then:

fly secrets set ESTNLTK_MCP_AUTH_TOKEN="$(python3 -c 'import secrets;print(secrets.token_urlsafe(32))')"
fly deploy

Generic Docker (any container host):

docker build -t estonian-mcp .   # no image is published

# Public
docker run -p 8081:8081 -e ESTNLTK_MCP_PUBLIC_MODE=1 estonian-mcp

# Bearer
docker run -p 8081:8081 \
  -e ESTNLTK_MCP_AUTH_TOKEN="$(python3 -c 'import secrets;print(secrets.token_urlsafe(32))')" \
  estonian-mcp

Behind nginx, with TLS and a token per client: deploy/ is a Docker Compose stack (app + nginx + certbot) for running this on your own host. nginx terminates TLS with Let's Encrypt certificates, holds one bearer token per client with per-client rate limits and one-line revocation, meters the requests it refuses as well as the ones it serves, and answers OAuth discovery for connectors that cannot send a static Authorization header. It writes no access log unless you turn one on. See deploy/README.md.

cp .env.example .env         # set DOMAIN, LETSENCRYPT_EMAIL, INTERNAL_TOKEN
./deploy/new-token.sh my-laptop
./deploy/init-letsencrypt.sh

Smithery auto-builds from smithery.yaml and hosts the image for you. Fork, connect on Smithery, deploy. The shipped configSchema is empty (one-click install) because the deployment runs in public mode; flip it back if you fork to a bearer-mode setup.

Domain glossary (optional)

An organisation writing about its own systems has words no general corpus contains, and an agent writing for it tends to coin a compound where the organisation already has a word. Give the server that vocabulary and check_domain_terms can tell the two apart.

Variable

Contents

ESTNLTK_MCP_DOMAIN_GLOSSARY

Path to the organisation's terms: UTF-8, one lemma (base form) per line, # starts a comment. Matched case-insensitively, and offered as suggestions

ESTNLTK_MCP_DOMAIN_IDENTIFIERS

Path to names check_domain_terms never reports and never suggests: table, column or function names written as words. Same format; matched as written as well as by lemma. Only check_domain_terms reads this list

ESTNLTK_MCP_DOMAIN_SUGGEST_CUTOFF

Spelling similarity, 0.4 to 1, that a glossary term needs to be suggested. Default 0.6

The server reads the files once, at startup, so restart it after editing them. A file it cannot read, or a cutoff outside 0.4 to 1, stops it with exit status 2. With a glossary set, check_compound_familiarity marks each compound in_domain_glossary and check_term_consistency names a variant as its group's preferred form when it is the only one listed. Unset, every other tool answers exactly as before.

For stdio, add "env": {"ESTNLTK_MCP_DOMAIN_GLOSSARY": "/absolute/path/to/terms.txt"} to the server's entry in the client config, or with Claude Code:

claude mcp add estnltk -e ESTNLTK_MCP_DOMAIN_GLOSSARY=/absolute/path/to/terms.txt \
  -- /absolute/path/to/uv --directory /absolute/path/to/estonian-mcp \
  run python server.py

In a container, mount the file read-only. It must be readable by uid 1000, the user the image runs as. Bearer mode, so the glossary is not handed to anyone who finds the port:

docker build -t estonian-mcp .
docker run -p 8081:8081 \
  -e ESTNLTK_MCP_AUTH_TOKEN="$(python3 -c 'import secrets;print(secrets.token_urlsafe(32))')" \
  -v "$PWD/terms.txt:/etc/estonian-mcp/glossary/terms.txt:ro" \
  -e ESTNLTK_MCP_DOMAIN_GLOSSARY=/etc/estonian-mcp/glossary/terms.txt \
  estonian-mcp

The deploy/ stack reads them from deploy/glossary/.

Anyone who can call the server can read the glossary, because the suggestions quote it, and can probe the identifier list by what it stops reporting. On a public instance, list nothing confidential. The server logs a warning at startup when the two are combined.


Security

  • stdio mode: pure local subprocess. No network egress, no shell exec, no fs writes, no telemetry.

  • HTTP / public mode: no auth required (intentional for the free public service). Per-IP rate limit (300/min default). Same hardening as bearer mode: no shell exec, no fs writes, no telemetry, size-bounded inputs.

  • HTTP / bearer mode: ESTNLTK_MCP_AUTH_TOKEN (≥16 chars) required, server refuses to start without it. Bearer auth on every request, constant-time comparison, per-token rate limit (120/min).

  • Common to all HTTP: /health is the only path without a rate limit. The landing page, favicons, server card and /metrics share a separate per-IP limit (60/min default). No request or token logging. proxy_headers is off: the server reads X-Forwarded-For itself, counting ESTNLTK_MCP_TRUSTED_PROXY_HOPS entries from the RIGHT (default 1, for Fly's single edge proxy), because the leftmost entry is caller-controlled and letting uvicorn trust it defeated the per-IP rate limit (0.5.4).

  • Inputs: 100 KB cap per text tool, 200 chars for syllabify, 1,000 terms of up to 200 chars for a per-call glossary. Oversized inputs return a structured error rather than hanging.

  • Supply chain: deps pinned + hashed in uv.lock. Dependabot watches pip + GitHub Actions weekly. CI runs smoke + HTTP tests + Docker build/boot on Python 3.11 and 3.13 on every push.

Full threat model and disclosure path: SECURITY.md. Privacy policy (what we receive, what we don't store): PRIVACY.md. Terms of service for the hosted endpoint: TERMS.md.


Notes

  • The server never downloads anything at runtime. Not on import, not on a tool call, not to fill a gap it notices. That's the privacy promise. Resources are fetched at Docker build time, or by you running scripts/fetch_resources.py on a source install. If a resource is missing, tools say so: synonyms raises an actionable error, and check_term_consistency returns degraded: true with the reason in its Estonian summary rather than a confident-looking partial answer.

  • Most EstNLTK models (morph, NER, spell-check) ship inside the wheel. Three things don't, because they're data, not Python distributions, so uv.lock can't carry them: NLTK's punkt_tab tokenizer, WordNet, and the fastText model.

  • WordNet is a separate ~26 MB resource (used by synonyms and one of check_term_consistency's two rules).

  • The fastText model used by find_related_words, check_compound_familiarity and check_domain_terms is a ~33 MB compressed resource with a 100K-word vocabulary (built locally from Facebook's cc.et.300 via compress-fasttext, CC-BY-SA-3.0; see NOTICE).

  • common_legal_usage reads a bundled index of five Riigi Teataja codes (data/legal_collocations.json.gz). To cover more acts, build one with scripts/build_legal_collocations.py (see scripts/README.md) and set ESTNLTK_MCP_LEGAL_INDEX to its path; the server reads it on the first call.

  • Results are lean, because every caller pays for them in tokens. Each answer is one compact JSON block holding only the fields that apply. No tool echoes your input or repeats a fixed note, and the rules every tool shares are said once in the server instructions. 0.8.0 cut the tool list by 42% and a typical result by about half.

  • Heavy neural taggers (estnltk_neural, BERT-based NER) are intentionally not pulled in; this server stays lean and fast.

  • First call after server start incurs a one-time tag-layer load (~1-2 s). Subsequent calls are millisecond-scale.

  • The hosted Fly instance scales to zero when idle; the first request after a quiet period takes ~5 s, then everything is fast again.

🤝 Contributing

Contributions are welcome, especially from Estonian speakers who can sharpen the linguistic rules. Here's how to get started:

  1. Fork the repo and clone your fork.

  2. Set up the environment (Python 3.11.5 to 3.13):

    uv sync
    # punkt_tab + WordNet + fastText (none can come from uv.lock):
    uv run python scripts/fetch_resources.py
    export ESTNLTK_MCP_FASTTEXT_PATH=~/.cache/estnltk-mcp/fasttext-et-medium
  3. Create a feature branch (git checkout -b feature/my-feature).

  4. Run the tests, both must pass:

    uv run python tests/test_smoke.py       # tool behaviour
    uv run python tests/test_http.py        # transport, auth, /metrics
    uv run python tests/test_resources.py   # resource-availability handling
  5. Commit and open a pull request against master. CI (smoke on Python 3.11 + 3.13, plus a Docker build/boot check) must be green before merge.

Please open an issue first for major changes so we can discuss the approach before you invest the work.

Especially wanted: linguistic corrections

The heuristic tools lean on small hand-curated lexicons in server.py, marked/archaic words, register markers, compound-split pairs, partitive-governing verbs, and the EKI orthography rule sets. These are deliberately conservative and incomplete. If you're a fluent Estonian speaker and spot a gap or a wrong entry, that's the highest-value contribution you can make:

  • A missing calque AI agents produce, with the idiomatic native form

  • A verb that governs the partitive but isn't in the list

  • A compound that should (or shouldn't) be flagged

  • A register marker that's miscategorised

Open an issue with the English source (if it's a calque), the bad Estonian, and the better Estonian, or send a PR adding the entry to the relevant lexicon with a one-line test case.

License

Apache-2.0 for the source. Bundled data + models keep their own (copyleft) licenses, these apply to those files only, not to the Apache-2.0 code:

  • EstNLTK, dual-licensed GPL-2.0 OR Apache-2.0 (we use Apache-2.0).

  • Vabamorf analyzer, LGPL-2.1 with a separate commercial-use license.

  • Estonian fastText model (find_related_words, check_compound_familiarity, check_domain_terms), CC-BY-SA-3.0.

  • Estonian Wordnet (synonyms), CC-BY-SA-4.0.

The CC-BY-SA model + Wordnet data carry share-alike obligations on those files when you redistribute them (the Docker image includes both). See NOTICE for full attribution and redistribution terms.

Available Tools

28 tools
analyze_morphologyB
Read-onlyIdempotent

Morphological analysis of each word (punctuation omitted): word, lemma, partofspeech (pos_tag's tags), form (Vabamorf code, "" if uninflected), root (_ joins compound parts), ending ("0" = none).

Present only when they apply: form_estonian (the form's Estonian name), clitic, root_tokens (compound parts), analyses_count (>1: still ambiguous in context), usage_note (archaic, foreign, abbreviation, interjection, proper-noun) and the more precise usage_note_estonian (often names the neutral word), indeclinable: true (keeps its base form before a noun: täis, tuntud, täitmata; check it before declining a noun phrase).

Inputs: text (required), all_analyses. Returns: result

check_abbreviation_hyphenationA
Read-onlyIdempotent

Flags an ending that starts with l written straight onto an all-capital abbreviation: OÜle → OÜ-le, ÜROlt → ÜRO-lt, THIl → THI-l. EKI finds the hyphen clearer there. Every other hyphenless form (ELi, ELis, APIga, MCPst, ASile) is as correct as the hyphenated one and is not flagged: keep the text's own choice.

A stem read with a final consonant also needs the stem vowel i (ASle → AS-ile, ELlt → EL-ilt); a Roman ordinal up to XXXIX before a noun or adjective in the same case drops the ending (XIIl sajandil → XII).

Any all-capital stem counts, known or not; mixed-case ones (SaaS, PhD, iOS) and chloride formulas (HCl, NH4Cl) are not checked.

Inputs: text (required). Returns: issues, summary_estonian

check_capitalizationA
Read-onlyIdempotent

Flags words wrongly capitalized mid-sentence (algustäheortograafia):

  • weekday, month, nationality: lowercase except at sentence start (esmaspäeval, jaanuaris, eestlane).

  • language-adjective: a country name before a language or culture noun is lowercase (eesti keel, vene kultuur). On its own it is the country (Eesti, Eestis) and is not flagged.

Sentence-initial words and all-caps acronyms are skipped. A hit that opens a line, list item or quotation, or sits in a proper name (Eesti Keele Instituut), is usually false. English title case in headings is check_translationese's title-case.

Inputs: text (required). Returns: issues, summary_estonian

check_compound_familiarityA
Read-onlyIdempotent

Attestation check for Estonian compound nouns; use it on compounds you coined.

A compound is attested when its lemma is in the fastText 100K-word corpus vocabulary (in_vocab), Estonian WordNet (in_wordnet) or the legal terms list (neighbour_quality.legal_term). Read attested first: false is normal for correct specialist words, not evidence of invention, and never on its own a reason to rewrite.

is_suspect is narrow: unattested, and the nearest neighbour is a real word scoring under 0.55 (mõtteliin). Judge a flag from neighbours (unattested entries only): coherent related words mean the word is real. neighbour_quality.signal: "none": the nearest neighbour is scrape junk, so there is no verdict. Recall is low on purpose: some coinages pass, and so does any stilted compound (check register with check_officialese).

in_domain_glossary: true (only with a server glossary): the organisation's own word, so treat it as real. For your own glossary use check_domain_terms. Proper nouns are skipped.

Inputs: text (required). Returns: note, all_compounds, wordnet_checked, summary_estonian, +3 more

check_compoundsA
Read-onlyIdempotent

Flags compounds wrongly written as two words (liitsõnaõigekiri): kooli maja → koolimaja.

Matches a curated list of about 30 common splits, so a hit is reliable but most compounds are not covered.

Inputs: text (required). Returns: issues, summary_estonian

check_defined_termsA
Read-onlyIdempotent

Maps defined terms and cross-references in a long Estonian legal document.

defined_terms: each (edaspidi «X») term. total_occurrences counts exact-form, case-sensitive matches, the definition included, so it misses inflected uses: verify a defined-but-unused issue before acting. cross_references: §, lõige, punkt and artikkel mentions, not validated. issues: terms defined twice or unused.

Inputs: text (required). Returns: issues, defined_terms, cross_references, summary_estonian

check_domain_termsA
Read-onlyIdempotent

Reports compounds no lexicon or domain glossary vouches for, in Estonian you wrote about an organisation's own systems.

A compound is reported when it is unattested (see check_compound_familiarity) and absent from the server's glossary and identifier list and your glossary. A reported compound is not necessarily coined: it is only not the organisation's word, and may be ordinary Estonian (vagunisõit is). Where it names something the organisation has a term or identifier for, use theirs; otherwise leave it.

suggestions are glossary terms SPELLED alike, not synonyms: use one only if it names the same thing. contains_glossary_term is the term the compound is built on (vagunireisitabel on vagunireis): ordinary Estonian, not to be shortened to the term; ask only whether the thing it names has its own term.

The hosted server has no glossary: pass yours in glossary. Without one this is the unattested list, never on its own a reason to rewrite. Proper nouns are skipped.

Inputs: text (required), glossary, suggest_cutoff. Returns: note, glossary_size, suggest_cutoff, wordnet_checked, +5 more

check_hyphenationA
Read-onlyIdempotent

Line-break positions in one Estonian word (poolitamine); use only when line breaks matter. breaks: character offsets at syllable boundaries, at least 2 characters from either end; preferred: the word with each break marked ·. Compound seams, which Estonian prefers, are among the breaks but not singled out: choose the seam yourself (kooli·maja). A break can also split one vowel off a compound part (maao-manik in maa·o·ma·nik); skip those.

Inputs: word (required). Returns: breaks, preferred, syllable_count

check_legaleseA
Read-onlyIdempotent

Plain-language aid for Estonian statutes and contracts; rewrites must keep the legal meaning.

issues: archaic filler and stock phrases with a plainer suggestion, and over-long or comma-heavy sentences to split. terms_of_art: legal terms (first use per lemma) to keep verbatim, never swapped for a general synonym. Starter lexicons: an empty or short issues list does not mean the text is plain, and an unlisted word can still be a term of art. For reports and business prose use check_officialese.

Inputs: text (required). Returns: issues, terms_of_art, summary_estonian

check_numbersA
Read-onlyIdempotent

Flags number-writing slips (numbrite õigekirjutus):

  • decimal-separator: 3.14 → 3,14; skips kell 10.30, 14.05, punkt 3.2, Python 3.12, but flags a bare 10.30.

  • thousands-separator: 1,250 → 1250, 1,500,000 → 1 500 000 (EKI groups from five digits; ideally non-breaking spaces, suggestion has plain ones). If 1,250 was meant as the decimal 1,25, keep it.

  • approximate-tilde: 50 → u 50 (Umbes 50 at a sentence start; umbes and ligikaudu also fit). A style hint for general prose: EKI keeps the tilde for variants (mina ~ ma), so a spaced tilde after a word, ≈, code (inline, fenced or indented), paths, versions and ranges (510) are not flagged.

  • month-year-digits: 09.2016 → sept 2016, a date rather than a decimal; EKI finds the month in words clearer. A one-digit month (1.2019) is left alone, as it may be a rate, and 10 to 12 after a rate word or currency pair in the clause (kurss 11.2050, EUR/SEK, keskmine, koefitsient) is a decimal. Inflect a full month name to fit the sentence (alates märtsist 2019); abbreviations need no ending.

  • range-spacing: 2020 - 2024 → 2020-2024, 5 - 10 päeva → 5-10. Only a spaced keyboard hyphen between plain numbers; typeset EKI text uses the mõttekriips, also unspaced. Skips sums and expressions after =, scores, code, phone numbers, a label and its value (ülesanne 1 - 10 punkti), ends containing a space (9000 - 10 000), ordinal and season ranges (2015.-2019. aastal, 2019/2020), and month.year ends.

  • percent-sign-suffix: 20%-line → 20% or 20-protsendiline; case endings (10%-st, 5%-ni) are fine.

Spelling out small numbers is not checked.

Inputs: text (required). Returns: issues, summary_estonian

check_object_caseA
Read-onlyIdempotent

Flags a direct object in the wrong case (käändeõpetus): a common noun in nominative or genitive (form) after

  • negation-requires-partitive: negation (ei söönud leib → leiba), or

  • partitive-only-verb: verb, one of nine verbs such as armastama, vajama and ootama that always take a partitive object.

The negation rule skips any sentence containing olema (pole, ei ole, pole näinud). The fix is the partitive of lemma in the number form shows; take it from paradigm. With no parser, a hit may be a subject or an adverbial, so treat it as worth a second look.

Two more rules check the government of teavitama (keda + millest) and teatama (kellele + millest), and add a suggestion:

  • teavitama-allative-recipient: teavitama or informeerima, or their noun teavitamine or informeerimine (verb), with the person or body in the allative (teavitas politseile; word is the allative phrase).

  • teatama-partitive-person: teatama with a partitive personal pronoun (Teatame Teid, et ...).

The fix is either teavitama + partitive (teavitas politseid) or teatama + allative (teatas politseile); for the noun, Rahapesu Andmebüroo teavitamine or teatamine Rahapesu Andmebüroole. Recall is low by design: a clause that already has a partitive object (teavitab õpilastele hindeid), an allative before the verb, an allative that a participle, adjective or action noun governs (teavitada isikut talle seatud piirangust), one whose head noun is not a person or body (kolimisest teisele korrusele), the experiencer of an adverb or a translative (meile teadaolevalt, kõigile üllatuseks) and an allative after a heading line are not flagged, and neither is a partitive pronoun that a following participle governs (Teatame Teid puudutavatest muudatustest: grammatical, but Teatame Teile ... reads better).

Inputs: text (required). Returns: issues, summary_estonian

check_officialeseA
Read-onlyIdempotent

Flag Estonian kantseliit in reports, academic and business prose; statutes and contracts go to check_legalese, which protects terms of art.

Issue rules: impersonal-voice (ratio 0.4+, 4+ verbs), nominalisation (4+ -mine nouns per 100 words, positioned at the first), noun-density (noun/verb 2.5+, weakest: weigh it last), clause-stacking (3+ subordinate-clause openers in a sentence), long-sentence (25+ words), officialese-filler, officialese-phrase, poolt-calque, kusin-tapsemalt, calque-phrase. impersonal-voice and noun-density are document-wide (position 0). 'läbi viima' in the conduct sense is an officialese-phrase in any form (viidi läbi, on läbi viinud, viis uuringu läbi), and läbiviimine, läbiviija, läbiviidud, läbiviidav, läbi viimine an officialese-filler, suggesting korraldama / tegema (pidama for a meeting) in the same form, with the words between kept (viis uuringu läbi → korraldas uuringu); routes and threaded objects (Rada viib läbi metsa, Kaabel tuleb läbi viia seinast, kaabli läbiviimine), time spans (päev läbi), postpositions, the numeral viis and the fugue term are skipped, and the 'läbi suruma' sense is not told apart. A thing carried through with no route word (Kohver viidi läbi) is still flagged. kusin-tapsemalt is a sentence-initial 'Küsin/Küsime täpsemalt, kas …' in a letter; a plan to ask someone else matches too unless a reporting-back verb follows (…, ja annan teada; …, ja võtan teiega ühendust), and quoted speech, a dialogue-dash line and a quoted e-mail line ('>') are skipped. Both are style hints, not errors. calque-phrase is a translated stock phrase of letters: sealhulgas, kuid mitte ainult (and eelkõige, kuid mitte ainult, where only the tail goes); antud juhul / hetkel / olukorras, not the participle (on antud olukorras, kus ...); adresseerima a problem, not a mail item; ärge kõhelge ... võtmast, rewritten with its own verb; kiri leiab teid hästi; tänan teid teie ... eest; vaatan edasi koostööle, with an awaited event (not vaatas edasi merele); Palun leidke manuses, not a search instruction (Palun leidke manusest oma nimi). Leiate manusest and läbi e-posti are accepted Estonian and not flagged. metrics.nominalisations gives each -mine noun's verb, a particle verb written apart (läbivaatamine → läbi vaatama, tagaajamine → taga ajama), a noun + verb compound by its head (riskihindamine → hindama, sisuloomine → looma), and no verb when none is known. The split 'läbi viimine' counts as läbiviimine. Nouns lexicalised as things (teadmised, pakkumine, kohtumine, ettevõtmine and their compounds) and -misi adverbs (vaikimisi) are not counted.

Precision-first starter lexicons: no issues is not proof the text is plain.

Inputs: text (required). Returns: issues, metrics, summary_estonian

check_punctuationA
Read-onlyIdempotent

Flags a missing comma:

  • comma-before-clause-conjunction: before et, kuna, sest, kuigi, kuid, vaid, nagu, mistõttu, millepärast or kuhu. A comma before a pair (nii et, ilma et) passes, as does et after ja, ning, ega or ehk; nagu is flagged only before a clause with a verb.

  • comma-after-subordinate-clause: closing a clause opened after a comma by a relative word (kes, mis, kus) or a subordinator (et, kui, kas), before the main clause's verb: Mees, kes seal seisis oli minu isa → , oli; before its subject instead when that stands right before the verb and cannot be the clause's own (Hommikul, kui ärkasin päike juba paistis → , päike). Otherwise that is where the comma goes at the latest; it may belong earlier, before a longer fronted subject or inside a split phrase.

  • comma-before-ja-after-subordinate-clause: before ja or ning when the main clause goes on after a kes or mis clause, told by the verbs' person: Juhtisin projekti, mis kestis kaks aastat ja koolitasin → , ja.

The last two read only words that cannot be anything but a verb, so a verb that is also a noun (tuli, sai, lõppes) is missed; ei in ei ... ega and in ei tea kus, a -vad participle after olema (kes olid sobivad) and on in an English name (video on demand) are not counted. A line break, a table cell edge (| or a tab), an HTML tag, an arrow or a quotation mark ends the clause. Not checked: the comma before kui, mis or kes (it depends on meaning), apposition commas, dashes, colons. A comma before ja in a list and a letter's greeting and closing commas are check_translationese's.

Inputs: text (required). Returns: issues, summary_estonian

check_redundancyA
Read-onlyIdempotent

Flags redundant doubling (liiasus, pleonasm):

  • doubled-also: two "also" particles together (samuti ka, ka samuti, ühtlasi ka); keep one.

  • double-superlative: kõige before an absolute adjective (kõige optimaalsem, "most optimal"); drop kõige.

  • fixed-pleonasm: a short curated list (ajaline periood, väike nüanss, üldine konsensus).

Each issue's explanation gives the reason in Estonian. Conservative: it misses much redundancy a native speaker would hear.

Inputs: text (required). Returns: issues, summary_estonian

check_styleA
Read-onlyIdempotent

Heuristic Estonian style metrics; no cliche detection.

  • repetition: content lemmas used threshold+ times (scales with length), with character offsets.

  • passive_voice: umbisikuline tegumood share of verbs (attributive -tud participles go to attributive_excluded). Marketing copy: aim under 15%; under 5% may read forceful. Reports: over 40% is the clearest kantseliit sign (see check_officialese).

  • sentence_length: words per sentence; a stddev under 30% of the mean reads monotonous. News and web text: at most 10 to 15 words a sentence (the state's web-writing guide). Measured averages: e-mail about 9, news about 14, statutes about 25.

  • hedging: share of words on a short fixed list (vist, pigem, ehk); over 5% reads wishy-washy, 0% does not rule hedging out.

Inputs: text (required). Returns: hedging, repetition, passive_voice, sentence_length

check_term_consistencyA
Read-onlyIdempotent

Flag a document that names one thing several ways (andmestik, teadusandmestik, pildiandmestik).

Rules: shared-compound-head (a bare noun plus a compound on it, or 3+ lemmas sharing a head) and shared-wordnet-synset (two of the 40 most frequent nouns share a WordNet synset). Each group gives variants with counts and dominant, the most used. Some groups are distinct concepts and the tool does not pick the right term: read each first.

degraded: true means WordNet is missing and the synset rule did not run: no groups is then no proof of consistency.

With a domain glossary (the server's or glossary), variants carry in_domain_glossary, and a group's only listed variant is its preferred term, whatever dominant says (several listed suggest distinct concepts).

Misses synonyms sharing neither head nor synset (korpus / andmestik): compare their synonyms definitions.

Inputs: text (required), glossary. Returns: groups, degraded, terms_analysed, summary_estonian

check_translationeseA
Read-onlyIdempotent

Flag English structure that makes Estonian read as translated. Run it on Estonian you wrote or translated.

Rules: oma-possessive (saatke meile teie andmed → oma andmed), pronoun-after-verb (lähtume me → lähtume), subject-pronoun (a third of the sentences open with Ma or Me; once), verb-second (Kui ..., me saadame → saadame), saama-future (saab olema → on), maks-infinitive (ettepanek võtmaks → võtta), maks-purpose (Tagamaks → et tagada), mitte-des (Mitte leides → Leidmata), tanu-negative (tänu + a bad cause → tõttu), english-phrase (minu arvamusel), greeting-punctuation (Hea Mari, → Hea Mari!; Tere Mari → Tere, Mari), closing-comma (Lugupidamisega,), serial-comma (teed, ja küpsiseid), title-case (Meie Teenused Ja Hinnad).

maks-purpose and subject-pronoun are style hints. Third-person possessives, negated verbs and questions are not checked. Accepted Estonian is never flagged (aset leidma, rolli mängima, Eile ma läksin, a capital Teie to one reader). Letter formulas such as Palun leidke manuses are check_officialese's.

Inputs: text (required). Returns: issues, summary_estonian

classify_registerA
Read-onlyIdempotent

Heuristic Estonian register score: a directional hint, not a verdict. Most everyday prose scores neutral, and address forms (sina/teie) are not scored.

score runs from -1 (colloquial) to 1 (formal); tier_estonian is the correct Estonian label to quote (formaalne, never *formalne). consistency.is_mixed: formal and colloquial markers both occur, which jars even when the tier is neutral. structure adds up to 0.4 (applied) for umbisikuline tegumood and noun density, from 25 words up and never on net-colloquial text. For a per-issue kantseliit breakdown use check_officialese.

Inputs: text (required). Returns: tier, score, structure, word_count, +4 more

lemmatizeA
Read-onlyIdempotent

Lemma (dictionary form) of each word, from its most likely analysis. Punctuation is omitted.

Inputs: text (required). Returns: result

named_entitiesA
Read-onlyIdempotent

People, places and organisations (type PER, LOC, ORG) with character offsets start and end. text is the span as written, often inflected (Tallinnas).

Inputs: text (required). Returns: result

paradigmA
Read-onlyIdempotent

Inflection paradigm of one Estonian word from Vabamorf, which generates what is possible, not necessarily idiomatic.

Nominals: up to 28 forms, 14 cases in singular and plural (iga has no plural), plus the short illative adt (majja beside majasse) where it exists. Verbs: about 39 common forms, impersonal included, not all Vabamorf can make. A word that does not inflect gets empty forms and a summary_estonian saying why.

forms entries: form (Vabamorf code), form_estonian (its Estonian name), surface. A list surface holds correct variants, any built on this paradigm's own stem first (raamatutele before the literary raamatuile).

Both illatives are correct and the short illative is often the commoner: never "correct" one into the other. adt is usually spelled like the singular partitive sg p (vend: venda), so a surface in this table does not confirm its case in a sentence.

paradigm_count > 1 means several inflection types (kott: koti or kota): forms is the first-ranked, named by paradigm_key (its singular genitive), and the rest are in other_paradigms, which give form_estonian only for a code forms lacks. Read ambiguity_estonian before quoting a form. Pass an inflected form (koti) to select the type you mean.

Inputs: word (required). Returns: forms, lemma, invariant, word_class, +11 more

pos_tagA
Read-onlyIdempotent

Part-of-speech tag of each word (most likely reading); punctuation omitted.

S noun, H proper noun, V verb, A adjective (C comparative, U superlative, G indeclinable), P pronoun, D adverb, K adposition, J conjunction, N cardinal, O ordinal, I interjection, Y abbreviation or symbol (§, €), X verb-bound word (plehku), Z a word of 40+ characters, too long for Vabamorf to analyse.

Inputs: text (required). Returns: result

spell_checkA
Read-onlyIdempotent

Spell-check Estonian text. Lists only the misspelled tokens, each occurrence in text order: text, spelling: false, and suggestions when Vabamorf has any. An empty list means every word passed.

Passing proves only that a word is well-formed: Vabamorf accepts any valid compound, even an invented one (toortõlkeoht). Check a compound you coined with check_compound_familiarity.

Inputs: text (required), suggestions. Returns: result

syllabifyA
Read-onlyIdempotent

Lowercased syllables of one Estonian word; quantity is the välde (1-3), accent 1 marks stress. Vabamorf's guesser syllabifier: it can err even on common words.

Inputs: word (required). Returns: result

synonymsA
Read-onlyIdempotent

Estonian WordNet synsets for a word, one per sense, each with lemmas (the synonyms), any definition and any examples. synset_count is the total before max_synsets cuts the list.

For "is this the right word here?", read each definition against the context, not just lemmas. A gloss naming a medium, field or material limits where the word fits: korpus is "kirjaliku või suulise teksti elektrooniline kogu", so a set of images is not a korpus, while andmestik has no such limit. Register is a different question: check_officialese, classify_register.

Inputs: word (required), max_synsets. Returns: synsets, synset_count

tokenizeA
Read-onlyIdempotent

Split Estonian text into sentences and words (every token in order, punctuation included).

Inputs: text (required). Returns: words, sentences

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 28 tools

    Disambiguation4/5

    Tool boundaries are unusually well signposted: descriptions explicitly cross-reference siblings (find_related_words vs synonyms, check_officialese vs check_legalese, check_style vs check_translationese, check_compound_familiarity vs check_domain_terms). The only residual overlap is among the register/prose tools (check_style, check_officialese, classify_register) which touch similar metrics like impersonal voice and noun density, but the text guides selection by genre.

    Naming Consistency4/5

    Mostly a predictable snake_case scheme with check_* for every linting tool, which makes the large check family scannable. Deviations are minor: bare-verb analysis tools (tokenize, lemmatize, syllabify, paradigm) and the reversed spell_check rather than check_spelling.

    Tool Count3/5

    At 28 tools this is on the heavy side, though the domain (Estonian morphology, orthography, style, legal drafting) is genuinely broad and each check targets a distinct phenomenon. Still, the surface could likely be consolidated (e.g. merging the many narrow legal checks) without losing capability.

    Completeness4/5

    Covers the full language-tooling lifecycle: tokenize, morph analysis, lemma/POS, paradigm generation, syllabify, hyphenation, spell check, NER, plus a deep set of orthography/style/legal checks. Minor gaps remain, e.g. no syntax/agreement parsing and no general grammar-check for sentence structure beyond the curated rule lists.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers