io.github.kuhumcst/dannet

Official16 toolsLive

by kuhumcst · Clojure

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

io.github.kuhumcst/dannet MCP Server

DanNet is a Danish WordNet with rich lexical relationships and SPARQL access, exposed via an MCP server. The server represents and serializes data using RDF across the database level and application space, enabling developers to browse and query Danish lexical resources from integrated tools.

🛠️ Key Features

Danish WordNet (“DanNet”) with rich lexical relationships
Native RDF representation at database and application layers
SPARQL access for querying the RDF data
Tooling count: 16

🚀 Use Cases

Browse the WordNet data via wordnet.dk
Query the dataset using AI integration
Download datasets from the GitHub releases page

⚡ Developer Benefits

Aligns with semantic web workflows using RDF
Supports knowledge-graph and linked-data patterns (topics include RDF, triples/triplestore)
Relevant technologies in scope: Apache Jena, OWL, semantic-web data, JSON-LD, SPARQL

⚠️ Limitations

Description and excerpt do not specify supported input/output formats beyond RDF, nor detailed MCP tool behaviors.

Topics

graphtriplestripletsrdfwordnetapache-jenajenaowltriplestoreknowledge-graphdanishlinked-datasemantic-webjson-ldmcp-serverwn-lmfcsvwdmlexinferencellm

Captured live from the server via tools/list.

get_word_synsets

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 without requiring a separate get_synset_info() call. The single-result case is equivalent to calling get_synset_info() on the synset, providing the same comprehensive RDF data structure with all semantic relations. Args: query: The Danish word or phrase to search for language: Language for labels and definitions in results (default: "da" for Danish, "en" for English when available) Note: Only Danish words can be searched regardless of this parameter Returns: MULTIPLE RESULTS: List of SearchResult objects with: - word: The lexical form - synset_id: Unique synset identifier (format: synset-NNNNN) - label: Human-readable synset label (e.g., "{kage_1§1}") - definition: Brief semantic definition (may be truncated with "...") SINGLE RESULT: Dict with complete synset data including: - All RDF properties with namespace prefixes (e.g., wn:hypernym) - dns:ontologicalType → semantic types with @set array - dns:sentiment → parsed sentiment (if present) - synset_id → clean identifier for convenience - All semantic relationships and linguistic properties Examples: # Multiple results case results = get_word_synsets("hund") # Returns list of search result dictionaries for all meanings of "hund" # => [{"word": "hund", "synset_id": "synset-3047", ...}, ...] # Single result case (redirect) result = get_word_synsets("svinkeærinde") # Returns complete synset data for unique word # => {'wn:hypernym': 'dn:synset-11677', 'dns:sentiment': {...}, ...}

Parameters2

query	string	required
language	string	optional

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "language": {
      "default": "da",
      "title": "Language",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "title": "get_word_synsetsArguments"
}

get_entity_info

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_info("i76470", namespace="ili") # Inter-Lingual Index entry get_entity_info("noun", namespace="lexinfo") # Lexinfo part-of-speech

Parameters2

identifier	string	required
namespace	string	optional

Raw schema

{
  "type": "object",
  "properties": {
    "identifier": {
      "title": "Identifier",
      "type": "string"
    },
    "namespace": {
      "default": "dn",
      "title": "Namespace",
      "type": "string"
    }
  },
  "required": [
    "identifier"
  ],
  "title": "get_entity_infoArguments"
}

get_synset_info

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 properties from parent synsets - Use parse_resource_id() on URI references to get clean IDs - For fuller definitions, examine individual sense source URLs via get_sense_info() Args: synset_id: Synset identifier (e.g., "synset-1876" or just "1876") Returns: Dict containing JSON-LD format with: - @context → namespace mappings - @id → entity identifier (e.g., "dn:synset-1876") - @type → "ontolex:LexicalConcept" - All RDF properties with namespace prefixes (e.g., wn:hypernym) - dns:ontologicalType → {"@set": ["dnc:Animal", ...]} (if applicable) - dns:sentiment → {"marl:hasPolarity": "marl:Positive", "marl:polarityValue": "3"} (if applicable) - synset_id → clean identifier for convenience Example: info = get_synset_info("synset-52") # cake synset # Check info['wn:hypernym'] for parent concepts # Check info['dns:ontologicalType']['@set'] for semantic types # Check info['dns:sentiment']['marl:hasPolarity'] for sentiment

