# com.valksor/hub (remote · mcp.valksor.com)

One MCP endpoint over every Valksor dictionary: namespaced tools plus a JSON passthrough.

- Trust score: 76/100 (medium)
- Change this week: +7
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `mcp.valksor.com`: 76/100 (this document), [markdown](https://verifymcp.io/servers/com-valksor-hub/mcp.md), [page](https://verifymcp.io/servers/com-valksor-hub/mcp)

## Channel facts

- Endpoint: `https://mcp.valksor.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `2.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 83/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 69/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 8765 tokens (~324/item across 27 items; 27 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http com-valksor-hub https://mcp.valksor.com/mcp
```

### Codex

```toml
[mcp_servers.com-valksor-hub]
url = "https://mcp.valksor.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-valksor-hub": {
      "type": "remote",
      "url": "https://mcp.valksor.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-valksor-hub --url https://mcp.valksor.com/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-valksor-hub:
    url: "https://mcp.valksor.com/mcp"
```

### Other

```json
{
  "mcpServers": {
    "com-valksor-hub": {
      "type": "http",
      "url": "https://mcp.valksor.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 75, +4)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-29 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 69, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 68)

First indexed and scored.

## MCP tools (27)

### `dictionaries` (~134 tokens)

Index of every Valksor dictionary reachable through this hub and its CURRENT tool and prompt names (each named <language>_<verb>). Call this to discover or re-check names — e.g. after an 'unknown tool'/'unknown prompt' error. The optional `language` argument narrows the result to one dictionary by its id (the prefix before the first underscore). Each entry's `host` is that dictionary's public site, for reference only — you still reach its tools through this hub by their listed names, not via that host.

Input parameters:

- `language` (string): Restrict the index to one dictionary by its id.

Output parameters:

- `dictionaries` (array)

### `livonian_search` (~669 tokens)

Search the Livonian dictionary

Look a word up in the real Livonian–Estonian–Latvian dictionary and return only
attested content, so translations are grounded, not invented.

Search a meaning (in English/Latvian/Estonian) to find the Livonian headword, or a
Livonian word to confirm it exists and read its sense, part of speech and examples.
See the `query` and `search_language` parameter docs for how to phrase a query. By
default each match's full inflection table is returned inline, so one call usually
suffices; on a broad query only the first N tables expand (the rest are listed as
handles to fetch with livonian_get_inflections). Returns Markdown plus the same result as
structuredContent matching the declared outputSchema.

Results are cached server-side, so repeating a query is instant and free; a
first-time query reaches the live dictionary and calls are rate limited — on a
rate-limit error, wait a few seconds and retry instead of re-issuing immediately.
Dictionary content is from livonian.tech (CC BY-SA 4.0 — attribute if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full inflection table is returned INLINE — usable cases/tenses in ONE call, no follow-up livonian_get_inflections. Set false to get just the headword handles + gloss…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). Raise it to pull more tables in ONE call on a broad query, or set a small value to keep a broad query cheap. On an uncache…
- `query` (string, required): A SINGLE content word, not a phrase. Exactly one word per call — even with several candidates or synonyms in mind, search them one at a time ('see', then 'look'), never combined into one query like '…
- `search_language`: Language your query word is in — selects which language the search matches against: 'eng' (default), 'liv', 'lat', or 'est'. For English→Livonian translation, keep 'eng'. Glosses are in English.

Output parameters:

- `entries` (array): Structured dictionary entries: headword, pronunciation, part of speech, paradigm anchors, and senses with example sentences.
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached. Refine the query or call livonian_get_inflections.
- `found` (boolean): False when nothing matched.
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original inflected query when search_method='lemma_index'; empty on a direct match.
- `resolved_lemma` (string): The dictionary lemma actually searched when search_method='lemma_index'; empty on a direct match.
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = the query was an inflected Livonian form, resolved to its dictionary lemma via the cached paradigm index and re-searched.
- `source` (string)

### `livonian_get_inflections` (~406 tokens)

Get Livonian inflection table

Fetch the full declension (nouns) or conjugation (verbs) table for a word
identified by a search result's inflection handle (entry_id + word_class) — the
exact case, number, tense, not a guessed ending. Use this only when a search ran
without inline forms, or to fetch a match a broad search left un-expanded. Never a
first call — the handle values only come from livonian_search results, and a
default search already returns each match's table inline, so calling this
afterwards just re-fetches what you have.

Returns Markdown — a nominal gets one case × {singular, plural} table; a verb gets a table
per mood/tense (person × {affirmative, negative}, the negation auxiliary folded
into the negative) plus its principal-parts and participle lists — or a clean
not-found message. (Grammatical labels are normalised to English; Livonian forms
stay verbatim.) The same table rides along as structuredContent with the shape
{"result": <paradigm>} per the declared outputSchema — switch on
result.category ('nominal' | 'verbal' | 'not_found') before reading the body.
Results are cached server-side (repeats are instant) and
calls are rate limited — on a rate-limit error, wait a few seconds and retry.
Table content is from livonian.tech (CC BY-SA 4.0 — attribute if republished).

Input parameters:

- `entry_id` (required): The word id from a search result's inflection handle. Accepts a number or a digit-string (e.g. 17746 or "17746").
- `word_class` (string, required): The word-class code from a search result's inflection handle (e.g. 's' = noun, 'adj' = adjective, 'vi' = intransitive verb, 'vt' = transitive verb).

Output parameters:

- `result`

### `livonian_romanize` (~216 tokens)

Romanize Livonian to clean ASCII

Strip Livonian orthography down to clean, pronounceable ASCII for an
English-trained downstream (a voice/TTS, a search box). See the `text` parameter
doc for the exact letter mappings. Returns Markdown plus the romanized output as
structuredContent matching the declared outputSchema. Pure local transform: no
dictionary lookup, no network, and the output is always ASCII.

Input parameters:

- `text` (string, required): Livonian text to reduce to clean, pronounceable ASCII. Strips macrons, diacritics and capitals (ā→aa, š→sh, õ→u), softens a palatalized consonant (ņ ļ ŗ ţ ḑ) only before a vowel (ņ+a→nya, else ikšigg…

Output parameters:

- `text` (string): The romanized ASCII output.

### `livonian_deromanize` (~226 tokens)

Find the Livonian word(s) matching a romanized spelling

Find the real Livonian word(s) whose pronunciation-romanization matches this
clean-ASCII input — the inverse direction of `livonian_romanize`. Because
romanize is lossy, this is a LOOKUP against the words already in the dictionary
cache: attested spellings come back as source=dictionary. If none match, a single
best-effort reconstruction is returned (source=reconstruction, approximate=true) —
a guess, not attested. Coverage grows as words are cached, so an identical query
may return a reconstruction now and a dictionary hit later.

Input parameters:

- `text` (string, required): Romanized (clean-ASCII) Livonian text to resolve back to real orthography. Returns the attested dictionary spelling(s) whose romanization matches (source=dictionary, exact) — several may match one am…

Output parameters:

- `approximate` (boolean)
- `candidates` (array)

### `latin_search` (~509 tokens)

Look a Latin word up

Look a Latin word up on Wiktionary and return its senses plus full
declension/conjugation tables — attested content, not invented. Any form of
the word works; an inflected query is resolved to its lemma automatically
(via previously cached paradigms or the Morpheus analyzer) and the result
notes the resolution. With search_language='eng' the query is an English
word instead: the result lists its per-sense Latin equivalents (the
translations block) plus their expanded entries. Returns Markdown plus the
same result as structuredContent matching the declared outputSchema.

Results are cached server-side; first-time queries reach the live upstream
politely and calls are rate limited — on a rate-limit error, wait a few
seconds and retry. Content is from en.wiktionary.org (CC BY-SA 4.0 —
attribute and share alike if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full declension/conjugation table is returned INLINE — usable cases/tenses in ONE call, no follow-up latin_get_inflections. Set false for a cheap screen of which ent…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). On an uncached query each table is one politely paced upstream fetch, so high values on cold queries are slow. Omit for th…
- `query` (string, required): The word to look up, in the language search_language names. Latin (default): a SINGLE word, any form — an inflected form ('amavit') is resolved to its lemma ('amo') automatically, and the result name…
- `search_language`: Language the query word is in: 'lat' (default) looks the Latin word up directly; 'eng' finds the Latin equivalents of an English word (per-sense, from Wiktionary's translation tables) and returns the…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means Latin translations were found — entries may still be empty when none of them could be expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The query whose lemma this result names (paired with resolved_lemma); else empty. lat queries only (always empty for eng). Set both when an inflected miss was re-searched (search_method lemma_index/m…
- `resolved_lemma` (string): The lemma this query maps to; else empty. lat queries only. With search_method 'lemma_index'/'morpheus' the entries below ARE this lemma's; with 'direct' the entries are the queried form-of stub and…
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = an inflected form resolved via a previously cached paradigm; 'morpheus' = resolved via the Morpheus morphological analyze…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for lat): the Latin terms each English sense translates to, in sense order. Entries/handles below are the expanded dictionary entries of those terms.
- `translations_truncated` (integer): How many distinct translated lemmas were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `latin_get_inflections` (~213 tokens)

Get a Latin inflection table

Fetch the full declension (nominals) or conjugation (verbs) table for a
lemma identified by a search result's inflection handle (entry_id +
word_class). Use this only when a search ran without inline forms or left a
match un-expanded — a default search already returns each match's table
inline. Returns Markdown plus the table as structuredContent with the shape
{"result": <paradigm>} per the declared outputSchema — switch on
result.category ('nominal' | 'verbal' | 'not_found') before reading the body.
Content from en.wiktionary.org (CC BY-SA 4.0).

Input parameters:

- `entry_id` (string, required): The Wiktionary page title (the lemma) from a search result's inflection handle, e.g. 'amo', 'aqua'.
- `word_class` (string, required): The part-of-speech section from a search result's inflection handle, e.g. 'verb', 'noun', 'adjective'.

Output parameters:

- `result`

### `latin_lemmatize` (~139 tokens)

Morphologically analyze a Latin form

Analyze one inflected Latin form with the Morpheus morphological
analyzer: its lemma(s) plus the grammatical reading (person, number, tense,
mood, voice, case…). Useful when you want the morphology itself — for the
dictionary entry, latin_search already resolves inflected queries on its
own. Returns Markdown plus the analysis as structuredContent matching the
declared outputSchema. Results are cached server-side. Analyses via the
Perseids Morpheus service.

Input parameters:

- `word` (string, required): One inflected Latin word form to analyze, e.g. 'amavit', 'aquam'. Macrons optional.

Output parameters:

- `analyses` (array)
- `found` (boolean)
- `source` (string)
- `word` (string)

### `slavonic_search` (~546 tokens)

Look a Church Slavonic word up

Look an Old Church Slavonic word up on Wiktionary and return its senses
plus full declension/conjugation tables — attested content (singular, dual
and plural), not invented. Any form of the word works; an inflected query
is resolved to its lemma automatically via previously cached paradigms and
the result notes the resolution. With search_language='eng' the query is
an English word instead: the result lists its per-sense Old Church
Slavonic equivalents (the translations block) plus their expanded entries.
Returns Markdown plus the same result as structuredContent matching the
declared outputSchema.

Results are cached server-side; first-time queries reach the live upstream
politely and calls are rate limited — on a rate-limit error, wait a few
seconds and retry. Content is from en.wiktionary.org (CC BY-SA 4.0 —
attribute and share alike if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full declension/conjugation table is returned INLINE — usable cases/tenses (singular, dual AND plural) in ONE call, no follow-up slavonic_get_inflections. Set false…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). On an uncached query each table is one politely paced upstream fetch, so high values on cold queries are slow. Omit for th…
- `query` (string, required): The word to look up, in the language search_language names. Church Slavonic (default): a SINGLE Old Church Slavonic word in Cyrillic, any form — an inflected form ('бога') is resolved to its lemma ('…
- `search_language`: Language the query word is in: 'chu' (default) looks the Old Church Slavonic word up directly; 'eng' finds the OCS equivalents of an English word (per-sense, from Wiktionary's translation tables) and…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means Old Church Slavonic translations were found — entries may still be empty when none of them could be expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original inflected query when resolved; else empty. chu queries only — always empty for eng results.
- `resolved_lemma` (string): The lemma actually searched when resolved; else empty. chu queries only — always empty for eng results.
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = an inflected form resolved via a previously cached paradigm; 'translations' = an English query resolved via Wiktionary tr…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for chu): the OCS terms each English sense translates to, in sense order. Entries/handles below are the expanded dictionary entries of those terms.
- `translations_truncated` (integer): How many distinct translated lemmas were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `slavonic_get_inflections` (~219 tokens)

Get a Church Slavonic inflection table

Fetch the full declension (nominals) or conjugation (verbs) table for a
lemma identified by a search result's inflection handle (entry_id +
word_class). Use this only when a search ran without inline forms or left a
match un-expanded — a default search already returns each match's table
inline. Returns Markdown plus the table as structuredContent with the shape
{"result": <paradigm>} per the declared outputSchema — switch on
result.category ('nominal' | 'verbal' | 'not_found') before reading the body.
Content from en.wiktionary.org (CC BY-SA 4.0).

Input parameters:

- `entry_id` (string, required): The Wiktionary page title (the Cyrillic lemma) from a search result's inflection handle, e.g. 'богъ', 'глаголати'.
- `word_class` (string, required): The part-of-speech section from a search result's inflection handle, e.g. 'verb', 'noun', 'adjective'.

Output parameters:

- `result`

### `slavonic_transliterate` (~191 tokens)

Transliterate Church Slavonic to scientific Latin

Render Church Slavonic — Cyrillic or Glagolitic — in the scientific
Latin transliteration Wiktionary uses (богъ → bogŭ, ⰱⱁⰳⱏ → bogŭ).
Liturgical reading marks (titlos, accents) are dropped and late Church
Slavonic spellings folded, so copied liturgical text works as-is. Returns
Markdown plus the transliterated output as structuredContent matching the
declared outputSchema. Pure local transform: no dictionary lookup and no
network.

Input parameters:

- `text` (string, required): Church Slavonic text to transliterate — Cyrillic and/or Glagolitic, one word or whole lines. Liturgical reading marks (titlos, accents, breathings) are dropped and late Church Slavonic spellings fold…

Output parameters:

- `text` (string): The scientific transliteration.

### `slavonic_detransliterate` (~283 tokens)

Find the Church Slavonic word(s) matching a Latin transliteration

Find the real Church Slavonic word(s) whose scientific-Latin transliteration
matches this input — the inverse direction of `slavonic_transliterate`. Because
transliterate is lossy, this is a LOOKUP against the words already in the
dictionary cache: attested spellings (normalized OCS Cyrillic) come back as
source=dictionary. If none match, a single best-effort reconstruction is returned
(source=reconstruction, approximate=true) — a guess in normalized OCS Cyrillic, not
attested, with no Glagolitic or liturgical marks. Coverage grows as words are
cached, so an identical query may return a reconstruction now and a dictionary hit
later.

Input parameters:

- `text` (string, required): Scientific-Latin transliteration of Church Slavonic to resolve back to real orthography. Returns the attested dictionary spelling(s) whose transliteration matches (source=dictionary, exact) — several…

Output parameters:

- `approximate` (boolean)
- `candidates` (array)

### `scythian_search` (~539 tokens)

Look a Proto-Scythian word up

Look a Proto-Scythian lemma up on Wiktionary and return its senses plus
its full descendants payload — the reconstructed etymology and the reflex
tree down to Ossetian and Khotanese, attested scholarship, not invention.
Plain ASCII spellings are folded to the reconstruction's diacritics and
the result notes the resolution. With search_language='eng' the query is
an English word instead: the result lists the lemmas whose glosses match
it (the translations block) plus their expanded entries. Returns Markdown
plus the same result as structuredContent matching the declared
outputSchema.

Results are cached server-side; first-time queries reach the live
upstream politely and calls are rate limited — on a rate-limit error,
wait a few seconds and retry. Content is from en.wiktionary.org
(CC BY-SA 4.0 — attribute and share alike if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full descendants payload — etymology, glosses and the reflex tree down to Ossetian and Khotanese — is returned INLINE in ONE call, no follow-up scythian_get_descenda…
- `max_forms`: Optional override for how many descendants payloads to expand this call (0–12). On an uncached query each payload is one politely paced upstream fetch, so high values on cold queries are slow. Omit f…
- `query` (string, required): The word to look up, in the language search_language names. Scythian (default): a SINGLE Proto-Scythian lemma — plain ASCII works ('tigri' finds *tiɣri: macrons and carons are folded, and ɣ→g, δ→d, β…
- `search_language`: Language the query word is in: 'xsc' (default) looks the Proto-Scythian lemma up directly; 'eng' finds the lemmas whose English glosses match the query (the local gloss index — reconstructed language…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline descendants payload because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means the gloss index named Proto-Scythian lemmas — entries may still be empty when none of them could be expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original query when resolved via the index; else empty. xsc queries only — always empty for eng results.
- `resolved_lemma` (string): The lemma actually searched when resolved; else empty. xsc queries only — always empty for eng results.
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = an ASCII/diacritic-folded spelling resolved via the reverse index; 'translations' = an English query resolved via the loc…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for xsc): the Proto-Scythian lemmas whose glosses match the query. Entries/handles below are the expanded dictionary entries of those lemmas.
- `translations_truncated` (integer): How many distinct matched lemmas were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `scythian_get_descendants` (~239 tokens)

Get a Proto-Scythian entry's descendants

Fetch the full descendants payload — etymology, glosses and the reflex
tree (Sarmatian→Alanic→Ossetian, Saka→Khotanese) — for a lemma identified
by a search result's descendant handle (entry_id + word_class). Use this
only when a search ran without inline payloads or left a match
un-expanded — a default search already returns each match's payload
inline. Returns Markdown plus the payload as structuredContent with the
shape {"result": <payload>} per the declared outputSchema — switch on
result.category ('descendants' | 'not_found') before reading the body.
Content from en.wiktionary.org (CC BY-SA 4.0).

Input parameters:

- `entry_id` (string, required): The bare lemma (no asterisk) from a search result's descendant handle, e.g. 'tiɣri', 'baga' — a typed leading asterisk is tolerated.
- `word_class` (string, required): The part-of-speech section from a search result's descendant handle, e.g. 'noun', 'adjective', 'proper noun'.

Output parameters:

- `result`

### `norse_search` (~552 tokens)

Look an Old Norse word up

Look an Old Norse word up on Wiktionary and return its senses plus full
declension/conjugation tables — attested content (including the verbs'
mediopassive voice), not invented. Any form of the word works; an
inflected query is resolved to its lemma automatically via previously
cached paradigms and the result notes the resolution. With
search_language='eng' the query is an English word instead: the result
lists its per-sense Old Norse equivalents (the translations block) plus
their expanded entries. Returns Markdown plus the same result as
structuredContent matching the declared outputSchema.

Results are cached server-side; first-time queries reach the live upstream
politely and calls are rate limited — on a rate-limit error, wait a few
seconds and retry. Content is from en.wiktionary.org (CC BY-SA 4.0 —
attribute and share alike if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full declension/conjugation table is returned INLINE — usable cases/tenses (and the verbs' mediopassive voice) in ONE call, no follow-up norse_get_inflections. Set f…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). On an uncached query each table is one politely paced upstream fetch, so high values on cold queries are slow. Omit for th…
- `query` (string, required): The word to look up, in the language search_language names. Old Norse (default): a SINGLE Old Norse word, any form — an inflected form ('mǫnnum') is resolved to its lemma ('maðr') automatically via c…
- `search_language`: Language the query word is in: 'non' (default) looks the Old Norse word up directly; 'eng' finds the Old Norse equivalents of an English word (per-sense, from Wiktionary's translation tables) and ret…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means Old Norse translations were found — entries may still be empty when none of them could be expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original inflected query when resolved; else empty. non queries only — always empty for eng results.
- `resolved_lemma` (string): The lemma actually searched when resolved; else empty. non queries only — always empty for eng results.
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = an inflected form resolved via a previously cached paradigm; 'translations' = an English query resolved via Wiktionary tr…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for non): the Old Norse terms each English sense translates to, in sense order. Entries/handles below are the expanded dictionary entries of those terms.
- `translations_truncated` (integer): How many distinct translated lemmas were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `norse_get_inflections` (~224 tokens)

Get an Old Norse inflection table

Fetch the full declension (nominals) or conjugation (verbs — active AND
mediopassive) tables for a lemma identified by a search result's inflection
handle (entry_id + word_class). Use this only when a search ran without
inline forms or left a match un-expanded — a default search already returns
each match's table inline. Returns Markdown plus the table as
structuredContent with the shape {"result": <paradigm>} per the declared
outputSchema — switch on result.category ('nominal' | 'verbal' |
'not_found') before reading the body. Content from en.wiktionary.org
(CC BY-SA 4.0).

Input parameters:

- `entry_id` (string, required): The Wiktionary page title (the lemma) from a search result's inflection handle, e.g. 'maðr', 'kasta'.
- `word_class` (string, required): The part-of-speech section from a search result's inflection handle, e.g. 'verb', 'noun', 'adjective'.

Output parameters:

- `result`

### `latgalian_search` (~518 tokens)

Look a Latgalian word up

Look a Latgalian word up on Wiktionary and return its senses plus full
declension/conjugation tables — attested content, not invented. Any form of
the word works; an inflected query is resolved to its lemma automatically
via previously cached paradigms and the result notes the resolution. With
search_language='eng' the query is an English word instead: the result
lists its per-sense Latgalian equivalents (the translations block) plus
their expanded entries. Returns Markdown plus the same result as
structuredContent matching the declared outputSchema.

Results are cached server-side; first-time queries reach the live upstream
politely and calls are rate limited — on a rate-limit error, wait a few
seconds and retry. Content is from en.wiktionary.org (CC BY-SA 4.0 —
attribute and share alike if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full declension/conjugation table is returned INLINE — usable cases/tenses in ONE call, no follow-up latgalian_get_inflections. Set false for a cheap screen of which…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). On an uncached query each table is one politely paced upstream fetch, so high values on cold queries are slow. Omit for th…
- `query` (string, required): The word to look up, in the language search_language names. Latgalian (default): a SINGLE Latgalian word, any form — an inflected form ('akmiņa') is resolved to its lemma ('akmiņs') automatically via…
- `search_language`: Language the query word is in: 'ltg' (default) looks the Latgalian word up directly; 'eng' finds the Latgalian equivalents of an English word (per-sense, from Wiktionary's translation tables) and ret…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means Latgalian translations were found — entries may still be empty when none of them could be expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original inflected query when resolved; else empty. ltg queries only — always empty for eng results.
- `resolved_lemma` (string): The lemma actually searched when resolved; else empty. ltg queries only — always empty for eng results.
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = an inflected form resolved via a previously cached paradigm; 'translations' = an English query resolved via Wiktionary tr…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for ltg): the Latgalian terms each English sense translates to, in sense order. Entries/handles below are the expanded dictionary entries of those terms.
- `translations_truncated` (integer): How many distinct translated lemmas were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `latgalian_get_inflections` (~223 tokens)

Get a Latgalian inflection table

Fetch the full declension (nominals) or conjugation (verbs — positive AND
negative) tables for a lemma identified by a search result's inflection
handle (entry_id + word_class). Use this only when a search ran without
inline forms or left a match un-expanded — a default search already returns
each match's table inline. Returns Markdown plus the table as
structuredContent with the shape {"result": <paradigm>} per the declared
outputSchema — switch on result.category ('nominal' | 'verbal' |
'not_found') before reading the body. Content from en.wiktionary.org
(CC BY-SA 4.0).

Input parameters:

- `entry_id` (string, required): The Wiktionary page title (the lemma) from a search result's inflection handle, e.g. 'akmiņs', 'byut'.
- `word_class` (string, required): The part-of-speech section from a search result's inflection handle, e.g. 'verb', 'noun', 'adjective'.

Output parameters:

- `result`

### `latgalian_romanize` (~233 tokens)

Romanize Latgalian to clean ASCII

Strip Latgalian orthography down to clean, pronounceable ASCII for an
English-trained downstream (a voice/TTS, a search box). See the `text`
parameter doc for the exact letter mappings. Returns Markdown plus the
romanized output as structuredContent matching the declared outputSchema.
Pure local transform: no dictionary lookup, no network, and the output is
always ASCII.

Input parameters:

- `text` (string, required): Latgalian text to reduce to clean, pronounceable ASCII. Lowercases and maps each special letter to an English-readable spelling: the macron vowels double (ā→aa, ē→ee, ī→ee, ō→o, ū→oo), the caron cons…

Output parameters:

- `text` (string): The romanized ASCII output.

### `latgalian_deromanize` (~258 tokens)

Find the Latgalian word(s) matching a romanized spelling

Find the real Latgalian word(s) whose pronunciation-romanization matches this
clean-ASCII input — the inverse direction of `latgalian_romanize`. Because
romanize is lossy, this is a LOOKUP against the words already in the dictionary
cache: attested spellings come back as source=dictionary. If none match, a single
best-effort reconstruction is returned (source=reconstruction, approximate=true) —
a guess, not attested. Coverage grows as words are cached, so an identical query
may return a reconstruction now and a dictionary hit later.

Input parameters:

- `text` (string, required): Romanized (clean-ASCII) Latgalian text to resolve back to real orthography. Returns the attested dictionary spelling(s) whose romanization matches (source=dictionary, exact) — several may match one a…

Output parameters:

- `approximate` (boolean)
- `candidates` (array)

### `anglo_search` (~534 tokens)

Look an Old English word up

Look an Old English word up on Wiktionary and return its senses plus full
declension/conjugation tables — attested content, not invented. Any form of
the word works; an inflected query is resolved to its lemma automatically
via previously cached paradigms and the result notes the resolution. With
search_language='eng' the query is a modern English word instead: the
result lists its per-sense Old English equivalents (the translations block)
plus their expanded entries. Returns Markdown plus the same result as
structuredContent matching the declared outputSchema.

Results are cached server-side; first-time queries reach the live upstream
politely and calls are rate limited — on a rate-limit error, wait a few
seconds and retry. Content is from en.wiktionary.org (CC BY-SA 4.0 —
attribute and share alike if republished).

Input parameters:

- `include_forms` (boolean): When true (default), each match's full declension/conjugation table is returned INLINE — usable cases/tenses (nouns, the adjectives' strong/weak family, the verbs' moods, the pronouns' dual) in ONE c…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). On an uncached query each table is one politely paced upstream fetch, so high values on cold queries are slow. Omit for th…
- `query` (string, required): The word to look up, in the language search_language names. Old English (default): a SINGLE Old English word, any form — an inflected form ('bindaþ') is resolved to its lemma ('bindan') automatically…
- `search_language`: Language the query word is in: 'ang' (default) looks the Old English word up directly; 'eng' finds the Old English equivalents of a modern English word (per-sense, from Wiktionary's translation table…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means Old English translations were found — entries may still be empty when none of them could be expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original inflected query when resolved; else empty. ang queries only — always empty for eng results.
- `resolved_lemma` (string): The lemma actually searched when resolved; else empty. ang queries only — always empty for eng results.
- `search_method` (string): How the match was found: 'direct' = the query itself matched; 'lemma_index' = an inflected form resolved via a previously cached paradigm; 'translations' = an English query resolved via Wiktionary tr…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for ang): the Old English terms each English sense translates to, in sense order. Entries/handles below are the expanded dictionary entries of those terms.
- `translations_truncated` (integer): How many distinct translated lemmas were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `anglo_get_inflections` (~229 tokens)

Get an Old English inflection table

Fetch the full declension (nominals, including the pronouns' dual) or
conjugation (verbs) table for a lemma identified by a search result's
inflection handle (entry_id + word_class). Use this only when a search ran
without inline forms or left a match un-expanded — a default search already
returns each match's table inline. Returns Markdown plus the table as
structuredContent with the shape {"result": <paradigm>} per the declared
outputSchema — switch on result.category ('nominal' | 'verbal' |
'not_found') before reading the body. Content from en.wiktionary.org
(CC BY-SA 4.0).

Input parameters:

- `entry_id` (string, required): The Wiktionary page title (the lemma) from a search result's inflection handle, e.g. 'cyning', 'bindan'.
- `word_class` (string, required): The part-of-speech section from a search result's inflection handle, e.g. 'verb', 'noun', 'adjective', 'pronoun'.

Output parameters:

- `result`

### `anglo_romanize` (~147 tokens)

Romanize Old English to clean ASCII

Reduce Old English orthography to its primary ASCII spelling (þing→thing,
wæter→waeter; macrons and the dotted ġ/ċ dropped) for an ASCII-keyboard
downstream. Pure local transform: no dictionary lookup, no network, always ASCII.

Input parameters:

- `text` (string, required): Old English text to reduce to its primary ASCII spelling. Drops macrons and the dotted ġ/ċ, and folds the special letters (þ/ð→th, æ→ae, ƿ→w, œ→oe): þing→thing, wæter→waeter. For an ASCII-keyboard do…

Output parameters:

- `text` (string): The primary ASCII spelling.

### `anglo_deromanize` (~212 tokens)

Find the Old English word(s) matching an ASCII spelling

Find the real Old English word(s) whose ASCII spelling matches this input — the
inverse of `anglo_romanize`. romanize is deeply lossy (th←þ or ð, dropped
macrons), so this is a LOOKUP against words already cached: attested spellings
come back as source=dictionary. If none match, a single best-effort reconstruction
(source=reconstruction, approximate=true) — a guess, not attested. Coverage grows
as words are cached.

Input parameters:

- `text` (string, required): ASCII-spelled Old English text to resolve back to real orthography. Returns the attested dictionary spelling(s) whose romanization matches (source=dictionary, exact) — several may match one ambiguous…

Output parameters:

- `approximate` (boolean)
- `candidates` (array)

### `interslavic_search` (~509 tokens)

Look an Interslavic word up

Look an Interslavic word up in the bundled community dictionary and return
its translation matrix (English + 11 Slavic languages) plus its full,
algorithmically-generated declension/conjugation table. Any form and either
script works; an inflected query resolves to its headword and the result notes
it. With search_language='eng' the query is an English word: the result lists
its Interslavic equivalents plus their expanded entries. Returns Markdown plus
the same result as structuredContent matching the declared outputSchema.

Fully offline (bundled snapshot); calls are rate limited per client IP.
Content: the Interslavic dictionary (van Steenbergen et al.); reuse licence
unconfirmed — attribute the source.

Input parameters:

- `include_forms` (boolean): When true (default), each match's full declension/conjugation table is returned INLINE — usable cases/tenses in ONE call, no follow-up interslavic_get_inflections. Set false for a cheap screen of whi…
- `max_forms`: Optional override for how many inflection tables to expand this call (0–12). Tables are served from the bundled dataset (no network), so this is cheap. Omit for the server default.
- `query` (string, required): The word to look up, in the language search_language names. Interslavic (default): a SINGLE Interslavic word, any form and either script — an inflected form ('brata') resolves to its headword ('brat'…
- `search_language`: Language the query is in: 'isv' (default) looks the Interslavic word up directly; 'eng' finds the Interslavic equivalents of an English word (via the gloss index) and returns their full entries. Thes…

Output parameters:

- `entries` (array)
- `forms_truncated` (integer): How many handles did NOT get an inline table because the per-search cap was reached.
- `found` (boolean): False when nothing matched. For an eng query, True means the gloss index named Interslavic words — entries may still be empty when none of them expanded (see translations).
- `handles` (array)
- `language`
- `query` (string)
- `resolved_from` (string): The original query when resolved via the index; else empty. isv queries only — always empty for eng results.
- `resolved_lemma` (string): The headword actually searched when resolved; else empty. isv queries only — always empty for eng results.
- `search_method` (string): How the match was found: 'direct' = the query matched a headword; 'lemma_index' = an inflected/alternate spelling resolved via the reverse form index; 'translations' = an English query resolved via t…
- `source` (string)
- `translations` (array): Populated only for eng queries (always [] for isv): the Interslavic words whose English gloss matched the query. Entries/handles below are the expanded entries of those words.
- `translations_truncated` (integer): How many distinct matched words were NOT expanded into entries because the per-search expansion cap was reached (they still appear under translations).

### `interslavic_get_inflections` (~220 tokens)

Get an Interslavic inflection table

Fetch the full declension (noun/adjective) or conjugation (verb) table for a
word identified by a search result's inflection handle (entry_id + word_class).
Use this only when a search ran without inline forms or left a match
un-expanded — a default search already returns each match's table inline.
Returns Markdown plus the table as structuredContent with the shape
{"result": <paradigm>} — switch on result.category ('noun' | 'adjective' |
'verb' | 'not_found') before reading the body. Tables are generated by the
official Interslavic morphology engine, not attested.

Input parameters:

- `entry_id` (string, required): The dictionary word id from a search result's inflection handle (a number, e.g. '33555') — NOT the headword itself (Interslavic homographs share a spelling).
- `word_class` (string, required): The paradigm class from a search result's inflection handle: 'noun', 'adjective' or 'verb'.

Output parameters:

- `result`

### `interslavic_transliterate` (~212 tokens)

Transliterate one Interslavic word between Latin and Cyrillic

Transliterate ONE Interslavic word between Latin and Cyrillic. This is
bidirectional: it auto-detects the input's script and returns the attested spelling
in the OTHER script — Latin input yields Cyrillic, Cyrillic input yields Latin (or
pass `target` to force it). Unlike the lossy deromanize tools, this is an EXACT
dataset lookup (both spellings are stored per entry): it never guesses — a word not
in the dataset returns empty candidates.

Input parameters:

- `target`: Force the output script (cyrillic|latin); omit to auto-detect.
- `text` (string, required): ONE Interslavic word (not a phrase — the lookup does not tokenize). Auto-detects the script and returns the attested spelling in the OTHER script (Latin↔Cyrillic). A word absent from the dataset, or…

Output parameters:

- `candidates` (array)
- `direction` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-valksor-hub/mcp#diagnostics

## Score history

- 2026-08-03: 76
- 2026-08-02: 75
- 2026-08-01: 75
- 2026-07-31: 75
- 2026-07-30: 71
- 2026-07-29: 70
- 2026-07-28: 69
- 2026-07-27: 69
- 2026-07-26: 68

## Links

- Remote endpoint: https://mcp.valksor.com/mcp
- Website: https://mcp.valksor.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-valksor-hub/mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-valksor-hub/mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/com-valksor-hub/mcp