dictionary-mcp-server 0.1.0__py3-none-any.whl

dictionary_mcp_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: dictionary-mcp-server
+Version: 0.1.0
+Summary: MCP-Server fuer Woerterbuch-Daten: Definitionen, Synonyme, Antonyme, Reime, Phonetik. Free Dictionary API + Datamuse, kein API-Key noetig.
+Project-URL: Homepage, https://github.com/AiAgentKarl/dictionary-mcp-server
+Project-URL: Repository, https://github.com/AiAgentKarl/dictionary-mcp-server
+Project-URL: Issues, https://github.com/AiAgentKarl/dictionary-mcp-server/issues
+Author-email: AiAgentKarl <coach1916@gmail.com>
+License: MIT
+Keywords: ai-agent,antonyms,dictionary,linguistics,mcp,nlp,rhymes,synonyms,thesaurus,wordnet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# dictionary-mcp-server
+
+MCP-Server fuer AI-Agents mit Zugriff auf Woerterbuch-, Thesaurus- und Linguistik-Daten. Liefert Definitionen, Synonyme, Antonyme, Reime, Phonetik (IPA + Audio), Etymologie und semantische Assoziationen.
+
+**Kein API-Key noetig** — kombiniert die [Free Dictionary API](https://dictionaryapi.dev/) und die [Datamuse API](https://www.datamuse.com/api/).
+
+## 15 Tools
+
+### Definitionen & Phonetik
+- `tool_get_definition(word)` — Vollstaendige Definition(en) mit allen Wortarten
+- `tool_get_phonetic(word)` — IPA-Transkription + Audio-URLs
+- `tool_get_examples(word)` — Beispielsaetze, gruppiert nach Wortart
+- `tool_get_word_origin(word)` — Etymologie und Ursprung wenn verfuegbar
+
+### Thesaurus & Semantik
+- `tool_get_synonyms(word, max_results=20)` — Aehnlich bedeutende Woerter
+- `tool_get_antonyms(word, max_results=20)` — Gegenteilige Woerter
+- `tool_get_word_associations(word, max_results=20)` — Semantisch verwandte Woerter (means-like)
+- `tool_get_triggers(word, max_results=20)` — Statistisch oft im Kontext erscheinende Woerter
+- `tool_get_hypernyms(word, max_results=20)` — Oberbegriffe (oak -> tree)
+- `tool_get_hyponyms(word, max_results=20)` — Unterbegriffe (tree -> oak, maple)
+
+### Reime & Phonetische Suche
+- `tool_get_rhymes(word, max_results=20, perfect_only=True)` — Perfekte oder near-rhymes
+- `tool_get_sounds_like(word, max_results=20)` — Phonetisch aehnliche Woerter
+- `tool_spell_check(pattern, max_results=20)` — Pattern-Matching mit `?`/`*` Wildcards
+
+### All-in-One
+- `tool_word_full_report(word)` — Definition + Phonetik + Synonyme + Antonyme + Reime in einem Call
+- `tool_get_server_info()` — Server-Metadaten
+
+## Installation
+
+```bash
+pip install dictionary-mcp-server
+```
+
+## Konfiguration (Claude Desktop)
+
+```json
+{
+  "mcpServers": {
+    "dictionary": {
+      "command": "dictionary-mcp-server"
+    }
+  }
+}
+```
+
+## Beispiele
+
+```python
+# Vollstaendige Definition + Beispiele
+await tool_get_definition("serendipity")
+
+# Synonyme fuer Brainstorming
+await tool_get_synonyms("happy", max_results=10)
+
+# Reime fuer Songtexte / Poesie
+await tool_get_rhymes("love", perfect_only=True)
+
+# Spell-Check via Pattern
+await tool_spell_check("hel?o")  # findet hello, helio
+
+# Alles auf einen Schlag
+await tool_word_full_report("computer")
+```
+
+## Datenquellen
+
+- **Free Dictionary API** (dictionaryapi.dev) — Definitionen, IPA, Beispiele, Audio. Kein API-Key, unbegrenzt.
+- **Datamuse API** (datamuse.com/api) — Thesaurus, Reime, Assoziationen. Kein API-Key, 100k Calls/Tag frei.
+
+## Lizenz
+
+MIT

dictionary_mcp_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/server.py,sha256=Cy9fgabC67qM6FDc5iX5rcT9NBFhbV8qc-zKS8-DPeY,1761
+src/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/clients/datamuse_client.py,sha256=opB594pcSwLfYD2MroT8S90dxPQM8z8RcUooMui_DwQ,1862
+src/clients/dictionary_client.py,sha256=3LjX-zckQMTXfbGYPGfzGuccP9l0Aq3eqsUySh5KQgU,729
+src/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/tools/definition_tools.py,sha256=4Q9nsh3UR_nmNL5AsCjlwyjX_qkR6P5OnFK5cJKjfGo,3284
+src/tools/info_tools.py,sha256=YrAlulpxrZZLzP4ZTuzo7Nh-rMBcNJ5Cn2IQVMj4OLI,2469
+src/tools/phonetic_tools.py,sha256=aB55hKBxNw1Hof-Q2jwIgbikWy6mK5E5Tt5S1kQoo6g,2418
+src/tools/thesaurus_tools.py,sha256=oPmApJAwjifux9SS5KwgoOwXTIAFgU_su89ZMoru0Bk,3730
+dictionary_mcp_server-0.1.0.dist-info/METADATA,sha256=zocxkZF7RB9bPbRfK0wFO9cfXBgJn0xPoFNLMcnI01U,3809
+dictionary_mcp_server-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+dictionary_mcp_server-0.1.0.dist-info/entry_points.txt,sha256=MkPq2dFeH6uuy9C-4ik2-QtCe9FIRL02Ntmpe1U1KCc,58
+dictionary_mcp_server-0.1.0.dist-info/RECORD,,

dictionary_mcp_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dictionary_mcp_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dictionary-mcp-server = src.server:main

src/clients/datamuse_client.py

@@ -0,0 +1,56 @@
+"""Client fuer Datamuse API (api.datamuse.com) -- kostenlos, kein API-Key."""
+import httpx
+
+BASE_URL = "https://api.datamuse.com/words"
+
+
+async def query(params: dict, max_results: int = 20) -> list:
+    """Generische Datamuse-Abfrage. Params siehe https://www.datamuse.com/api/"""
+    params = {**params, "max": max_results}
+    async with httpx.AsyncClient(timeout=15.0) as client:
+        response = await client.get(BASE_URL, params=params)
+        response.raise_for_status()
+        return response.json()
+
+
+async def synonyms(word: str, max_results: int = 20) -> list:
+    return await query({"rel_syn": word}, max_results)
+
+
+async def antonyms(word: str, max_results: int = 20) -> list:
+    return await query({"rel_ant": word}, max_results)
+
+
+async def rhymes(word: str, max_results: int = 20) -> list:
+    return await query({"rel_rhy": word}, max_results)
+
+
+async def near_rhymes(word: str, max_results: int = 20) -> list:
+    return await query({"rel_nry": word}, max_results)
+
+
+async def means_like(word: str, max_results: int = 20) -> list:
+    return await query({"ml": word}, max_results)
+
+
+async def sounds_like(word: str, max_results: int = 20) -> list:
+    return await query({"sl": word}, max_results)
+
+
+async def spelled_like(pattern: str, max_results: int = 20) -> list:
+    return await query({"sp": pattern}, max_results)
+
+
+async def triggers(word: str, max_results: int = 20) -> list:
+    """Woerter, die statistisch im Kontext von 'word' assoziiert sind."""
+    return await query({"rel_trg": word}, max_results)
+
+
+async def hypernyms(word: str, max_results: int = 20) -> list:
+    """Oberbegriffe (mehr generisch)."""
+    return await query({"rel_spc": word}, max_results)
+
+
+async def hyponyms(word: str, max_results: int = 20) -> list:
+    """Unterbegriffe (mehr spezifisch)."""
+    return await query({"rel_gen": word}, max_results)

src/clients/dictionary_client.py

@@ -0,0 +1,18 @@
+"""Client fuer Free Dictionary API (api.dictionaryapi.dev)."""
+import httpx
+
+BASE_URL = "https://api.dictionaryapi.dev/api/v2/entries"
+
+
+async def fetch_word(word: str, lang: str = "en") -> dict:
+    """Holt rohen Eintrag von der Free Dictionary API."""
+    url = f"{BASE_URL}/{lang}/{word}"
+    async with httpx.AsyncClient(timeout=15.0) as client:
+        response = await client.get(url)
+        if response.status_code == 404:
+            return {"error": "not_found", "word": word, "message": f"Wort '{word}' nicht gefunden."}
+        response.raise_for_status()
+        data = response.json()
+        if isinstance(data, list) and data:
+            return data[0]
+        return {"error": "invalid_response", "word": word}

src/server.py

@@ -0,0 +1,67 @@
+"""FastMCP-Server fuer Woerterbuch- und Thesaurus-Daten."""
+from mcp.server.fastmcp import FastMCP
+
+from src.tools.definition_tools import (
+    tool_get_definition,
+    tool_get_phonetic,
+    tool_get_examples,
+    tool_get_word_origin,
+)
+from src.tools.thesaurus_tools import (
+    tool_get_synonyms,
+    tool_get_antonyms,
+    tool_get_word_associations,
+    tool_get_triggers,
+    tool_get_hypernyms,
+    tool_get_hyponyms,
+)
+from src.tools.phonetic_tools import (
+    tool_get_rhymes,
+    tool_get_sounds_like,
+    tool_spell_check,
+)
+from src.tools.info_tools import (
+    tool_word_full_report,
+    tool_get_server_info,
+)
+
+
+mcp = FastMCP(
+    "dictionary-mcp-server",
+    instructions=(
+        "Gibt AI-Agents Zugriff auf Woerterbuch-, Thesaurus- und Linguistik-Daten. "
+        "Liefert Definitionen, Synonyme, Antonyme, Reime, Phonetik, Etymologie und semantische Assoziationen. "
+        "Quellen: Free Dictionary API + Datamuse API (beide kostenlos, kein API-Key noetig)."
+    ),
+)
+
+
+def _register_tools() -> None:
+    """Registriert alle Tool-Funktionen am MCP-Server."""
+    mcp.tool()(tool_get_definition)
+    mcp.tool()(tool_get_phonetic)
+    mcp.tool()(tool_get_examples)
+    mcp.tool()(tool_get_word_origin)
+    mcp.tool()(tool_get_synonyms)
+    mcp.tool()(tool_get_antonyms)
+    mcp.tool()(tool_get_word_associations)
+    mcp.tool()(tool_get_triggers)
+    mcp.tool()(tool_get_hypernyms)
+    mcp.tool()(tool_get_hyponyms)
+    mcp.tool()(tool_get_rhymes)
+    mcp.tool()(tool_get_sounds_like)
+    mcp.tool()(tool_spell_check)
+    mcp.tool()(tool_word_full_report)
+    mcp.tool()(tool_get_server_info)
+
+
+_register_tools()
+
+
+def main() -> None:
+    """Entry-Point fuer das Console-Script."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

src/tools/definition_tools.py

@@ -0,0 +1,118 @@
+"""Tools fuer Wort-Definitionen, Phonetik, Beispiele, Etymologie."""
+from src.clients import dictionary_client
+
+
+async def tool_get_definition(word: str) -> dict:
+    """Holt vollstaendige Definition(en) eines Wortes.
+
+    Args:
+        word: Englisches Wort, z.B. "happy" oder "computer".
+
+    Returns:
+        Dict mit allen Bedeutungen (parts of speech, definitions, beispiele).
+    """
+    data = await dictionary_client.fetch_word(word)
+    if data.get("error"):
+        return data
+
+    meanings = []
+    for m in data.get("meanings", []):
+        defs = []
+        for d in m.get("definitions", []):
+            defs.append({
+                "definition": d.get("definition"),
+                "example": d.get("example"),
+                "synonyms": d.get("synonyms", []),
+                "antonyms": d.get("antonyms", []),
+            })
+        meanings.append({
+            "part_of_speech": m.get("partOfSpeech"),
+            "definitions": defs,
+        })
+
+    return {
+        "word": data.get("word"),
+        "meanings": meanings,
+        "source": "Free Dictionary API (dictionaryapi.dev)",
+    }
+
+
+async def tool_get_phonetic(word: str) -> dict:
+    """Holt Phonetik (IPA) und Audio-Aussprache eines Wortes.
+
+    Args:
+        word: Englisches Wort.
+
+    Returns:
+        Dict mit IPA-Transkription und Audio-URLs.
+    """
+    data = await dictionary_client.fetch_word(word)
+    if data.get("error"):
+        return data
+
+    phonetics = []
+    for p in data.get("phonetics", []):
+        if p.get("text") or p.get("audio"):
+            phonetics.append({
+                "ipa": p.get("text"),
+                "audio_url": p.get("audio") or None,
+            })
+
+    return {
+        "word": data.get("word"),
+        "phonetics": phonetics,
+        "source": "Free Dictionary API",
+    }
+
+
+async def tool_get_examples(word: str) -> dict:
+    """Holt Beispielsaetze fuer ein Wort aus allen Definitionen.
+
+    Args:
+        word: Englisches Wort.
+
+    Returns:
+        Dict mit Liste von Beispielsaetzen, gruppiert nach Wortart.
+    """
+    data = await dictionary_client.fetch_word(word)
+    if data.get("error"):
+        return data
+
+    examples = []
+    for m in data.get("meanings", []):
+        for d in m.get("definitions", []):
+            if d.get("example"):
+                examples.append({
+                    "part_of_speech": m.get("partOfSpeech"),
+                    "example": d["example"],
+                    "context_definition": d.get("definition"),
+                })
+
+    return {
+        "word": data.get("word"),
+        "example_count": len(examples),
+        "examples": examples,
+        "source": "Free Dictionary API",
+    }
+
+
+async def tool_get_word_origin(word: str) -> dict:
+    """Holt etymologische / Ursprungs-Informationen wenn verfuegbar.
+
+    Args:
+        word: Englisches Wort.
+
+    Returns:
+        Dict mit origin/etymology-Info wenn vorhanden.
+    """
+    data = await dictionary_client.fetch_word(word)
+    if data.get("error"):
+        return data
+
+    return {
+        "word": data.get("word"),
+        "origin": data.get("origin", "Keine Etymologie-Information verfuegbar."),
+        "source_urls": data.get("sourceUrls", []),
+        "license": data.get("license", {}),
+        "source": "Free Dictionary API",
+    }

src/tools/info_tools.py

@@ -0,0 +1,64 @@
+"""Server-Informationen und Sammel-Tools."""
+from src.clients import dictionary_client, datamuse_client
+
+
+async def tool_word_full_report(word: str) -> dict:
+    """Liefert einen vollstaendigen Report fuer ein Wort: Definition, Phonetik, Synonyme, Antonyme, Reime.
+
+    Bequemes All-in-One Tool fuer Agenten, die alles auf einmal brauchen.
+
+    Args:
+        word: Englisches Wort, z.B. "happy".
+
+    Returns:
+        Dict mit allen verfuegbaren Informationen.
+    """
+    dict_data = await dictionary_client.fetch_word(word)
+    syn = await datamuse_client.synonyms(word, 10)
+    ant = await datamuse_client.antonyms(word, 10)
+    rhy = await datamuse_client.rhymes(word, 10)
+
+    if dict_data.get("error"):
+        meanings = []
+        phonetics = []
+    else:
+        meanings = [
+            {
+                "part_of_speech": m.get("partOfSpeech"),
+                "definitions": [d.get("definition") for d in m.get("definitions", [])][:3],
+            }
+            for m in dict_data.get("meanings", [])
+        ]
+        phonetics = [p.get("text") for p in dict_data.get("phonetics", []) if p.get("text")]
+
+    return {
+        "word": word,
+        "phonetics": phonetics,
+        "meanings": meanings,
+        "synonyms": [r["word"] for r in syn],
+        "antonyms": [r["word"] for r in ant],
+        "rhymes": [r["word"] for r in rhy],
+        "dictionary_found": not bool(dict_data.get("error")),
+        "sources": ["Free Dictionary API", "Datamuse API"],
+    }
+
+
+async def tool_get_server_info() -> dict:
+    """Liefert Informationen ueber den dictionary-mcp-server."""
+    return {
+        "name": "dictionary-mcp-server",
+        "version": "0.1.0",
+        "description": "MCP-Server fuer Woerterbuch, Thesaurus, Reime und Phonetik.",
+        "tools": [
+            "tool_get_definition", "tool_get_phonetic", "tool_get_examples", "tool_get_word_origin",
+            "tool_get_synonyms", "tool_get_antonyms", "tool_get_word_associations",
+            "tool_get_triggers", "tool_get_hypernyms", "tool_get_hyponyms",
+            "tool_get_rhymes", "tool_get_sounds_like", "tool_spell_check",
+            "tool_word_full_report",
+        ],
+        "data_sources": {
+            "free_dictionary_api": "https://dictionaryapi.dev (kostenlos, kein API-Key)",
+            "datamuse_api": "https://www.datamuse.com/api/ (kostenlos, kein API-Key)",
+        },
+        "languages": "Englisch (en) -- weitere Sprachen via Free Dictionary API moeglich",
+    }

src/tools/phonetic_tools.py

@@ -0,0 +1,78 @@
+"""Tools fuer Reime, Aussprache-Aehnlichkeit, Spell-Checking."""
+from src.clients import datamuse_client
+
+
+async def tool_get_rhymes(word: str, max_results: int = 20, perfect_only: bool = True) -> dict:
+    """Holt sich reimende Woerter.
+
+    Args:
+        word: Englisches Wort, z.B. "love".
+        max_results: Maximale Anzahl Ergebnisse.
+        perfect_only: Wenn True, nur perfekte Reime. Sonst auch near-rhymes.
+
+    Returns:
+        Dict mit Liste der Reime + Silbenanzahl.
+    """
+    if perfect_only:
+        results = await datamuse_client.rhymes(word, max_results)
+        rhyme_type = "perfect"
+    else:
+        results = await datamuse_client.near_rhymes(word, max_results)
+        rhyme_type = "near"
+
+    return {
+        "word": word,
+        "rhyme_type": rhyme_type,
+        "rhymes": [
+            {
+                "word": r["word"],
+                "score": r.get("score", 0),
+                "syllables": r.get("numSyllables"),
+            }
+            for r in results
+        ],
+        "count": len(results),
+        "source": "Datamuse API",
+    }
+
+
+async def tool_get_sounds_like(word: str, max_results: int = 20) -> dict:
+    """Holt Woerter, die phonetisch aehnlich klingen.
+
+    Args:
+        word: Englisches Wort oder Lautmalerei, z.B. "jirraf".
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit phonetisch aehnlichen Woertern (gut fuer Spell-Correction).
+    """
+    results = await datamuse_client.sounds_like(word, max_results)
+    return {
+        "input": word,
+        "sounds_like": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API (sl=)",
+    }
+
+
+async def tool_spell_check(pattern: str, max_results: int = 20) -> dict:
+    """Spell-Check via Pattern-Matching. Wildcards: ? = 1 Buchstabe, * = beliebig.
+
+    Beispiele:
+        - "hel?o" findet "hello", "helio".
+        - "comp*" findet "computer", "compete", etc.
+
+    Args:
+        pattern: Wort-Pattern mit ? und * Wildcards.
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit passenden Woertern.
+    """
+    results = await datamuse_client.spelled_like(pattern, max_results)
+    return {
+        "pattern": pattern,
+        "matches": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API (sp=)",
+    }

src/tools/thesaurus_tools.py

@@ -0,0 +1,124 @@
+"""Tools fuer Synonyme, Antonyme, semantisch verwandte Woerter."""
+from src.clients import datamuse_client
+
+
+async def tool_get_synonyms(word: str, max_results: int = 20) -> dict:
+    """Holt Synonyme fuer ein Wort (Woerter mit aehnlicher Bedeutung).
+
+    Args:
+        word: Englisches Wort, z.B. "happy".
+        max_results: Maximale Anzahl Ergebnisse (Standard 20).
+
+    Returns:
+        Dict mit sortierter Liste von Synonymen + Relevanz-Score.
+    """
+    results = await datamuse_client.synonyms(word, max_results)
+    return {
+        "word": word,
+        "synonyms": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API",
+    }
+
+
+async def tool_get_antonyms(word: str, max_results: int = 20) -> dict:
+    """Holt Antonyme fuer ein Wort (Woerter mit entgegengesetzter Bedeutung).
+
+    Args:
+        word: Englisches Wort, z.B. "happy".
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit sortierter Liste von Antonymen.
+    """
+    results = await datamuse_client.antonyms(word, max_results)
+    return {
+        "word": word,
+        "antonyms": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API",
+    }
+
+
+async def tool_get_word_associations(word: str, max_results: int = 20) -> dict:
+    """Holt semantisch verwandte Woerter ('means like' -- aehnliche Bedeutung).
+
+    Geeignet zum Brainstorming oder fuer Vokabular-Erweiterung.
+
+    Args:
+        word: Englisches Wort.
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit Liste verwandter Woerter.
+    """
+    results = await datamuse_client.means_like(word, max_results)
+    return {
+        "word": word,
+        "associations": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API (ml=)",
+    }
+
+
+async def tool_get_triggers(word: str, max_results: int = 20) -> dict:
+    """Holt Trigger-Woerter (statistisch oft im Kontext von 'word').
+
+    Beispiel: 'cow' -> milk, farm, moo, bovine, etc.
+
+    Args:
+        word: Englisches Wort.
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit Trigger-Woertern.
+    """
+    results = await datamuse_client.triggers(word, max_results)
+    return {
+        "word": word,
+        "triggers": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API (rel_trg=)",
+    }
+
+
+async def tool_get_hypernyms(word: str, max_results: int = 20) -> dict:
+    """Holt Oberbegriffe (allgemeinere Kategorien).
+
+    Beispiel: 'oak' -> tree, plant.
+
+    Args:
+        word: Englisches Wort.
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit Oberbegriffen.
+    """
+    results = await datamuse_client.hypernyms(word, max_results)
+    return {
+        "word": word,
+        "hypernyms": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API (rel_spc=)",
+    }
+
+
+async def tool_get_hyponyms(word: str, max_results: int = 20) -> dict:
+    """Holt Unterbegriffe (spezifischere Beispiele).
+
+    Beispiel: 'tree' -> oak, maple, pine.
+
+    Args:
+        word: Englisches Wort.
+        max_results: Maximale Anzahl Ergebnisse.
+
+    Returns:
+        Dict mit Unterbegriffen.
+    """
+    results = await datamuse_client.hyponyms(word, max_results)
+    return {
+        "word": word,
+        "hyponyms": [{"word": r["word"], "score": r.get("score", 0)} for r in results],
+        "count": len(results),
+        "source": "Datamuse API (rel_gen=)",
+    }