Parameters1

synset_id

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "synset_id": {
      "title": "Synset Id",
      "type": "string"
    }
  },
  "required": [
    "synset_id"
  ],
  "title": "get_synset_infoArguments"
}

get_word_info

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

Parameters1

word_id

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "word_id": {
      "title": "Word Id",
      "type": "string"
    }
  },
  "required": [
    "word_id"
  ],
  "title": "get_word_infoArguments"
}

get_sense_info

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 definition (with caveats) - Use parse_resource_id() on URI references to get clean IDs Args: sense_id: Sense identifier (e.g., "sense-21033604" or just "21033604") Returns: Dict containing: - All RDF properties with namespace prefixes (e.g., ontolex:isSenseOf) - resource_id → clean identifier for convenience - All sense properties and relationships Example: info = get_sense_info("sense-21033604") # "hund_1§1" sense # Check info['ontolex:isSenseOf'] for parent word # Check info['ontolex:isLexicalizedSenseOf'] for synset # Check info['lexinfo:senseExample'] for usage examples from DDO # Check info['lexinfo:register'] for register classification # Check info['lexinfo:usageNote'] for usage notes like "slang" # Check info['dns:source'] for DDO source URL (may not always work)

Parameters1

sense_id

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "sense_id": {
      "title": "Sense Id",
      "type": "string"
    }
  },
  "required": [
    "sense_id"
  ],
  "title": "get_sense_infoArguments"
}

get_word_synonyms

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

Parameters1

word

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "word": {
      "title": "Word",
      "type": "string"
    }
  },
  "required": [
    "word"
  ],
  "title": "get_word_synonymsArguments"
}

get_word_overview

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"])

Parameters1

word

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "word": {
      "title": "Word",
      "type": "string"
    }
  },
  "required": [
    "word"
  ],
  "title": "get_word_overviewArguments"
}

autocomplete_danish_word

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"

Parameters2

prefix	string	required
max_results	integer	optional

Raw schema

{
  "type": "object",
  "properties": {
    "prefix": {
      "title": "Prefix",
      "type": "string"
    },
    "max_results": {
      "default": 10,
      "title": "Max Results",
      "type": "integer"
    }
  },
  "required": [
    "prefix"
  ],
  "title": "autocomplete_danish_wordArguments"
}

switch_dannet_server

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")

Parameters1

server

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "server": {
      "title": "Server",
      "type": "string"
    }
  },
  "required": [
    "server"
  ],
  "title": "switch_dannet_serverArguments"
}

get_current_dannet_server

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"}

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {},
  "title": "get_current_dannet_serverArguments"
}

get_cache_stats

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

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {},
  "title": "get_cache_statsArguments"
}

fetch_ddo_definition

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

Parameters1

synset_id

string

required

Raw schema

{
  "type": "object",
  "properties": {
    "synset_id": {
      "title": "Synset Id",
      "type": "string"
    }
  },
  "required": [
    "synset_id"
  ],
  "title": "fetch_ddo_definitionArguments"
}

validate_synset_structure

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

Parameters1

synset_data

object

required

Raw schema

{
  "type": "object",
  "properties": {
    "synset_data": {
      "additionalProperties": true,
      "title": "Synset Data",
      "type": "object"
    }
  },
  "required": [
    "synset_data"
  ],
  "title": "validate_synset_structureArguments"
}

extract_semantic_data

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

Parameters1

entity_data

object

required

Raw schema

{
  "type": "object",
  "properties": {
    "entity_data": {
      "additionalProperties": true,
      "title": "Entity Data",
      "type": "object"
    }
  },
  "required": [
    "entity_data"
  ],
  "title": "extract_semantic_dataArguments"
}

analyze_namespace_usage

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

