io.github.kuhumcst/dannet

{
  "checks": {
    "action_safety_probe": {
      "details": {
        "auth_present": false,
        "confirmation_signals": [],
        "safeguard_count": 0,
        "summary": {
          "bulk_access_tools": 0,
          "capability_distribution": {},
          "destructive_tools": 0,
          "egress_tools": 0,
          "exec_tools": 0,
          "high_risk_tools": 0,
          "risk_distribution": {
            "critical": 0,
            "high": 0,
            "low": 0,
            "medium": 0
          },
          "secret_tools": 0,
          "tool_count": 0
        }
      },
      "latency_ms": null,
      "status": "ok"
    },
    "advanced_capabilities_probe": {
      "details": {
        "capabilities": {
          "completions": false,
          "elicitation": false,
          "prompts": false,
          "resource_links": false,
          "resources": false,
          "roots": false,
          "sampling": false,
          "structured_outputs": false
        },
        "enabled": [],
        "enabled_count": 0,
        "initialize_capability_keys": [
          "experimental",
          "prompts",
          "resources",
          "tools"
        ]
      },
      "latency_ms": null,
      "status": "missing"
    },
    "connector_publishability_probe": {
      "details": {
        "blockers": [
          "tools_list",
          "server_card",
          "tool_surface"
        ],
        "criteria": {
          "action_safety": true,
          "auth_flow": true,
          "connector_replay": true,
          "initialize": true,
          "protocol_version": true,
          "remote_transport": true,
          "request_association": true,
          "server_card": false,
          "session_resume": true,
          "step_up_auth": true,
          "tool_surface": false,
          "tools_list": false,
          "transport_compliance": true
        },
        "high_risk_tools": 0,
        "tool_count": 0,
        "transport": "streamable-http"
      },
      "latency_ms": null,
      "status": "error"
    },
    "connector_replay_probe": {
      "details": {
        "reason": "no_tools"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "determinism_probe": {
      "details": {
        "reason": "tools_list_unavailable"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "initialize": {
      "details": {
        "headers": {
          "content-type": "text/event-stream",
          "mcp-session-id": "576a4e003d6a4651aa6de66bd7d559ed"
        },
        "http_status": 200,
        "payload": {
          "id": 1,
          "jsonrpc": "2.0",
          "result": {
            "capabilities": {
              "experimental": {},
              "prompts": {
                "listChanged": false
              },
              "resources": {
                "listChanged": false,
                "subscribe": false
              },
              "tools": {
                "listChanged": false
              }
            },
            "instructions": "DanNet MCP Server - Danish WordNet with rich semantic relationships\n\nSEMANTIC DATA MODEL:\nDanNet follows OntoLex-Lemon + Global WordNet standards where:\n- Words (LexicalEntry) \u2192 Senses \u2192 Synsets (LexicalConcept)\n- Synsets represent units of meaning shared by synonymous words\n- Rich semantic network with 10+ major relation categories, 70+ specific types\n\nRDF STORAGE PATTERNS:\nDanNet uses sophisticated RDF structures for complex data:\n- Ontological types (dns:ontologicalType) are stored as RDF Bags with numbered properties (rdf:_0, rdf:_1, etc.)\n- Word connections use ontolex:isEvokedBy pointing to word entities, not direct labels\n- Synset labels contain quoted word forms with DDO notation (e.g., \"{\"hund\", \"k\u00f8ter\"}\")\n- Some properties may be stored as blank nodes requiring multi-step queries\n\nQUICK START WORKFLOW:\n1. Check resources for context:\n   - dannet://wordnet-schema \u2192 core WordNet RDF relations\n   - dannet://dannet-schema \u2192 DanNet-specific WordNet relation extensions\n   - dannet://ontological-types \u2192 Semantic categories (Animal, Human, Object, etc.)\n   - dannet://namespaces \u2192 Understanding prefixes in the data\n   \n2. Search for words to find synsets:\n   - get_word_synsets(\"hund\") \u2192 Find all meanings\n   - Note: Danish has high polysemy (words with multiple meanings)\n   \n3. Explore synset details:\n   - get_synset_info() \u2192 Full RDF data with relationships\n   - Check dns:ontologicalType for semantic class\n   - Follow wn:hypernym for categories, wn:hyponym for specifics\n   \n4. Navigate semantic relationships:\n   - Taxonomic: hypernym (broader) / hyponym (narrower)\n   - Similarity: similar, near_synonym, antonym\n   - Part-whole: meronym/holonym (part/substance/member)\n   - Functional: used_for, causes, instrument (DanNet-specific)\n\nCORE RELATION CATEGORIES:\n- Taxonomic: hypernym/hyponym chains + orthogonalHyponym for cross-cutting categories\n- Part-Whole: mero_part/holo_part (components), mero_member/holo_member (collections), \n  mero_substance/holo_substance (materials), mero_location/holo_location (spatial)\n- Thematic Roles: agent/involved_agent (who), instrument/involved_instrument (with what),\n  patient/involved_patient (to what), result/involved_result (outcome)\n- Functional: usedFor/usedForObject (purpose), domain_topic/has_domain_topic (fields)\n- Causal-Temporal: causes/is_caused_by, entails/is_entailed_by, subevent/is_subevent_of\n- Similarity-Opposition: similar, eq_synonym, antonym (+ gradable/simple/converse variants)\n- Co-occurrence: co_agent_instrument, co_patient_agent (systematic co-occurrence patterns)\n\nSEMANTIC PATTERNS BY DOMAIN:\n- Animals: taxonomic hierarchies + agent roles + instrument co-occurrence\n- Artifacts: extensive part-whole decomposition + functional domains\n- Actions: thematic role chains (agent-instrument-patient-result)\n- Body parts: anatomical part-whole hierarchies + location relations\n- Emotions: similarity networks + sentiment annotations\n- Locations: spatial containment + domain classifications\n\nONTOLOGICAL TYPES (dns:ontologicalType):\nCore: Animal, Human, Object, Physical, Mental, Property\nEvents: BoundedEvent, UnboundedEvent, Agentive, Cause\nArtifacts: Vehicle, Instrument, Artifact, Natural, BodyPart\nDomains: Place, Location, Comestible, Occupation\n\nDANNET EXTENSIONS:\n- Sentiment polarity (Positive/Negative) with intensity values\n- Inheritance system (dns:inherited) reduces redundancy\n- DDO integration via synset labels {word_entry\u00a7definition}\n- Cross-linguistic via wn:ili (Inter-Lingual Index) + the Open English WordNet\n\nJSON-LD FORMAT GUIDE:\n- All responses use standard JSON-LD with @context, @id, @type\n- Namespace prefixes: dns: (schema), wn: (WordNet), ontolex: (vocabulary)\n- Semantic data directly accessible: dns:ontologicalType[\"@set\"], dns:sentiment[\"marl:hasPolarity\"]\n- Property names use colon format: \"dns:sentiment\" not \":dns/sentiment\"\n- Multi-value properties use arrays: [\"dn:synset-1\", \"dn:synset-2\"]\n- Language-tagged literals: {\"@value\": \"text\", \"@language\": \"da\"}\n\nKEY SEMANTIC PATTERNS:\n- Hypernym chains reveal conceptual hierarchies\n- Multiple hyponyms indicate important category nodes\n- dns:inherited shows properties from parent concepts\n- Cross-linguistic via wn:ili (or wn:eq_synonym to the Open English WordNet)\n\nDATA FORMATS:\n- JSON-LD responses with semantic data directly accessible\n- Clean namespace prefixes (dns: for schema, dn: for data)\n- Raw RDF available via Turtle format for graph operations\n- All properties use standard JSON-LD format with @context\n\nTIPS FOR LLM USAGE:\n- Start broad with word search, then narrow to specific synsets\n- Use ontological types to understand what kind of entity something is\n- Follow relation chains: taxonomic for classification, functional for purpose,\n  part-whole for composition, thematic roles for event structure\n- Check sentiment annotations for emotional concepts\n",
            "protocolVersion": "2025-03-26",
            "serverInfo": {
              "name": "DanNet",
              "version": "1.27.0"
            }
          }
        },
        "url": "https://wordnet.dk/mcp"
      },
      "latency_ms": 324.75,
      "status": "ok"
    },
    "interactive_flow_probe": {
      "details": {
        "oauth_supported": false,
        "prompt_available": false,
        "risk_hits": [],
        "safe_hits": []
      },
      "latency_ms": null,
      "status": "missing"
    },
    "oauth_authorization_server": {
      "details": {
        "reason": "no_authorization_server"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "oauth_protected_resource": {
      "details": {
        "error": "Client error '404 Not Found' for url 'https://wordnet.dk/.well-known/oauth-protected-resource'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
        "url": "https://wordnet.dk/.well-known/oauth-protected-resource"
      },
      "latency_ms": 319.42,
      "status": "error"
    },
    "official_registry_probe": {
      "details": {
        "direct_match": true,
        "official_peer_count": 1,
        "registry_identifier": "io.github.kuhumcst/dannet",
        "registry_source": "official_registry"
      },
      "latency_ms": null,
      "status": "ok"
    },
    "openid_configuration": {
      "details": {
        "reason": "no_authorization_server"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "probe_noise_resilience": {
      "details": {
        "headers": {
          "content-type": "text/plain"
        },
        "http_status": 404,
        "url": "https://wordnet.dk/robots.txt"
      },
      "latency_ms": 312.18,
      "status": "ok"
    },
    "prompt_get": {
      "details": {
        "reason": "not_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "prompts_list": {
      "details": {
        "error": "Client error '400 Bad Request' for url 'https://wordnet.dk/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
        "headers": {
          "content-type": "application/json",
          "mcp-session-id": "87ad0e9246414c098134512126c56dd9"
        },
        "http_status": 400,
        "payload": {},
        "reason": "not_advertised",
        "url": "https://wordnet.dk/mcp"
      },
      "latency_ms": 317.73,
      "status": "missing"
    },
    "protocol_version_probe": {
      "details": {
        "claimed_version": "2025-03-26",
        "lag_days": 244,
        "latest_known_version": "2025-11-25",
        "releases_behind": 2,
        "validator_protocol_version": "2025-03-26"
      },
      "latency_ms": null,
      "status": "warning"
    },
    "provenance_divergence_probe": {
      "details": {
        "direct_official_match": true,
        "drift_fields": [],
        "metadata_document_count": 1,
        "registry_homepage": null,
        "registry_repository": null,
        "registry_title": null,
        "registry_version": null,
        "server_card_homepage": null,
        "server_card_repository": null,
        "server_card_title": null,
        "server_card_version": null
      },
      "latency_ms": null,
      "status": "ok"
    },
    "request_association_probe": {
      "details": {
        "reason": "no_request_association_capabilities_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "resource_read": {
      "details": {
        "reason": "not_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "resources_list": {
      "details": {
        "error": "Client error '400 Bad Request' for url 'https://wordnet.dk/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
        "headers": {
          "content-type": "application/json",
          "mcp-session-id": "482ce4a979a8415399918ffc555072c7"
        },
        "http_status": 400,
        "payload": {},
        "reason": "not_advertised",
        "url": "https://wordnet.dk/mcp"
      },
      "latency_ms": 321.68,
      "status": "missing"
    },
    "server_card": {
      "details": {
        "error": "Client error '404 Not Found' for url 'https://wordnet.dk/.well-known/mcp/server-card.json'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
        "url": "https://wordnet.dk/.well-known/mcp/server-card.json"
      },
      "latency_ms": 523.91,
      "status": "error"
    },
    "session_resume_probe": {
      "details": {
        "headers": {
          "content-type": "text/event-stream",
          "mcp-session-id": "576a4e003d6a4651aa6de66bd7d559ed"
        },
        "http_status": 200,
        "payload": {
          "id": 301,
          "jsonrpc": "2.0",
          "result": {
            "tools": [
              {
                "description": "\nGet synsets (word meanings) for a Danish word, returning a sorted list of lexical concepts.\n\nDanNet follows the OntoLex-Lemon model where:\n- Words (ontolex:LexicalEntry) evoke concepts through senses\n- Synsets (ontolex:LexicalConcept) represent units of meaning\n- Multiple words can share the same synset (synonyms)\n- One word can have multiple synsets (polysemy)\n\nThis function returns all synsets associated with a word, effectively giving you\nall the different meanings/senses that word can have. Each synset represents\na distinct semantic concept with its own definition and semantic relationships.\n\nCommon patterns in Danish:\n- Nouns often have multiple senses (e.g., \"kage\" = cake/lump)\n- Verbs distinguish motion vs. state (e.g., \"l\u00f8be\" = run/flow)\n- Check synset's dns:ontologicalType for semantic classification\n\nDDO CONNECTION AND SYNSET LABELS:\nSynset labels are compositions of DDO-derived sense labels, showing all words that \nexpress the same meaning. For example:\n- \"{hund_1\u00a71; k\u00f8ter_\u00a71; vovhund_\u00a71; vovse_\u00a71}\" = all words meaning \"domestic dog\"\n- \"{forlygte_\u00a72; babs_\u00a71; bryst_\u00a72; patte_1\u00a71a}\" = all words meaning \"female breast\"\n\nEach individual sense label follows DDO structure:\n- \"hund_1\u00a71\" = word \"hund\", entry 1, definition 1 in DDO (ordnet.dk)\n- \"patte_1\u00a71a\" = word \"patte\", entry 1, definition 1, subdefinition a\n- The \u00a7 notation connects directly to DDO's definition numbering system\n\nThis composition reveals the semantic relationships between Danish words and their\nshared meanings, all traceable back to authoritative DDO lexicographic data.\n\nRETURN BEHAVIOR:\nThis function has two possible return modes depending on search results:\n\n1. MULTIPLE RESULTS: Returns List[SearchResult] with basic information for each synset\n2. SINGLE RESULT (redirect): Returns full synset data Dict when DanNet automatically \n   redirects to a single synset. This provides immediate access to all semantic \n   relationships, ontological types, sentiment data, and other rich information \n   without requiring a separate get_synset_info() call.\n\nThe single-result case is equivalent to calling get_synset_info() on the synset,\nproviding the same comprehensive RDF data structure with all semantic relations.\n\nArgs:\n    query: The Danish word or phrase to search for\n\n    language: Language for labels and definitions in results (default: \"da\" for Danish, \"en\" for English when available)\n    Note: Only Danish words can be searched regardless of this parameter\n    \nReturns:\n    MULTIPLE RESULTS: List of SearchResult objects with:\n    - word: The lexical form\n    - synset_id: Unique synset identifier (format: synset-NNNNN)\n    - label: Human-readable synset label (e.g., \"{kage_1\u00a71}\")\n    - definition: Brief semantic definition (may be truncated with \"...\")\n    \n    SINGLE RESULT: Dict with complete synset data including:\n    - All RDF properties with namespace prefixes (e.g., wn:hypernym)\n    - dns:ontologicalType \u2192 semantic types with @set array\n    - dns:sentiment \u2192 parsed sentiment (if present)\n    - synset_id \u2192 clean identifier for convenience\n    - All semantic relationships and linguistic properties\n\nExamples:\n    # Multiple results case\n    results = get_word_synsets(\"hund\")\n    # Returns list of search result dictionaries for all meanings of \"hund\"\n    # => [{\"word\": \"hund\", \"synset_id\": \"synset-3047\", ...}, ...]\n    \n    # Single result case (redirect)\n    result = get_word_synsets(\"svinke\u00e6rinde\")  \n    # Returns complete synset data for unique word\n    # => {'wn:hypernym': 'dn:synset-11677', 'dns:sentiment': {...}, ...}\n",
                "inputSchema": {
                  "properties": {
                    "language": {
                      "default": "da",
                      "title": "Language",
                      "type": "string"
                    },
                    "query": {
                      "title": "Query",
                      "type": "string"
                    }
                  },
                  "required": [
                    "query"
                  ],
                  "title": "get_word_synsetsArguments",
                  "type": "object"
                },
                "name": "get_word_synsets",
                "outputSchema": {
                  "$defs": {
                    "SearchResult": {
                      "description": "Search result from DanNet",
                      "properties": {
                        "definition": {
                          "anyOf": [
                            {
                              "type": "string"
                            },
                            {
                              "type": "null"
                            }
                          ],
                          "description": "Definition",
                          "title": "Definition"
                        },
                        "label": {
                          "anyOf": [
                            {
                              "type": "string"
                            },
                            {
                              "type": "null"
                            }
                          ],
                          "description": "Synset label",
                          "title": "Label"
                        },
                        "synset_id": {
                          "anyOf": [
                            {
                              "type": "string"
                            },
                            {
                              "type": "null"
                            }
                          ],
                          "description": "Associated synset ID",
                          "title": "Synset Id"
                        },
                        "word": {
                          "description": "The word form",
                          "title": "Word",
                          "type": "string"
                        }
                      },
                      "required": [
                        "word",
                        "synset_id",
                        "label",
                        "definition"
                      ],
                      "title": "SearchResult",
                      "type": "object"
                    }
                  },
                  "properties": {
                    "result": {
                      "anyOf": [
                        {
                          "items": {
                            "$ref": "#/$defs/SearchResult"
                          },
                          "type": "array"
                        },
                        {
                          "additionalProperties": true,
                          "type": "object"
                        }
                      ],
                      "title": "Result"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_word_synsetsOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet comprehensive RDF data for any entity in the DanNet database.\n\nSupports both DanNet entities and external vocabulary entities loaded\ninto the triplestore from various schemas and datasets.\n\nUNDERSTANDING THE DATA MODEL:\nThe DanNet database contains entities from multiple sources:\n- DanNet entities (namespace=\"dn\"): synsets, words, senses, and other resources\n- External entities (other namespaces): OntoLex vocabulary, Inter-Lingual Index, etc.\n\nAll entities follow RDF patterns with namespace prefixes for properties and relationships.\n\nNAVIGATION TIPS:\n- DanNet synsets have rich semantic relationships (wn:hypernym, wn:hyponym, etc.)\n- External entities provide vocabulary definitions and cross-references\n- Use parse_resource_id() on URI references to get clean IDs\n- Check @type to understand what kind of entity you're working with\n\nArgs:\n    identifier: Entity identifier (e.g., \"synset-3047\", \"word-11021628\", \"LexicalConcept\", \"i76470\")\n    namespace: Namespace for the entity (default: \"dn\" for DanNet entities)\n              - \"dn\": DanNet entities via /dannet/data/ endpoint\n              - Other values: External entities via /dannet/external/{namespace}/ endpoint\n              - Common external namespaces: \"ontolex\", \"ili\", \"wn\", \"lexinfo\", etc.\n\nReturns:\n    Dict containing JSON-LD format with:\n    - @context \u2192 namespace mappings (if applicable)\n    - @id \u2192 entity identifier\n    - @type \u2192 entity type\n    - All RDF properties with namespace prefixes (e.g., wn:hypernym, ontolex:evokes)\n    - For DanNet synsets: dns:ontologicalType and dns:sentiment (if applicable)\n    - Entity-specific convenience fields (synset_id, resource_id, etc.)\n\nExamples:\n    # DanNet entities\n    get_entity_info(\"synset-3047\")  # DanNet synset\n    get_entity_info(\"word-11021628\")  # DanNet word\n    get_entity_info(\"sense-21033604\")  # DanNet sense\n    \n    # External vocabulary entities  \n    get_entity_info(\"LexicalConcept\", namespace=\"ontolex\")  # OntoLex class definition\n    get_entity_info(\"i76470\", namespace=\"ili\")  # Inter-Lingual Index entry\n    get_entity_info(\"noun\", namespace=\"lexinfo\")  # Lexinfo part-of-speech\n",
                "inputSchema": {
                  "properties": {
                    "identifier": {
                      "title": "Identifier",
                      "type": "string"
                    },
                    "namespace": {
                      "default": "dn",
                      "title": "Namespace",
                      "type": "string"
                    }
                  },
                  "required": [
                    "identifier"
                  ],
                  "title": "get_entity_infoArguments",
                  "type": "object"
                },
                "name": "get_entity_info",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_entity_infoOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet comprehensive RDF data for a DanNet synset (lexical concept).\n\nUNDERSTANDING THE DATA MODEL:\nSynsets are ontolex:LexicalConcept instances representing word meanings.\nThey connect to words via ontolex:isEvokedBy and have rich semantic relations.\n\nKEY RELATIONSHIPS (by importance):\n\n1. TAXONOMIC (most fundamental):\n   - wn:hypernym \u2192 broader concept (e.g., \"hund\" \u2192 \"pattedyr\")\n   - wn:hyponym \u2192 narrower concepts (e.g., \"hund\" \u2192 \"puddel\", \"sch\u00e6fer\")\n   - dns:orthogonalHypernym \u2192 cross-cutting categories [Danish: ortogonalt hyperonym]\n\n2. LEXICAL CONNECTIONS:\n   - ontolex:isEvokedBy \u2192 words expressing this concept [Danish: fremkaldes af]\n   - ontolex:lexicalizedSense \u2192 sense instances [Danish: leksikaliseret betydning]\n   - wn:similar \u2192 related but distinct concepts\n\n3. PART-WHOLE RELATIONS:\n   - wn:mero_part/wn:holo_part \u2192 component relationships [English: meronym/holonym part]\n   - wn:mero_substance/wn:holo_substance \u2192 material composition\n   - wn:mero_member/wn:holo_member \u2192 membership relations\n\n4. SEMANTIC PROPERTIES:\n   - dns:ontologicalType \u2192 semantic classification with @set array of dnc: types\n     Common types: dnc:Animal, dnc:Human, dnc:Object, dnc:Physical,\n     dnc:Dynamic (events/actions), dnc:Static (states)\n   - dns:sentiment \u2192 emotional polarity with marl:hasPolarity and marl:polarityValue\n   - wn:lexfile \u2192 semantic domain (e.g., \"noun.food\", \"verb.motion\")\n   - skos:definition \u2192 synset definition (may be truncated for length)\n\n5. CROSS-LINGUISTIC:\n   - wn:ili \u2192 Interlingual Index for cross-language mapping\n   - wn:eq_synonym \u2192 Open English WordNet equivalent\n\nDDO CONNECTION FOR FULLER DEFINITIONS:\nDanNet synset definitions (skos:definition) may be truncated (ending with \"\u2026\").\nFor complete definitions, use the fetch_ddo_definition() tool which automatically\nretrieves full DDO text, or manually examine sense source URLs via get_sense_info().\n\nNAVIGATION TIPS:\n- Follow wn:hypernym chains to find semantic categories\n- Check dns:inherited for properties from parent synsets\n- Use parse_resource_id() on URI references to get clean IDs\n- For fuller definitions, examine individual sense source URLs via get_sense_info()\n\nArgs:\n    synset_id: Synset identifier (e.g., \"synset-1876\" or just \"1876\")\n\nReturns:\n    Dict containing JSON-LD format with:\n    - @context \u2192 namespace mappings\n    - @id \u2192 entity identifier (e.g., \"dn:synset-1876\")\n    - @type \u2192 \"ontolex:LexicalConcept\"\n    - All RDF properties with namespace prefixes (e.g., wn:hypernym)\n    - dns:ontologicalType \u2192 {\"@set\": [\"dnc:Animal\", ...]} (if applicable)\n    - dns:sentiment \u2192 {\"marl:hasPolarity\": \"marl:Positive\", \"marl:polarityValue\": \"3\"} (if applicable)\n    - synset_id \u2192 clean identifier for convenience\n\nExample:\n    info = get_synset_info(\"synset-52\")  # cake synset\n    # Check info['wn:hypernym'] for parent concepts\n    # Check info['dns:ontologicalType']['@set'] for semantic types\n    # Check info['dns:sentiment']['marl:hasPolarity'] for sentiment\n",
                "inputSchema": {
                  "properties": {
                    "synset_id": {
                      "title": "Synset Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "synset_id"
                  ],
                  "title": "get_synset_infoArguments",
                  "type": "object"
                },
                "name": "get_synset_info",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_synset_infoOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet comprehensive RDF data for a DanNet word (lexical entry).\n\nUNDERSTANDING THE DATA MODEL:\nWords are ontolex:LexicalEntry instances representing lexical forms.\nThey connect to synsets via senses and have morphological information.\n\nKEY RELATIONSHIPS:\n\n1. LEXICAL CONNECTIONS:\n   - ontolex:evokes \u2192 synsets this word can express\n   - ontolex:sense \u2192 sense instances connecting word to synsets\n   - ontolex:canonicalForm \u2192 canonical form with written representation\n\n2. MORPHOLOGICAL PROPERTIES:\n   - lexinfo:partOfSpeech \u2192 part of speech classification\n   - wn:partOfSpeech \u2192 WordNet part of speech\n   - ontolex:canonicalForm/ontolex:writtenRep \u2192 written form\n\n3. CROSS-REFERENCES:\n   - owl:sameAs \u2192 equivalent resources in other datasets\n   - dns:source \u2192 source URL for this word entry\n\nNAVIGATION TIPS:\n- Follow ontolex:evokes to find synsets this word expresses\n- Check ontolex:sense for detailed sense information\n- Use parse_resource_id() on URI references to get clean IDs\n\nArgs:\n    word_id: Word identifier (e.g., \"word-11021628\" or just \"11021628\")\n\nReturns:\n    Dict containing:\n    - All RDF properties with namespace prefixes (e.g., ontolex:evokes)\n    - resource_id \u2192 clean identifier for convenience\n    - All linguistic properties and relationships\n\nExample:\n    info = get_word_info(\"word-11021628\")  # \"hund\" word\n    # Check info['ontolex:evokes'] for synsets this word can express\n    # Check info['ontolex:sense'] for senses\n",
                "inputSchema": {
                  "properties": {
                    "word_id": {
                      "title": "Word Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "word_id"
                  ],
                  "title": "get_word_infoArguments",
                  "type": "object"
                },
                "name": "get_word_info",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_word_infoOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet comprehensive RDF data for a DanNet sense (lexical sense).\n\nUNDERSTANDING THE DATA MODEL:\nSenses are ontolex:LexicalSense instances connecting words to synsets.\nThey represent specific meanings of words with examples and definitions.\n\nKEY RELATIONSHIPS:\n\n1. LEXICAL CONNECTIONS:\n   - ontolex:isSenseOf \u2192 word this sense belongs to\n   - ontolex:isLexicalizedSenseOf \u2192 synset this sense represents\n\n2. SEMANTIC INFORMATION:\n   - lexinfo:senseExample \u2192 usage examples in context\n   - rdfs:label \u2192 sense label (e.g., \"hund_1\u00a71\")\n\n3. REGISTER AND STYLISTIC INFORMATION:\n   - lexinfo:register \u2192 formal register classification (e.g., \":lexinfo/slangRegister\")\n   - lexinfo:usageNote \u2192 human-readable usage notes (e.g., \"slang\", \"formal\")\n\n4. SOURCE INFORMATION:\n   - dns:source \u2192 source URL for this sense entry\n\nDDO CONNECTION (Den Danske Ordbog):\nDanNet senses are derived from DDO (ordnet.dk), the authoritative modern Danish dictionary.\n\nSENSE LABELS: The format \"word_entry\u00a7definition\" connects to DDO structure:\n- \"hund_1\u00a71\" = word \"hund\", entry 1, definition 1 in DDO\n- \"forlygte_\u00a72\" = word \"forlygte\", definition 2 in DDO\n- The \u00a7 notation directly corresponds to DDO's definition numbering\n\nSOURCE TRACEABILITY: The dns:source URLs link back to specific DDO entries:\n- Format: https://ordnet.dk/ddo/ordbog?entry_id=X&def_id=Y&query=word\n- Note: Some DDO URLs may not resolve correctly if IDs have changed since import\n- If the DDO page loads correctly, the relevant definition has CSS class \"selected\"\n\nMETADATA ORIGINS: Usage examples, register information, and definitions flow from DDO's\ncorpus-based lexicographic data, providing authoritative linguistic information.\n\nNAVIGATION TIPS:\n- Follow ontolex:isSenseOf to find the parent word\n- Follow ontolex:isLexicalizedSenseOf to find the synset\n- Check lexinfo:senseExample for usage examples from DDO corpus\n- Check lexinfo:register and lexinfo:usageNote for stylistic information\n- Use dns:source to attempt tracing back to original DDO definition (with caveats)\n- Use parse_resource_id() on URI references to get clean IDs\n\nArgs:\n    sense_id: Sense identifier (e.g., \"sense-21033604\" or just \"21033604\")\n\nReturns:\n    Dict containing:\n    - All RDF properties with namespace prefixes (e.g., ontolex:isSenseOf)\n    - resource_id \u2192 clean identifier for convenience\n    - All sense properties and relationships\n\nExample:\n    info = get_sense_info(\"sense-21033604\")  # \"hund_1\u00a71\" sense\n    # Check info['ontolex:isSenseOf'] for parent word\n    # Check info['ontolex:isLexicalizedSenseOf'] for synset\n    # Check info['lexinfo:senseExample'] for usage examples from DDO\n    # Check info['lexinfo:register'] for register classification\n    # Check info['lexinfo:usageNote'] for usage notes like \"slang\"\n    # Check info['dns:source'] for DDO source URL (may not always work)\n",
                "inputSchema": {
                  "properties": {
                    "sense_id": {
                      "title": "Sense Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "sense_id"
                  ],
                  "title": "get_sense_infoArguments",
                  "type": "object"
                },
                "name": "get_sense_info",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_sense_infoOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nFind synonyms for a Danish word through shared synsets (word senses).\n\nSYNONYM TYPES IN DANNET:\n- True synonyms: Words sharing the exact same synset\n- Context-specific: Different synonyms for different word senses\nNote: Near-synonyms via wn:similar relations are not currently included\n\nThe function returns all words that share synsets with the input word,\neffectively finding lexical alternatives that express the same concepts.\n\nArgs:\n    word: The Danish word to find synonyms for\n\nReturns:\n    Comma-separated string of synonymous words (aggregated across all word senses)\n\nExample:\n    synonyms = get_word_synonyms(\"hund\")\n    # Returns: \"k\u00f8ter, vovhund, vovse\"\n\nNote: Check synset definitions to understand which synonyms apply\nto which meaning (polysemy is common in Danish).\n",
                "inputSchema": {
                  "properties": {
                    "word": {
                      "title": "Word",
                      "type": "string"
                    }
                  },
                  "required": [
                    "word"
                  ],
                  "title": "get_word_synonymsArguments",
                  "type": "object"
                },
                "name": "get_word_synonyms",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "title": "Result",
                      "type": "string"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_word_synonymsOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet a complete overview of all senses for a Danish word in a single call.\n\nReplaces the common pattern of calling get_word_synsets \u2192 get_synset_info\nper result \u2192 get_word_synonyms, collapsing 5-15 HTTP round-trips into one\nSPARQL query.\n\nOnly returns synsets where the word is a primary lexical member (i.e. the\nword itself has a direct sense in the synset), excluding multi-word\nexpressions that merely contain the word as a component.\n\nArgs:\n    word: The Danish word to look up\n\nReturns:\n    List of dicts, one per synset, each containing:\n    - synset_id: Clean synset identifier (e.g. \"synset-3047\")\n    - label: Human-readable synset label\n    - definition: Synset definition (may be truncated with \"\u2026\")\n    - ontological_types: List of dnc: type URIs\n    - synonyms: List of co-member lemmas (true synonyms only)\n    - hypernym: Dict with synset_id and label of the immediate broader concept, or null\n    - lexfile: WordNet lexicographer file name (e.g. \"noun.animal\"), or null if absent\n\nExample:\n    overview = get_word_overview(\"hund\")\n    # Returns list of 4 synsets, the first being:\n    # {\"synset_id\": \"synset-3047\",\n    #  \"label\": \"{hund_1\u00a71; k\u00f8ter_\u00a71; vovhund_\u00a71; vovse_\u00a71}\",\n    #  \"definition\": \"pattedyr som har god lugtesans ...\",\n    #  \"ontological_types\": [\"dnc:Animal\", \"dnc:Object\"],\n    #  \"synonyms\": [\"k\u00f8ter\", \"vovhund\", \"vovse\"],\n    #  \"lexfile\": \"noun.animal\"}\n\n    # Pass synset_id to get_synset_info() for full JSON-LD data on any result:\n    # full_data = get_synset_info(overview[0][\"synset_id\"])\n",
                "inputSchema": {
                  "properties": {
                    "word": {
                      "title": "Word",
                      "type": "string"
                    }
                  },
                  "required": [
                    "word"
                  ],
                  "title": "get_word_overviewArguments",
                  "type": "object"
                },
                "name": "get_word_overview",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "items": {
                        "additionalProperties": true,
                        "type": "object"
                      },
                      "title": "Result",
                      "type": "array"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_word_overviewOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet autocomplete suggestions for Danish word prefixes.\n\nUseful for discovering Danish vocabulary or finding the correct spelling\nof words. Returns lemma forms (dictionary forms) of words.\n\nArgs:\n    prefix: The beginning of a Danish word (minimum 3 characters required)\n    max_results: Maximum number of suggestions to return (default: 10)\n    \nReturns:\n    Comma-separated string of word completions in alphabetical order\n\nNote: Autocomplete requires at least 3 characters to prevent excessive results.\n\nExample:\n    suggestions = autocomplete_danish_word(\"hyg\", 5)\n    # Returns: \"hygge, hyggelig, hygiejne\"\n",
                "inputSchema": {
                  "properties": {
                    "max_results": {
                      "default": 10,
                      "title": "Max Results",
                      "type": "integer"
                    },
                    "prefix": {
                      "title": "Prefix",
                      "type": "string"
                    }
                  },
                  "required": [
                    "prefix"
                  ],
                  "title": "autocomplete_danish_wordArguments",
                  "type": "object"
                },
                "name": "autocomplete_danish_word",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "title": "Result",
                      "type": "string"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "autocomplete_danish_wordOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nSwitch between local and remote DanNet servers on the fly.\n\nThis tool allows you to change the DanNet server endpoint during runtime\nwithout restarting the MCP server. Useful for switching between development\n(local) and production (remote) servers.\n\nArgs:\n    server: Server to switch to. Options:\n           - \"local\": Use localhost:3456 (development server)\n           - \"remote\": Use wordnet.dk (production server)\n           - Custom URL: Any valid URL starting with http:// or https://\n\nReturns:\n    Dict with status information:\n    - status: \"success\" or \"error\"\n    - message: Description of the operation\n    - previous_url: The URL that was previously active\n    - current_url: The URL that is now active\n\nExample:\n    # Switch to local development server\n    result = switch_dannet_server(\"local\")\n    \n    # Switch to production server\n    result = switch_dannet_server(\"remote\")\n    \n    # Switch to custom server\n    result = switch_dannet_server(\"https://my-custom-dannet.example.com\")\n",
                "inputSchema": {
                  "properties": {
                    "server": {
                      "title": "Server",
                      "type": "string"
                    }
                  },
                  "required": [
                    "server"
                  ],
                  "title": "switch_dannet_serverArguments",
                  "type": "object"
                },
                "name": "switch_dannet_server",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": {
                        "type": "string"
                      },
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "switch_dannet_serverOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nGet information about the currently active DanNet server.\n\nReturns:\n    Dict with current server information:\n    - server_url: The base URL of the current DanNet server\n    - server_type: \"local\", \"remote\", or \"custom\"\n    - status: Connection status information\n\nExample:\n    info = get_current_dannet_server()\n    # Returns: {\"server_url\": \"https://wordnet.dk\", \"server_type\": \"remote\", \"status\": \"active\"}\n",
                "inputSchema": {
                  "properties": {},
                  "title": "get_current_dannet_serverArguments",
                  "type": "object"
                },
                "name": "get_current_dannet_server",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": {
                        "type": "string"
                      },
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_current_dannet_serverOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nReturn statistics about the session-scoped resource cache.\n\nUseful for verifying that caching is working: call get_synset_info (or similar)\ntwice for the same ID and check that cache_size grows by 1 on the first call\nbut not on the second, and that cached_keys contains the expected IDs.\n\nReturns:\n    Dict with:\n    - cache_size: Total number of cached entries\n    - cached_keys: List of (base_url, resource_id) pairs currently cached\n",
                "inputSchema": {
                  "properties": {},
                  "title": "get_cache_statsArguments",
                  "type": "object"
                },
                "name": "get_cache_stats",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "get_cache_statsOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nFetch the full, untruncated definition from DDO (Den Danske Ordbog) for a synset.\n\nThis tool addresses the issue that DanNet synset definitions (:skos/definition)\nmay be capped at a certain length. It retrieves the complete definition from\nthe authoritative DDO source by following sense source URLs.\n\nWORKFLOW:\n1. Get synset information to find associated senses\n2. Extract DDO source URLs from sense data (dns:source)\n3. Fetch DDO HTML pages and parse for definitions\n4. Find elements with class \"definitionBox selected\" and extract span.definition content\n\nIMPORTANT NOTES:\n- Looks for CSS classes \"definitionBox selected\" and child span.definition\n- DDO and DanNet have diverged over time, so source URLs may not always work\n- This implementation uses httpx for web requests and regex-based HTML parsing\n\nArgs:\n    synset_id: Synset identifier (e.g., \"synset-1876\" or just \"1876\")\n\nReturns:\n    Dict containing:\n    - synset_id: The queried synset ID\n    - ddo_definitions: List of definitions found from DDO pages\n    - source_urls: List of DDO URLs that were attempted\n    - success_urls: List of URLs that successfully returned definitions\n    - errors: List of any errors encountered\n    - truncated_definition: The original DanNet definition for comparison\n\nExample:\n    result = fetch_ddo_definition(\"synset-3047\")\n    # Check result['ddo_definitions'] for full DDO definitions\n    # Compare with result['truncated_definition'] from DanNet\n",
                "inputSchema": {
                  "properties": {
                    "synset_id": {
                      "title": "Synset Id",
                      "type": "string"
                    }
                  },
                  "required": [
                    "synset_id"
                  ],
                  "title": "fetch_ddo_definitionArguments",
                  "type": "object"
                },
                "name": "fetch_ddo_definition",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "fetch_ddo_definitionOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nValidate and analyze the structure of synset JSON-LD data.\n\nThis enhanced tool helps debug and understand synset data structure,\nproviding validation and insights into the JSON-LD format.\n\nArgs:\n    synset_data: Synset data returned from get_synset_info()\n    \nReturns:\n    Dict with validation results and structural analysis\n",
                "inputSchema": {
                  "properties": {
                    "synset_data": {
                      "additionalProperties": true,
                      "title": "Synset Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "synset_data"
                  ],
                  "title": "validate_synset_structureArguments",
                  "type": "object"
                },
                "name": "validate_synset_structure",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "validate_synset_structureOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nExtract and normalize semantic data from any DanNet JSON-LD entity.\n\nThis tool provides a unified way to extract semantic information from\nsynsets, words, or senses, handling different JSON-LD structures consistently.\n\nArgs:\n    entity_data: Any DanNet entity JSON-LD data\n    \nReturns:\n    Dict with normalized semantic information\n",
                "inputSchema": {
                  "properties": {
                    "entity_data": {
                      "additionalProperties": true,
                      "title": "Entity Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "entity_data"
                  ],
                  "title": "extract_semantic_dataArguments",
                  "type": "object"
                },
                "name": "extract_semantic_data",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "extract_semantic_dataOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nAnalyze namespace usage and provide resolution for prefixed properties.\n\nThis debugging tool helps understand how namespaces are used in\nDanNet JSON-LD data and resolves prefixed URIs to full forms.\n\nArgs:\n    entity_data: Any DanNet JSON-LD entity data\n    \nReturns:\n    Dict with namespace analysis and URI resolution\n",
                "inputSchema": {
                  "properties": {
                    "entity_data": {
                      "additionalProperties": true,
                      "title": "Entity Data",
                      "type": "object"
                    }
                  },
                  "required": [
                    "entity_data"
                  ],
                  "title": "analyze_namespace_usageArguments",
                  "type": "object"
                },
                "name": "analyze_namespace_usage",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "analyze_namespace_usageOutput",
                  "type": "object"
                }
              },
              {
                "description": "\nExecute a SPARQL SELECT query against the DanNet triplestore.\n\nThis tool provides direct access to DanNet's RDF data through SPARQL queries.\nThe query is automatically prepended with common namespace prefix declarations,\nso you can use short prefixes instead of full URIs in your queries.\n\n============================================================\nCRITICAL PERFORMANCE RULES (read before writing any query):\n============================================================\n\n1. ALWAYS start from a known entity URI or a word lookup \u2014 never scan the whole graph.\n   FAST: dn:synset-3047 wn:hypernym ?x .\n   SLOW: ?x wn:hypernym ?y .  (scans every synset)\n\n2. ALWAYS use DISTINCT for SELECT queries to avoid duplicate rows.\n\n3. NEVER use FILTER(CONTAINS(...)) on labels across the whole graph.\n   SLOW: ?s rdfs:label ?l . FILTER(CONTAINS(?l, \"hund\"))\n   FAST: Use get_word_synsets(\"hund\") first, then query specific synset URIs.\n\n4. NEVER create cartesian products \u2014 every triple pattern must share a variable\n   with at least one other pattern.\n   SLOW: ?x a ontolex:LexicalConcept . ?y a ontolex:LexicalEntry . (cross join!)\n\n5. ALWAYS add LIMIT (even if max_results caps it server-side, explicit LIMIT\n   lets the query engine optimize).\n\n6. Use property paths for multi-hop traversals:\n   FAST: dn:synset-3047 wn:hypernym+ ?ancestor .  (transitive closure)\n   FAST: ?entry ontolex:canonicalForm/ontolex:writtenRep \"hund\"@da .  (path)\n\n7. Prefer VALUES over FILTER for matching multiple known entities:\n   FAST: VALUES ?synset { dn:synset-3047 dn:synset-3048 } ?synset rdfs:label ?l .\n   SLOW: ?synset rdfs:label ?l . FILTER(?synset = dn:synset-3047 || ?synset = dn:synset-3048)\n\n8. The triplestore contains BOTH DanNet (Danish, dn: namespace) AND the Open\n   English WordNet (en: namespace). Unanchored queries will scan both.\n   To restrict to Danish data, anchor on dn: URIs or use @da language tags.\n\n============================================\nFAST QUERY TEMPLATES (copy and adapt these):\n============================================\n\n# TEMPLATE 1: Find synsets for a Danish word (via word lookup)\nSELECT DISTINCT ?synset ?label ?def WHERE {\n  ?entry ontolex:canonicalForm/ontolex:writtenRep \"WORD\"@da .\n  ?entry ontolex:sense/ontolex:isLexicalizedSenseOf ?synset .\n  ?synset rdfs:label ?label .\n  OPTIONAL { ?synset skos:definition ?def }\n}\n\n# TEMPLATE 2: Get all properties of a known synset\nSELECT ?p ?o WHERE {\n  dn:synset-NNNN ?p ?o .\n} LIMIT 50\n\n# TEMPLATE 3: Find hypernyms (broader concepts) of a known synset\nSELECT DISTINCT ?hypernym ?label WHERE {\n  dn:synset-NNNN wn:hypernym ?hypernym .\n  ?hypernym rdfs:label ?label .\n}\n\n# TEMPLATE 4: Find hyponyms (narrower concepts) of a known synset\nSELECT DISTINCT ?hyponym ?label WHERE {\n  ?hyponym wn:hypernym dn:synset-NNNN .\n  ?hyponym rdfs:label ?label .\n}\n\n# TEMPLATE 5: Trace full hypernym chain (taxonomic ancestors)\nSELECT DISTINCT ?ancestor ?label WHERE {\n  dn:synset-NNNN wn:hypernym+ ?ancestor .\n  ?ancestor rdfs:label ?label .\n}\n\n# TEMPLATE 6: Find all relationships OF a known synset\nSELECT DISTINCT ?rel ?target ?targetLabel WHERE {\n  dn:synset-NNNN ?rel ?target .\n  ?target rdfs:label ?targetLabel .\n  FILTER(isURI(?target))\n} LIMIT 50\n\n# TEMPLATE 7: Find all relationships TO a known synset\nSELECT DISTINCT ?source ?rel ?sourceLabel WHERE {\n  ?source ?rel dn:synset-NNNN .\n  ?source rdfs:label ?sourceLabel .\n  FILTER(isURI(?source))\n} LIMIT 50\n\n# TEMPLATE 8: Query multiple known synsets at once\nSELECT DISTINCT ?synset ?label ?def WHERE {\n  VALUES ?synset { dn:synset-3047 dn:synset-3048 dn:synset-6524 }\n  ?synset rdfs:label ?label .\n  OPTIONAL { ?synset skos:definition ?def }\n}\n\n# TEMPLATE 9: Find functional relations for a specific synset\nSELECT DISTINCT ?rel ?target ?targetLabel WHERE {\n  dn:synset-NNNN ?rel ?target .\n  ?target rdfs:label ?targetLabel .\n  VALUES ?rel { dns:usedFor dns:usedForObject wn:agent wn:instrument wn:causes }\n}\n\n# TEMPLATE 10: Find ontological type of a synset (stored as RDF Bag)\nSELECT ?type WHERE {\n  dn:synset-NNNN dns:ontologicalType ?bag .\n  ?bag ?pos ?type .\n  FILTER(STRSTARTS(STR(?pos), STR(rdf:_)))\n}\n\n============================================\nKNOWN PREFIXES (automatically declared):\n============================================\ndn: (DanNet data), dns: (DanNet schema), dnc: (DanNet concepts),\nwn: (WordNet relations), ontolex: (lexical model), skos: (definitions),\nrdfs: (labels), rdf: (types), owl: (ontology), lexinfo: (morphology),\nmarl: (sentiment), dc: (metadata), ili: (interlingual index),\nen: (English WordNet), enl: (English lemmas), cor: (Danish register)\n\nArgs:\n    query: SPARQL SELECT query string (prefixes will be automatically added)\n    timeout: Query timeout in milliseconds (default: 8000, max: 15000)\n    max_results: Maximum number of results to return (default: 100, max: 100)\n    distinct: Auto-apply DISTINCT to SELECT queries (default: True).\n              Set to False when you need duplicate rows, e.g. for frequency counts.\n    inference: Control model selection for query execution (default: None).\n               None = auto-detect: tries base model first, retries with inference\n               if SELECT results are empty (best for most queries).\n               True = force inference model: needed for inverse relations like\n               wn:hyponym, wn:holonym, etc. that are derived by OWL reasoning.\n               False = force base model only, no retry.\n\nReturns:\n    Dict containing SPARQL results in standard JSON format:\n    - head: Query metadata with variable names\n    - results: Bindings array with variable-value mappings\n    Each value includes type (uri/literal) and language information when applicable\n\nNote: Only SELECT queries are supported. The query is validated before execution.\n",
                "inputSchema": {
                  "properties": {
                    "distinct": {
                      "default": true,
                      "title": "Distinct",
                      "type": "boolean"
                    },
                    "inference": {
                      "anyOf": [
                        {
                          "type": "boolean"
                        },
                        {
                          "type": "null"
                        }
                      ],
                      "default": null,
                      "title": "Inference"
                    },
                    "max_results": {
                      "default": 100,
                      "title": "Max Results",
                      "type": "integer"
                    },
                    "query": {
                      "title": "Query",
                      "type": "string"
                    },
                    "timeout": {
                      "default": 8000,
                      "title": "Timeout",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "query"
                  ],
                  "title": "sparql_queryArguments",
                  "type": "object"
                },
                "name": "sparql_query",
                "outputSchema": {
                  "properties": {
                    "result": {
                      "additionalProperties": true,
                      "title": "Result",
                      "type": "object"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "title": "sparql_queryOutput",
                  "type": "object"
                }
              }
            ]
          }
        },
        "requested_protocol_version": "2025-03-26",
        "resumed": true,
        "session_id_present": true,
        "transport": "streamable-http",
        "url": "https://wordnet.dk/mcp"
      },
      "latency_ms": 223.25,
      "status": "ok"
    },
    "step_up_auth_probe": {
      "details": {
        "auth_required_checks": [],
        "broad_scopes": [],
        "challenge_headers": [],
        "minimal_scope_documented": false,
        "oauth_present": false,
        "scope_specificity_ratio": 0.0,
        "step_up_signals": [],
        "supported_scopes": []
      },
      "latency_ms": null,
      "status": "missing"
    },
    "tool_snapshot_probe": {
      "details": {
        "reason": "no_tools"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "tools_list": {
      "details": {
        "error": "Client error '400 Bad Request' for url 'https://wordnet.dk/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
        "headers": {
          "content-type": "application/json",
          "mcp-session-id": "0fd70a27ef634c86ba4748102f736b95"
        },
        "http_status": 400,
        "payload": {},
        "url": "https://wordnet.dk/mcp"
      },
      "latency_ms": 330.1,
      "status": "error"
    },
    "transport_compliance_probe": {
      "details": {
        "bad_protocol_error": null,
        "bad_protocol_headers": {
          "content-type": "application/json",
          "mcp-session-id": "576a4e003d6a4651aa6de66bd7d559ed"
        },
        "bad_protocol_payload": {
          "error": {
            "code": -32600,
            "message": "Bad Request: Unsupported protocol version: 1999-99-99. Supported versions: 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25"
          },
          "id": "server-error",
          "jsonrpc": "2.0"
        },
        "bad_protocol_status_code": 400,
        "delete_error": null,
        "delete_status_code": 200,
        "expired_session_error": null,
        "expired_session_status_code": 404,
        "issues": [
          "missing_protocol_header"
        ],
        "last_event_id_visible": false,
        "protocol_header_present": false,
        "requested_protocol_version": "2025-03-26",
        "session_id_present": true,
        "transport": "streamable-http"
      },
      "latency_ms": 211.31,
      "status": "warning"
    },
    "utility_coverage_probe": {
      "details": {
        "completions": {
          "advertised": false,
          "live_probe": "not_executed",
          "sample_target": null
        },
        "initialize_capability_keys": [
          "experimental",
          "prompts",
          "resources",
          "tools"
        ],
        "pagination": {
          "metadata_signal": false,
          "next_cursor_methods": [],
          "supported": false
        },
        "tasks": {
          "advertised": false,
          "http_status": 400,
          "probe_status": "missing"
        }
      },
      "latency_ms": 110.82,
      "status": "missing"
    }
  },
  "failures": {
    "oauth_authorization_server": {
      "reason": "no_authorization_server"
    },
    "oauth_protected_resource": {
      "error": "Client error '404 Not Found' for url 'https://wordnet.dk/.well-known/oauth-protected-resource'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
      "url": "https://wordnet.dk/.well-known/oauth-protected-resource"
    },
    "openid_configuration": {
      "reason": "no_authorization_server"
    },
    "server_card": {
      "error": "Client error '404 Not Found' for url 'https://wordnet.dk/.well-known/mcp/server-card.json'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404",
      "url": "https://wordnet.dk/.well-known/mcp/server-card.json"
    },
    "tools_list": {
      "error": "Client error '400 Bad Request' for url 'https://wordnet.dk/mcp'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400",
      "headers": {
        "content-type": "application/json",
        "mcp-session-id": "0fd70a27ef634c86ba4748102f736b95"
      },
      "http_status": 400,
      "payload": {},
      "url": "https://wordnet.dk/mcp"
    }
  },
  "remote_url": "https://wordnet.dk/mcp",
  "server_card_payload": null,
  "server_identifier": "io.github.kuhumcst/dannet"
}