# com.valksor/hub

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

- name: com.valksor/hub
- version: 2.0.0
- connection class: R0 (autonomous)
- trust: 75/100 flags: no-repository
- quality: 80/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/com.valksor%2Fhub
- tools: https://api.protogrid.dev/v1/servers/com.valksor%2Fhub/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

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


## Trust

- hygiene: 80
- liveness: 99
- freshness: 65
- provenance: 55
- drivers: +dns-namespace +website +reachable +uptime-98% ~updated-130d-ago -no-repository
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 80/100 (good)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 86 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 1 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 27 of 27 tools declare readOnlyHint or destructiveHint
- pass `tools.directory_hints`: every tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
- warn `tools.token_cost`: about 13,320 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 75 (weight 15)

- warn `stability.changes`: 16 tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 27, about 13,320 tokens to load them all
- tool set hash: 67bc37a2992ddf5fcf16ad03c4b8e63b
- tools last changed: 2026-10-13T15:48:15.374Z
- badge: [![protogrid quality](https://protogrid.dev/badge/com.valksor/hub.svg)](https://protogrid.dev/servers/com.valksor/hub)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

- 2026-10-13 `interslavic_get_inflections` changed (inputSchema)
- 2026-10-13 `anglo_get_inflections` changed (inputSchema, outputSchema)
- 2026-10-13 `anglo_search` changed (outputSchema)
- 2026-10-13 `latgalian_get_inflections` changed (inputSchema, outputSchema)
- 2026-10-13 `latgalian_search` changed (outputSchema)
- 2026-10-13 `norse_get_inflections` changed (inputSchema, outputSchema)
- 2026-10-13 `norse_search` changed (outputSchema)
- 2026-10-13 `scythian_get_descendants` changed (inputSchema, outputSchema)
- 2026-10-13 `scythian_search` changed (outputSchema)
- 2026-10-13 `slavonic_get_inflections` changed (inputSchema, outputSchema)

Full history: https://api.protogrid.dev/v1/servers/com.valksor%2Fhub/changes

## Remotes

- https://mcp.valksor.com/mcp (streamable-http, auth none, reachable true, uptime30d 0.982906)

## Packages

_none_

## Tools (27)

- `anglo_deromanize`: 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.

- `anglo_get_inflections`: 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).

- `anglo_romanize`: 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.

- `anglo_search`: 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).

- `dictionaries`: 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.
- `interslavic_get_inflections`: 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.

- `interslavic_search`: 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.

- `interslavic_transliterate`: 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.

- `latgalian_deromanize`: 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.

- `latgalian_get_inflections`: 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).

- `latgalian_romanize`: 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.

- `latgalian_search`: 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).

- `latin_get_inflections`: 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).

- `latin_lemmatize`: 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.

- `latin_search`: 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).

- `livonian_deromanize`: 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.

- `livonian_get_inflections`: 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).

- `livonian_romanize`: 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.

- `livonian_search`: 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).

- `norse_get_inflections`: 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).

- `norse_search`: 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).

- `scythian_get_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).

- `scythian_search`: 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).

- `slavonic_detransliterate`: 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.

- `slavonic_get_inflections`: 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).

- `slavonic_search`: 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).

- `slavonic_transliterate`: 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.