Parameters1

entity_data

object

required

Raw schema

{
  "type": "object",
  "properties": {
    "entity_data": {
      "additionalProperties": true,
      "title": "Entity Data",
      "type": "object"
    }
  },
  "required": [
    "entity_data"
  ],
  "title": "analyze_namespace_usageArguments"
}

sparql_query

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): ============================================ # TEMPLATE 1: Find synsets for a Danish word (via word lookup) SELECT DISTINCT ?synset ?label ?def WHERE { ?entry ontolex:canonicalForm/ontolex:writtenRep "WORD"@da . ?entry ontolex:sense/ontolex:isLexicalizedSenseOf ?synset . ?synset rdfs:label ?label . OPTIONAL { ?synset skos:definition ?def } } # TEMPLATE 2: Get all properties of a known synset SELECT ?p ?o WHERE { dn:synset-NNNN ?p ?o . } LIMIT 50 # TEMPLATE 3: Find hypernyms (broader concepts) of a known synset SELECT DISTINCT ?hypernym ?label WHERE { dn:synset-NNNN wn:hypernym ?hypernym . ?hypernym rdfs:label ?label . } # TEMPLATE 4: Find hyponyms (narrower concepts) of a known synset SELECT DISTINCT ?hyponym ?label WHERE { ?hyponym wn:hypernym dn:synset-NNNN . ?hyponym rdfs:label ?label . } # TEMPLATE 5: Trace full hypernym chain (taxonomic ancestors) SELECT DISTINCT ?ancestor ?label WHERE { dn:synset-NNNN wn:hypernym+ ?ancestor . ?ancestor rdfs:label ?label . } # TEMPLATE 6: Find all relationships OF a known synset SELECT DISTINCT ?rel ?target ?targetLabel WHERE { dn:synset-NNNN ?rel ?target . ?target rdfs:label ?targetLabel . FILTER(isURI(?target)) } LIMIT 50 # TEMPLATE 7: Find all relationships TO a known synset SELECT DISTINCT ?source ?rel ?sourceLabel WHERE { ?source ?rel dn:synset-NNNN . ?source rdfs:label ?sourceLabel . FILTER(isURI(?source)) } LIMIT 50 # TEMPLATE 8: Query multiple known synsets at once SELECT DISTINCT ?synset ?label ?def WHERE { VALUES ?synset { dn:synset-3047 dn:synset-3048 dn:synset-6524 } ?synset rdfs:label ?label . OPTIONAL { ?synset skos:definition ?def } } # TEMPLATE 9: Find functional relations for a specific synset SELECT DISTINCT ?rel ?target ?targetLabel WHERE { dn:synset-NNNN ?rel ?target . ?target rdfs:label ?targetLabel . VALUES ?rel { dns:usedFor dns:usedForObject wn:agent wn:instrument wn:causes } } # TEMPLATE 10: Find ontological type of a synset (stored as RDF Bag) SELECT ?type WHERE { dn:synset-NNNN dns:ontologicalType ?bag . ?bag ?pos ?type . FILTER(STRSTARTS(

Parameters5

query	string	required
timeout	integer	optional
max_results	integer	optional
distinct	boolean	optional
inference	any	optional

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "title": "Query",
      "type": "string"
    },
    "timeout": {
      "default": 8000,
      "title": "Timeout",
      "type": "integer"
    },
    "max_results": {
      "default": 100,
      "title": "Max Results",
      "type": "integer"
    },
    "distinct": {
      "default": true,
      "title": "Distinct",
      "type": "boolean"
    },
    "inference": {
      "anyOf": [
        {
          "type": "boolean"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Inference"
    }
  },
  "required": [
    "query"
  ],
  "title": "sparql_queryArguments"
}

README.md14 KBView on GitHub

DanNet logo

DanNet is a WordNet for the Danish language. DanNet uses RDF as its native representation at both the database level, in the application space, and as its primary serialisation format.

Browse the data at wordnet.dk
Query the data by integrating with AI
Download datasets from the releases page

