# io.github.kuhumcst/dannet (remote · wordnet.dk)

DanNet - Danish WordNet with rich lexical relationships and SPARQL access.

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

## Components

- remote · `wordnet.dk`: 63/100 (this document), [markdown](https://verifymcp.io/servers/kuhumcst-dannet/wordnet.md), [page](https://verifymcp.io/servers/kuhumcst-dannet/wordnet)

## Channel facts

- Endpoint: `https://wordnet.dk/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.2`

## 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**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 16 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 68/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 8504 tokens (~404/item across 21 items; 16 tools + 5 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**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% 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 kuhumcst-dannet https://wordnet.dk/mcp
```

### Codex

```toml
[mcp_servers.kuhumcst-dannet]
url = "https://wordnet.dk/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "kuhumcst-dannet": {
      "type": "remote",
      "url": "https://wordnet.dk/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add kuhumcst-dannet --url https://wordnet.dk/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  kuhumcst-dannet:
    url: "https://wordnet.dk/mcp"
```

### Other

```json
{
  "mcpServers": {
    "kuhumcst-dannet": {
      "type": "http",
      "url": "https://wordnet.dk/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 63, +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-08-01 (score 62, +1)

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

### 2026-07-31 (score 61, +1)

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

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

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

### 2026-07-29 (score 59, +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 58, +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 57)

First indexed and scored.

## MCP tools (16)

### `get_word_synsets` (~891 tokens)

Get synsets (word meanings) for a Danish word, returning a sorted list of lexical concepts.

DanNet follows the OntoLex-Lemon model where:
\- Words (ontolex:LexicalEntry) evoke concepts through senses
\- Synsets (ontolex:LexicalConcept) represent units of meaning
\- Multiple words can share the same synset (synonyms)
\- One word can have multiple synsets (polysemy)

This function returns all synsets associated with a word, effectively giving you
all the different meanings/senses that word can have. Each synset represents
a distinct semantic concept with its own definition and semantic relationships.

Common patterns in Danish:
\- Nouns often have multiple senses (e.g., "kage" = cake/lump)
\- Verbs distinguish motion vs. state (e.g., "løbe" = run/flow)
\- Check synset's dns:ontologicalType for semantic classification

DDO CONNECTION AND SYNSET LABELS:
Synset labels are compositions of DDO-derived sense labels, showing all words that 
express the same meaning. For example:
\- "{hund_1§1; køter_§1; vovhund_§1; vovse_§1}" = all words meaning "domestic dog"
\- "{forlygte_§2; babs_§1; bryst_§2; patte_1§1a}" = all words meaning "female breast"

Each individual sense label follows DDO structure:
\- "hund_1§1" = word "hund", entry 1, definition 1 in DDO (ordnet.dk)
\- "patte_1§1a" = word "patte", entry 1, definition 1, subdefinition a
\- The § notation connects directly to DDO's definition numbering system

This composition reveals the semantic relationships between Danish words and their
shared meanings, all traceable back to authoritative DDO lexicographic data.

RETURN BEHAVIOR:
This function has two possible return modes depending on search results:

1\. MULTIPLE RESULTS: Returns List[SearchResult] with basic information for each synset
2\. SINGLE RESULT (redirect): Returns full synset data Dict when DanNet automatically 
   redirects to a single synset. This provides immediate access to all semantic 
   relationships, ontological types, sentiment data, and other rich information…

Input parameters:

- `language` (string)
- `query` (string, required)

Output parameters:

- `result`

### `get_entity_info` (~538 tokens)

Get comprehensive RDF data for any entity in the DanNet database.

Supports both DanNet entities and external vocabulary entities loaded
into the triplestore from various schemas and datasets.

UNDERSTANDING THE DATA MODEL:
The DanNet database contains entities from multiple sources:
\- DanNet entities (namespace="dn"): synsets, words, senses, and other resources
\- External entities (other namespaces): OntoLex vocabulary, Inter-Lingual Index, etc.

All entities follow RDF patterns with namespace prefixes for properties and relationships.

NAVIGATION TIPS:
\- DanNet synsets have rich semantic relationships (wn:hypernym, wn:hyponym, etc.)
\- External entities provide vocabulary definitions and cross-references
\- Use parse_resource_id() on URI references to get clean IDs
\- Check @type to understand what kind of entity you're working with

Args:
    identifier: Entity identifier (e.g., "synset-3047", "word-11021628", "LexicalConcept", "i76470")
    namespace: Namespace for the entity (default: "dn" for DanNet entities)
              - "dn": DanNet entities via /dannet/data/ endpoint
              - Other values: External entities via /dannet/external/{namespace}/ endpoint
              - Common external namespaces: "ontolex", "ili", "wn", "lexinfo", etc.

Returns:
    Dict containing JSON-LD format with:
    - @context → namespace mappings (if applicable)
    - @id → entity identifier
    - @type → entity type
    - All RDF properties with namespace prefixes (e.g., wn:hypernym, ontolex:evokes)
    - For DanNet synsets: dns:ontologicalType and dns:sentiment (if applicable)
    - Entity-specific convenience fields (synset_id, resource_id, etc.)

Examples:
    # DanNet entities
    get_entity_info("synset-3047")  # DanNet synset
    get_entity_info("word-11021628")  # DanNet word
    get_entity_info("sense-21033604")  # DanNet sense
    
    # External vocabulary entities  
    get_entity_info("LexicalConcept", namespace="ontolex")  # OntoLex class definition
    get_entity…

Input parameters:

- `identifier` (string, required)
- `namespace` (string)

Output parameters:

- `result` (object)

### `get_synset_info` (~823 tokens)

Get comprehensive RDF data for a DanNet synset (lexical concept).

UNDERSTANDING THE DATA MODEL:
Synsets are ontolex:LexicalConcept instances representing word meanings.
They connect to words via ontolex:isEvokedBy and have rich semantic relations.

KEY RELATIONSHIPS (by importance):

1\. TAXONOMIC (most fundamental):
   \- wn:hypernym → broader concept (e.g., "hund" → "pattedyr")
   \- wn:hyponym → narrower concepts (e.g., "hund" → "puddel", "schæfer")
   \- dns:orthogonalHypernym → cross-cutting categories [Danish: ortogonalt hyperonym]

2\. LEXICAL CONNECTIONS:
   \- ontolex:isEvokedBy → words expressing this concept [Danish: fremkaldes af]
   \- ontolex:lexicalizedSense → sense instances [Danish: leksikaliseret betydning]
   \- wn:similar → related but distinct concepts

3\. PART-WHOLE RELATIONS:
   \- wn:mero_part/wn:holo_part → component relationships [English: meronym/holonym part]
   \- wn:mero_substance/wn:holo_substance → material composition
   \- wn:mero_member/wn:holo_member → membership relations

4\. SEMANTIC PROPERTIES:
   \- dns:ontologicalType → semantic classification with @set array of dnc: types
     Common types: dnc:Animal, dnc:Human, dnc:Object, dnc:Physical,
     dnc:Dynamic (events/actions), dnc:Static (states)
   \- dns:sentiment → emotional polarity with marl:hasPolarity and marl:polarityValue
   \- wn:lexfile → semantic domain (e.g., "noun.food", "verb.motion")
   \- skos:definition → synset definition (may be truncated for length)

5\. CROSS-LINGUISTIC:
   \- wn:ili → Interlingual Index for cross-language mapping
   \- wn:eq_synonym → Open English WordNet equivalent

DDO CONNECTION FOR FULLER DEFINITIONS:
DanNet synset definitions (skos:definition) may be truncated (ending with "…").
For complete definitions, use the fetch_ddo_definition() tool which automatically
retrieves full DDO text, or manually examine sense source URLs via get_sense_info().

NAVIGATION TIPS:
\- Follow wn:hypernym chains to find semantic categories
\- Check dns:inherited for properti…

Input parameters:

- `synset_id` (string, required)

Output parameters:

- `result` (object)

### `get_word_info` (~380 tokens)

Get comprehensive RDF data for a DanNet word (lexical entry).

UNDERSTANDING THE DATA MODEL:
Words are ontolex:LexicalEntry instances representing lexical forms.
They connect to synsets via senses and have morphological information.

KEY RELATIONSHIPS:

1\. LEXICAL CONNECTIONS:
   \- ontolex:evokes → synsets this word can express
   \- ontolex:sense → sense instances connecting word to synsets
   \- ontolex:canonicalForm → canonical form with written representation

2\. MORPHOLOGICAL PROPERTIES:
   \- lexinfo:partOfSpeech → part of speech classification
   \- wn:partOfSpeech → WordNet part of speech
   \- ontolex:canonicalForm/ontolex:writtenRep → written form

3\. CROSS-REFERENCES:
   \- owl:sameAs → equivalent resources in other datasets
   \- dns:source → source URL for this word entry

NAVIGATION TIPS:
\- Follow ontolex:evokes to find synsets this word expresses
\- Check ontolex:sense for detailed sense information
\- Use parse_resource_id() on URI references to get clean IDs

Args:
    word_id: Word identifier (e.g., "word-11021628" or just "11021628")

Returns:
    Dict containing:
    - All RDF properties with namespace prefixes (e.g., ontolex:evokes)
    - resource_id → clean identifier for convenience
    - All linguistic properties and relationships

Example:
    info = get_word_info("word-11021628")  # "hund" word
    # Check info['ontolex:evokes'] for synsets this word can express
    # Check info['ontolex:sense'] for senses

Input parameters:

- `word_id` (string, required)

Output parameters:

- `result` (object)

### `get_sense_info` (~744 tokens)

Get comprehensive RDF data for a DanNet sense (lexical sense).

UNDERSTANDING THE DATA MODEL:
Senses are ontolex:LexicalSense instances connecting words to synsets.
They represent specific meanings of words with examples and definitions.

KEY RELATIONSHIPS:

1\. LEXICAL CONNECTIONS:
   \- ontolex:isSenseOf → word this sense belongs to
   \- ontolex:isLexicalizedSenseOf → synset this sense represents

2\. SEMANTIC INFORMATION:
   \- lexinfo:senseExample → usage examples in context
   \- rdfs:label → sense label (e.g., "hund_1§1")

3\. REGISTER AND STYLISTIC INFORMATION:
   \- lexinfo:register → formal register classification (e.g., ":lexinfo/slangRegister")
   \- lexinfo:usageNote → human-readable usage notes (e.g., "slang", "formal")

4\. SOURCE INFORMATION:
   \- dns:source → source URL for this sense entry

DDO CONNECTION (Den Danske Ordbog):
DanNet senses are derived from DDO (ordnet.dk), the authoritative modern Danish dictionary.

SENSE LABELS: The format "word_entry§definition" connects to DDO structure:
\- "hund_1§1" = word "hund", entry 1, definition 1 in DDO
\- "forlygte_§2" = word "forlygte", definition 2 in DDO
\- The § notation directly corresponds to DDO's definition numbering

SOURCE TRACEABILITY: The dns:source URLs link back to specific DDO entries:
\- Format: https://ordnet.dk/ddo/ordbog?entry_id=X&def_id=Y&query=word
\- Note: Some DDO URLs may not resolve correctly if IDs have changed since import
\- If the DDO page loads correctly, the relevant definition has CSS class "selected"

METADATA ORIGINS: Usage examples, register information, and definitions flow from DDO's
corpus-based lexicographic data, providing authoritative linguistic information.

NAVIGATION TIPS:
\- Follow ontolex:isSenseOf to find the parent word
\- Follow ontolex:isLexicalizedSenseOf to find the synset
\- Check lexinfo:senseExample for usage examples from DDO corpus
\- Check lexinfo:register and lexinfo:usageNote for stylistic information
\- Use dns:source to attempt tracing back to original DDO d…

Input parameters:

- `sense_id` (string, required)

Output parameters:

- `result` (object)

### `get_word_synonyms` (~190 tokens)

Find synonyms for a Danish word through shared synsets (word senses).

SYNONYM TYPES IN DANNET:
\- True synonyms: Words sharing the exact same synset
\- Context-specific: Different synonyms for different word senses
Note: Near-synonyms via wn:similar relations are not currently included

The function returns all words that share synsets with the input word,
effectively finding lexical alternatives that express the same concepts.

Args:
    word: The Danish word to find synonyms for

Returns:
    Comma-separated string of synonymous words (aggregated across all word senses)

Example:
    synonyms = get_word_synonyms("hund")
    # Returns: "køter, vovhund, vovse"

Note: Check synset definitions to understand which synonyms apply
to which meaning (polysemy is common in Danish).

Input parameters:

- `word` (string, required)

Output parameters:

- `result` (string)

### `get_word_overview` (~455 tokens)

Get a complete overview of all senses for a Danish word in a single call.

Replaces the common pattern of calling get_word_synsets → get_synset_info
per result → get_word_synonyms, collapsing 5-15 HTTP round-trips into one
SPARQL query.

Only returns synsets where the word is a primary lexical member (i.e. the
word itself has a direct sense in the synset), excluding multi-word
expressions that merely contain the word as a component.

Args:
    word: The Danish word to look up

Returns:
    List of dicts, one per synset, each containing:
    - synset_id: Clean synset identifier (e.g. "synset-3047")
    - label: Human-readable synset label
    - definition: Synset definition (may be truncated with "…")
    - ontological_types: List of dnc: type URIs
    - synonyms: List of co-member lemmas (true synonyms only)
    - hypernym: Dict with synset_id and label of the immediate broader concept, or null
    - lexfile: WordNet lexicographer file name (e.g. "noun.animal"), or null if absent

Example:
    overview = get_word_overview("hund")
    # Returns list of 4 synsets, the first being:
    # {"synset_id": "synset-3047",
    #  "label": "{hund_1§1; køter_§1; vovhund_§1; vovse_§1}",
    #  "definition": "pattedyr som har god lugtesans ...",
    #  "ontological_types": ["dnc:Animal", "dnc:Object"],
    #  "synonyms": ["køter", "vovhund", "vovse"],
    #  "lexfile": "noun.animal"}

    # Pass synset_id to get_synset_info() for full JSON-LD data on any result:
    # full_data = get_synset_info(overview[0]["synset_id"])

Input parameters:

- `word` (string, required)

Output parameters:

- `result` (array)

### `autocomplete_danish_word` (~155 tokens)

Get autocomplete suggestions for Danish word prefixes.

Useful for discovering Danish vocabulary or finding the correct spelling
of words. Returns lemma forms (dictionary forms) of words.

Args:
    prefix: The beginning of a Danish word (minimum 3 characters required)
    max_results: Maximum number of suggestions to return (default: 10)
    
Returns:
    Comma-separated string of word completions in alphabetical order

Note: Autocomplete requires at least 3 characters to prevent excessive results.

Example:
    suggestions = autocomplete_danish_word("hyg", 5)
    # Returns: "hygge, hyggelig, hygiejne"

Input parameters:

- `max_results` (integer)
- `prefix` (string, required)

Output parameters:

- `result` (string)

### `switch_dannet_server` (~235 tokens)

Switch between local and remote DanNet servers on the fly.

This tool allows you to change the DanNet server endpoint during runtime
without restarting the MCP server. Useful for switching between development
(local) and production (remote) servers.

Args:
    server: Server to switch to. Options:
           - "local": Use localhost:3456 (development server)
           - "remote": Use wordnet.dk (production server)
           - Custom URL: Any valid URL starting with http:// or https://

Returns:
    Dict with status information:
    - status: "success" or "error"
    - message: Description of the operation
    - previous_url: The URL that was previously active
    - current_url: The URL that is now active

Example:
    # Switch to local development server
    result = switch_dannet_server("local")
    
    # Switch to production server
    result = switch_dannet_server("remote")
    
    # Switch to custom server
    result = switch_dannet_server("https://my-custom-dannet.example.com")

Input parameters:

- `server` (string, required)

Output parameters:

- `result` (object)

### `get_current_dannet_server` (~108 tokens)

Get information about the currently active DanNet server.

Returns:
    Dict with current server information:
    - server_url: The base URL of the current DanNet server
    - server_type: "local", "remote", or "custom"
    - status: Connection status information

Example:
    info = get_current_dannet_server()
    # Returns: {"server_url": "https://wordnet.dk", "server_type": "remote", "status": "active"}

Output parameters:

- `result` (object)

### `get_cache_stats` (~107 tokens)

Return statistics about the session-scoped resource cache.

Useful for verifying that caching is working: call get_synset_info (or similar)
twice for the same ID and check that cache_size grows by 1 on the first call
but not on the second, and that cached_keys contains the expected IDs.

Returns:
    Dict with:
    - cache_size: Total number of cached entries
    - cached_keys: List of (base_url, resource_id) pairs currently cached

Output parameters:

- `result` (object)

### `fetch_ddo_definition` (~355 tokens)

Fetch the full, untruncated definition from DDO (Den Danske Ordbog) for a synset.

This tool addresses the issue that DanNet synset definitions (:skos/definition)
may be capped at a certain length. It retrieves the complete definition from
the authoritative DDO source by following sense source URLs.

WORKFLOW:
1\. Get synset information to find associated senses
2\. Extract DDO source URLs from sense data (dns:source)
3\. Fetch DDO HTML pages and parse for definitions
4\. Find elements with class "definitionBox selected" and extract span.definition content

IMPORTANT NOTES:
\- Looks for CSS classes "definitionBox selected" and child span.definition
\- DDO and DanNet have diverged over time, so source URLs may not always work
\- This implementation uses httpx for web requests and regex-based HTML parsing

Args:
    synset_id: Synset identifier (e.g., "synset-1876" or just "1876")

Returns:
    Dict containing:
    - synset_id: The queried synset ID
    - ddo_definitions: List of definitions found from DDO pages
    - source_urls: List of DDO URLs that were attempted
    - success_urls: List of URLs that successfully returned definitions
    - errors: List of any errors encountered
    - truncated_definition: The original DanNet definition for comparison

Example:
    result = fetch_ddo_definition("synset-3047")
    # Check result['ddo_definitions'] for full DDO definitions
    # Compare with result['truncated_definition'] from DanNet

Input parameters:

- `synset_id` (string, required)

Output parameters:

- `result` (object)

### `validate_synset_structure` (~86 tokens)

Validate and analyze the structure of synset JSON-LD data.

This enhanced tool helps debug and understand synset data structure,
providing validation and insights into the JSON-LD format.

Args:
    synset_data: Synset data returned from get_synset_info()
    
Returns:
    Dict with validation results and structural analysis

Input parameters:

- `synset_data` (object, required)

Output parameters:

- `result` (object)

### `extract_semantic_data` (~86 tokens)

Extract and normalize semantic data from any DanNet JSON-LD entity.

This tool provides a unified way to extract semantic information from
synsets, words, or senses, handling different JSON-LD structures consistently.

Args:
    entity_data: Any DanNet entity JSON-LD data
    
Returns:
    Dict with normalized semantic information

Input parameters:

- `entity_data` (object, required)

Output parameters:

- `result` (object)

### `analyze_namespace_usage` (~83 tokens)

Analyze namespace usage and provide resolution for prefixed properties.

This debugging tool helps understand how namespaces are used in
DanNet JSON-LD data and resolves prefixed URIs to full forms.

Args:
    entity_data: Any DanNet JSON-LD entity data
    
Returns:
    Dict with namespace analysis and URI resolution

Input parameters:

- `entity_data` (object, required)

Output parameters:

- `result` (object)

### `sparql_query` (~1779 tokens)

Execute a SPARQL SELECT query against the DanNet triplestore.

This tool provides direct access to DanNet's RDF data through SPARQL queries.
The query is automatically prepended with common namespace prefix declarations,
so you can use short prefixes instead of full URIs in your queries.

\============================================================
CRITICAL PERFORMANCE RULES (read before writing any query):
\============================================================

1\. ALWAYS start from a known entity URI or a word lookup — never scan the whole graph.
   FAST: dn:synset-3047 wn:hypernym ?x .
   SLOW: ?x wn:hypernym ?y .  (scans every synset)

2\. ALWAYS use DISTINCT for SELECT queries to avoid duplicate rows.

3\. NEVER use FILTER(CONTAINS(...)) on labels across the whole graph.
   SLOW: ?s rdfs:label ?l . FILTER(CONTAINS(?l, "hund"))
   FAST: Use get_word_synsets("hund") first, then query specific synset URIs.

4\. NEVER create cartesian products — every triple pattern must share a variable
   with at least one other pattern.
   SLOW: ?x a ontolex:LexicalConcept . ?y a ontolex:LexicalEntry . (cross join!)

5\. ALWAYS add LIMIT (even if max_results caps it server-side, explicit LIMIT
   lets the query engine optimize).

6\. Use property paths for multi-hop traversals:
   FAST: dn:synset-3047 wn:hypernym+ ?ancestor .  (transitive closure)
   FAST: ?entry ontolex:canonicalForm/ontolex:writtenRep "hund"@da .  (path)

7\. Prefer VALUES over FILTER for matching multiple known entities:
   FAST: VALUES ?synset { dn:synset-3047 dn:synset-3048 } ?synset rdfs:label ?l .
   SLOW: ?synset rdfs:label ?l . FILTER(?synset = dn:synset-3047 || ?synset = dn:synset-3048)

8\. The triplestore contains BOTH DanNet (Danish, dn: namespace) AND the Open
   English WordNet (en: namespace). Unanchored queries will scan both.
   To restrict to Danish data, anchor on dn: URIs or use @da language tags.

\============================================
FAST QUERY TEMPLATES (copy and adapt these):
\====…

Input parameters:

- `distinct` (boolean)
- `inference`
- `max_results` (integer)
- `query` (string, required)
- `timeout` (integer)

Output parameters:

- `result` (object)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/kuhumcst-dannet/wordnet#diagnostics

## Score history

- 2026-08-03: 63
- 2026-08-02: 62
- 2026-08-01: 62
- 2026-07-31: 61
- 2026-07-30: 60
- 2026-07-29: 59
- 2026-07-28: 58
- 2026-07-27: 58
- 2026-07-26: 57

## Links

- Remote endpoint: https://wordnet.dk/mcp
- Repository: https://github.com/kuhumcst/DanNet
- Changelog RSS feed: https://verifymcp.io/servers/kuhumcst-dannet/wordnet/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/kuhumcst-dannet/wordnet/changelog.json
- HTML version of this page: https://verifymcp.io/servers/kuhumcst-dannet/wordnet