Dataset Formats
Companion Datasets
Standards
LLM Integration (AI)
Implementation
Setup
Deployment
Database Release Workflow

Dataset Formats

DanNet is available in multiple formats to maximise compatibility:

Format	Description
RDF (Turtle)	Native representation. Load into any RDF graph database (such as Apache Jena) and query with SPARQL.
CSV	Published with column metadata as CSVW.
WN-LMF	XML format compatible with Python libraries like wn.
DMLex	OASIS DMLex 1.0 representation as both XML and JSON, in a Danish and an English variant. The DMLex browser shows it as a dictionary.

Example: Using DanNet with Python

python

import wn

wn.add("dannet-wn-lmf.xml.gz")

for synset in wn.synsets('kage'):
    print((synset.lexfile() or "?") + ": " + (synset.definition() or "?"))

Differences Between Formats

While every format includes all synsets/senses/words, the CSV, WN-LMF and DMLex variants do not include every data point:

CSV: Some data is lost when converting from an open graph to fixed tables.
WN-LMF: Only official GWA relations are included per the standard (proprietary DanNet relations from the DanNet schema are excluded).
DMLex: Combines DanNet with COR, DDS and COR.SEM in one file. Relations to other datasets are not included. See doc/dmlex/plan.md for the conversion rules.

For the complete dataset, use the RDF format or browse at wordnet.dk.

Companion Datasets

Several companion datasets expand the RDF graph with additional data:

Dataset	Description
COR	Links DanNet resources to IDs from the COR project.
DDS	Adds sentiment data to DanNet resources.
OEWN extension	Provides DanNet-style labels for the Open English WordNet to facilitate browsing connections between the two datasets.

Inferred Data

Additional data is implicitly inferred from the base dataset, companion datasets, and ontological metadata. These inferences can be browsed at wordnet.dk. Releases containing fully inferred graphs are specifically marked as such.

Standards

DanNet is based on the Ontolex-lemon standard combined with relations defined by the Global Wordnet Association as used in the official GWA RDF standard.

Ontolex-lemon class	Represents
`ontolex:LexicalConcept`	Synsets
`ontolex:LexicalSense`	Word senses
`ontolex:LexicalEntry`	Words
`ontolex:Form`	Forms

Ontolex-lemon representation

URI Prefixes

Prefix	URI	Purpose
`dn`	https://wordnet.dk/dannet/data/	Dataset instances
`dnc`	https://wordnet.dk/dannet/concepts/	Ontological type members
`dns`	https://wordnet.dk/dannet/schema/	Schema definitions
`dnf`	https://wordnet.dk/dannet/function/	Custom SPARQL functions (`dnf:path`, `dnf:lch`, `dnf:wup` synset similarity)

All DanNet URIs resolve to HTTP resources. Accessing one of these URIs via a GET request returns the data for that resource.

Schemas

DanNet has proprietary relations defined in the DanNet schema in an Ontolex-compatible way. There is also a schema for EuroWordNet concepts. Both schemas follow the RDF conventions listed by Philippe Martin.

LLM Integration

DanNet can be connected to AI tools like Claude via MCP (Model Context Protocol).

MCP server URL: https://wordnet.dk/mcp
Registry ID: io.github.kuhumcst/dannet

To connect in e.g. Claude Desktop: go to Settings > Connectors > Browse Connectors, click "add a custom one", enter a name (e.g., "DanNet") and the MCP server URL.

Claude Desktop setup

Once connected, you can query DanNet's semantic relations directly through Claude.

Implementation

The database backend is Apache Jena, a mature RDF triplestore with OWL inference support. When represented in Jena, DanNet's relations form a queryable knowledge graph. DanNet is developed in Clojure, using libraries like Aristotle to interact with Jena.

See rationale.md for more on the design decisions.

Full Production Setup

The production deployment at wordnet.dk consists of three services managed via Docker Compose:

DanNet — the Clojure/ClojureScript web application
MCP server — a Python-based MCP server providing LLM access to DanNet
Caddy — reverse proxy handling HTTPS and routing

Clojure Support

DanNet can be queried in various ways from Clojure (see queries.md). Apache Jena transactions are built-in and enable persistence via the TDB 2 layer.

Web Application

The frontend is written in ClojureScript using Rum, served by Pedestal. The app works both as a single-page application (with JavaScript) and as a regular HTML website (without). Content negotiation serves different representations (HTML, RDF, Transit+JSON) based on the request.

See doc/web.md for details.

Bootstrap Process

New releases are bootstrapped from the preceding release. The process (in dk.cst.dannet.db.bootstrap):

Load and clean the previous version's RDF data
Convert to triples using the current schema
Import into Apache Jena graphs and apply release changes (only when cutting a release, i.e. when to differs from from)
Infer additional triples via OWL/RDFS schemas
Export the final RDF dataset (see Database Release Workflow)

Bootstrap data lives under ./bootstrap relative to the execution directory: the DanNet release assets in ./bootstrap/from/<version>/ (named after the release being bootstrapped from, so several can coexist) and the shared English datasets in ./bootstrap/other/english/. Missing files are downloaded automatically, so manual placement is only needed when working offline.

Setup

DanNet requires Java and Clojure's official CLI tools. Dependencies are specified in deps.edn.

Development

Start the web service using (restart) in dk.cst.dannet.web.service — available at localhost:3456
Run the frontend with shadow-cljs:
shell
```
npx shadow-cljs watch app
```

Testing a Release Build

Using Docker (requires Docker daemon running):

shell

# From the docker/ directory
docker compose up --build

Or manually:

shell

shadow-cljs --aliases :frontend release app
clojure -T:build org.corfield.build/uber :lib dk.cst/dannet :main dk.cst.dannet.web.service :uber-file "\"dannet.jar\""
java -jar -Xmx4g dannet.jar

Memory Requirements

The system uses ~1.5 GB when idle and ~3 GB when rebuilding the database. A server should have at least 4 GB of available RAM.

Validating RDF (SHACL)

The dn: dataset is validated against SHACL shapes located in resources/schemas/internal/shapes/ (see dk.cst.dannet.db.shapes). This happens in several ways:

a non-fatal check of the asserted graph runs asynchronously at every boot, logging violations and comparing counts to a known baseline,
RDF exports of the dn: dataset are gated: a baseline regression aborts the export, and
fixture-based tests run via clojure -X:test, which is also executed by the GitHub Actions workflow in .github/workflows/test.yml.

Validating WN-LMF

shell

python3 -m venv examples/venv
source examples/venv/bin/activate
python3 -m pip install wn
python -m wn validate --output-file examples/wn-lmf-validation.json export/wn-lmf/dannet-wn-lmf.xml

Validating DMLex

The validator in dk.cst.dannet.db.export.dmlex-validate checks both serializations of a variant against the official DMLex schemas. It needs the :validate alias:

shell

clojure -M:validate -e "((requiring-resolve 'dk.cst.dannet.db.export.dmlex-validate/validate-dmlex!) \"export/dmlex/\" \"da\")"

Deployment

The production server at wordnet.dk runs as a systemd service delegating to Docker.

Service Setup

shell

cp system/dannet.service /etc/systemd/system/dannet.service
systemctl enable dannet
systemctl start dannet

Updating the Web Service

To update the web service software without changing the database:

shell

# From the docker/ directory
docker compose up -d dannet --build

Database Release Workflow

When releasing a new version of the database:

Set to in dk.cst.dannet.release to the new version, leaving from on the release being bootstrapped from. The release-specific changes in make-release-changes! only run once the two differ.
Build the database via REPL in dk.cst.dannet.web.service:
clojure
```
(restart)
```

Generate the export artifacts, each in its own namespace:

clojure

(dk.cst.dannet.db.export.rdf/export-rdf! @dk.cst.dannet.web.resources/db)
(dk.cst.dannet.db.export.csv/export-csv! @dk.cst.dannet.web.resources/db)
(dk.cst.dannet.db.export.wn-lmf/export-wn-lmf! "export/wn-lmf/")
(dk.cst.dannet.db.export.dmlex/export-dmlex-variants! "export/dmlex/" @dk.cst.dannet.web.resources/db)
;; ~6 minutes
(dk.cst.dannet.db.query/save-synset-indegrees!
  (:graph @dk.cst.dannet.web.resources/db))

This writes export/rdf/ (dannet.zip, cor.zip, cor-sem.zip, framenet.zip, dds.zip, oewn-extension.zip), export/csv/dannet-csv.zip, export/wn-lmf/dannet-wn-lmf.xml.gz, export/dmlex/ (dannet-dmlex-da.zip, dannet-dmlex-en.zip) and export/synset-indegree.edn. These ship to production (step 7) and become the GitHub release assets that the next cycle bootstraps from (step 4).

Publish a GitHub release tagged v<version> and attach the bootstrap assets listed by bootstrap-files in dk.cst.dannet.db.bootstrap.downloads: dannet.zip, cor.zip, dds.zip, oewn-extension.zip and synset-indegree.edn. The next cycle fetches these from GitHub.
Compact the database, then zip it on the dev machine, ready for transfer:
clojure
```
(dk.cst.dannet.db/compact! (:dataset @dk.cst.dannet.web.instance/db))
```
TDB2 only reclaims the space left by in-place updates when compacted, and writes a new Data-000N generation, so restart the service afterwards. Before transferring, check that the database size divided by the triple count is in the hundreds of bytes, not the thousands.
Stop the service on production:
shell
```
docker compose stop dannet
```

Transfer database and export files via SFTP, then:

shell

unzip -o tdb2.zip -d /dannet/db/
mv cor.zip cor-sem.zip framenet.zip dannet.zip dds.zip oewn-extension.zip /dannet/export/rdf/
mv dannet-csv.zip /dannet/export/csv/
mv dannet-wn-lmf.xml.gz /dannet/export/wn-lmf/
mv dannet-dmlex-da.zip dannet-dmlex-en.zip /dannet/export/dmlex/

Ship the export/synset-indegree.edn generated in step 3. Production runs with --no-bootstrap and so never downloads it, but it is read at query time to rank search results and entity relations, and it should describe the database actually being shipped. Either location works, the first taking precedence (see indegrees-files in dk.cst.dannet.db.query):
shell
```
mv synset-indegree.edn /dannet/db/                      # legacy location
mv synset-indegree.edn /dannet/bootstrap/from/2026-08-03/   # alongside the bootstrap inputs
```
If neither exists the service still starts and search still works, but results come back unranked and a :dannet.query/indegrees-unavailable error is logged.
Restart:
shell
```
docker compose up -d dannet --build
```
Bump from to the new version and delete to, which then defaults to from again. Clear out the release-specific block in make-release-changes!: its changes have now shipped. This readies the next cycle.

Install

Tools (16)

get_word_synsetsget_entity_infoget_synset_infoget_word_infoget_sense_infoget_word_synonymsget_word_overviewautocomplete_danish_word

Remote endpoint

Streamable HTTP

Hosted server - connect over the network, no local install.

url

https://wordnet.dk/mcp

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "dannet": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://wordnet.dk/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.

io.github.kuhumcst/dannet MCP Server

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

get_word_synsets

get_entity_info

get_synset_info

get_word_info

get_sense_info

get_word_synonyms

get_word_overview

autocomplete_danish_word

switch_dannet_server

get_current_dannet_server

get_cache_stats

fetch_ddo_definition

validate_synset_structure

extract_semantic_data

analyze_namespace_usage

sparql_query

Table of Contents

Dataset Formats

Example: Using DanNet with Python

Differences Between Formats

Companion Datasets

Inferred Data

Standards

URI Prefixes

Schemas

LLM Integration

Implementation

Full Production Setup

Clojure Support

Web Application

Bootstrap Process

Setup

Development

Testing a Release Build

Memory Requirements

Validating RDF (SHACL)

Validating WN-LMF

Validating DMLex

Deployment

Service Setup

Updating the Web Service

Database Release Workflow

Install

Remote endpoint

Related servers