chefkoch-mcp 0.1.0__tar.gz

chefkoch_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 smlfg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chefkoch_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: chefkoch-mcp
+Version: 0.1.0
+Summary: MCP-Server für Chefkoch.de: Rezepte suchen, anzeigen und Einkaufslisten erstellen
+Author-email: smlfg <186922365+smlfg@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/smlfg/chefkoch-mcp
+Project-URL: Repository, https://github.com/smlfg/chefkoch-mcp
+Keywords: chefkoch,recipes,mcp,model-context-protocol
+Classifier: Environment :: Console
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.20
+Requires-Dist: chefkoch-cli>=0.1.1
+Dynamic: license-file
+
+# chefkoch-mcp
+
+MCP-Server für Chefkoch.de: Rezepte suchen, Rezeptdetails anzeigen und
+Einkaufslisten aus mehreren Rezepten erstellen. Ausschließlich lesend, ohne
+Login.
+
+Der Server ist eine dünne Hülle um den Kern der
+[`chefkoch-cli`](https://github.com/smlfg/chefkoch-cli): Er importiert
+`chefkoch_cli.service` und `chefkoch_cli.client` und ruft dieselben Funktionen
+wie `chefkoch suche`, `chefkoch rezept` und `chefkoch einkaufsliste` auf.
+
+## Was es kann
+
+- **Rezepte suchen** mit Filtern für vegetarisch/vegan, maximale Zeit,
+  Mindestbewertung, Schwierigkeit, Sortierung und Seite.
+- **Rezeptdetails** per ID, Chefkoch-URL oder Suchbegriff, Zutaten auf
+  Wunschportionen skaliert.
+- **Einkaufsliste** aus mehreren Rezepten, Zutaten nach Name und Einheit
+  zusammengefasst.
+
+## Schnellstart
+
+```bash
+uvx chefkoch-mcp
+```
+
+Der Befehl startet den MCP-Server über stdio. In der Praxis wird er aus dem
+MCP-Client heraus gestartet, nicht von Hand.
+
+## In Claude Desktop / Cursor nutzen
+
+```json
+{"mcpServers":{"chefkoch":{"command":"uvx","args":["chefkoch-mcp"]}}}
+```
+
+## Claude Code
+
+```bash
+claude mcp add chefkoch -- uvx chefkoch-mcp
+```
+
+## Tools
+
+| Tool | Beschreibung |
+|---|---|
+| `search_recipes` | Rezepte mit Filtern suchen |
+| `get_recipe` | Rezept per ID, URL oder Name anzeigen |
+| `shopping_list` | Einkaufsliste aus mehreren Rezepten erstellen |
+
+Alle Tools sind lesend (`readOnlyHint`) und liefern strukturierte Daten plus
+lesbaren Text. Fehler kommen als lesbare Meldung mit nächstem Schritt zurück.
+
+## Datenquelle
+
+Die Daten stammen von [chefkoch.de](https://www.chefkoch.de) über die
+inoffizielle API. Das Projekt ist nicht mit Chefkoch verbunden, greift nur
+lesend zu und benötigt keinen Login. Die API kann sich jederzeit ändern.
+
+## Konfiguration
+
+| Variable | Default | Bedeutung |
+|---|---|---|
+| `CHEFKOCH_BASE_URL` | `https://api.chefkoch.de` | API-Basis (Test/Fake-Server) |
+
+## Lizenz
+
+MIT, Copyright 2026 smlfg. Siehe `LICENSE`.
+
+<!-- mcp-name: io.github.smlfg/chefkoch-mcp -->

chefkoch_mcp-0.1.0/README.md

@@ -0,0 +1,69 @@
+# chefkoch-mcp
+
+MCP-Server für Chefkoch.de: Rezepte suchen, Rezeptdetails anzeigen und
+Einkaufslisten aus mehreren Rezepten erstellen. Ausschließlich lesend, ohne
+Login.
+
+Der Server ist eine dünne Hülle um den Kern der
+[`chefkoch-cli`](https://github.com/smlfg/chefkoch-cli): Er importiert
+`chefkoch_cli.service` und `chefkoch_cli.client` und ruft dieselben Funktionen
+wie `chefkoch suche`, `chefkoch rezept` und `chefkoch einkaufsliste` auf.
+
+## Was es kann
+
+- **Rezepte suchen** mit Filtern für vegetarisch/vegan, maximale Zeit,
+  Mindestbewertung, Schwierigkeit, Sortierung und Seite.
+- **Rezeptdetails** per ID, Chefkoch-URL oder Suchbegriff, Zutaten auf
+  Wunschportionen skaliert.
+- **Einkaufsliste** aus mehreren Rezepten, Zutaten nach Name und Einheit
+  zusammengefasst.
+
+## Schnellstart
+
+```bash
+uvx chefkoch-mcp
+```
+
+Der Befehl startet den MCP-Server über stdio. In der Praxis wird er aus dem
+MCP-Client heraus gestartet, nicht von Hand.
+
+## In Claude Desktop / Cursor nutzen
+
+```json
+{"mcpServers":{"chefkoch":{"command":"uvx","args":["chefkoch-mcp"]}}}
+```
+
+## Claude Code
+
+```bash
+claude mcp add chefkoch -- uvx chefkoch-mcp
+```
+
+## Tools
+
+| Tool | Beschreibung |
+|---|---|
+| `search_recipes` | Rezepte mit Filtern suchen |
+| `get_recipe` | Rezept per ID, URL oder Name anzeigen |
+| `shopping_list` | Einkaufsliste aus mehreren Rezepten erstellen |
+
+Alle Tools sind lesend (`readOnlyHint`) und liefern strukturierte Daten plus
+lesbaren Text. Fehler kommen als lesbare Meldung mit nächstem Schritt zurück.
+
+## Datenquelle
+
+Die Daten stammen von [chefkoch.de](https://www.chefkoch.de) über die
+inoffizielle API. Das Projekt ist nicht mit Chefkoch verbunden, greift nur
+lesend zu und benötigt keinen Login. Die API kann sich jederzeit ändern.
+
+## Konfiguration
+
+| Variable | Default | Bedeutung |
+|---|---|---|
+| `CHEFKOCH_BASE_URL` | `https://api.chefkoch.de` | API-Basis (Test/Fake-Server) |
+
+## Lizenz
+
+MIT, Copyright 2026 smlfg. Siehe `LICENSE`.
+
+<!-- mcp-name: io.github.smlfg/chefkoch-mcp -->

chefkoch_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chefkoch-mcp"
+version = "0.1.0"
+description = "MCP-Server für Chefkoch.de: Rezepte suchen, anzeigen und Einkaufslisten erstellen"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "smlfg", email = "186922365+smlfg@users.noreply.github.com" },
+]
+keywords = ["chefkoch", "recipes", "mcp", "model-context-protocol"]
+classifiers = [
+    "Environment :: Console",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "mcp>=1.20,<2",
+    "chefkoch-cli>=0.1.1",
+]
+
+[project.scripts]
+chefkoch-mcp = "chefkoch_mcp.server:main"
+
+[project.urls]
+Homepage = "https://github.com/smlfg/chefkoch-mcp"
+Repository = "https://github.com/smlfg/chefkoch-mcp"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+pythonpath = ["src"]

chefkoch_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chefkoch_mcp-0.1.0/src/chefkoch_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""MCP-Server für Chefkoch.de auf dem Kern der chefkoch-cli."""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

chefkoch_mcp-0.1.0/src/chefkoch_mcp/__main__.py

@@ -0,0 +1,8 @@
+"""Einstieg für ``python -m chefkoch_mcp``."""
+
+from __future__ import annotations
+
+from .server import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

chefkoch_mcp-0.1.0/src/chefkoch_mcp/server.py

@@ -0,0 +1,350 @@
+"""FastMCP-Server für Chefkoch.de – dünne Hülle um den Kern der chefkoch-cli."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import re
+import sys
+from typing import Annotated, Any, Callable, Literal, Sequence
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+from mcp.types import CallToolResult, TextContent, ToolAnnotations
+from pydantic import Field
+
+from chefkoch_cli import service
+from chefkoch_cli.client import ApiClient
+from chefkoch_cli.errors import CliError
+from chefkoch_cli.formatting import (
+    format_recipe_text,
+    format_search_line,
+    format_shopping_text,
+)
+
+from . import __version__
+
+logger = logging.getLogger("chefkoch_mcp")
+
+READ_ONLY = ToolAnnotations(
+    readOnlyHint=True,
+    destructiveHint=False,
+    idempotentHint=True,
+    openWorldHint=True,
+)
+
+mcp = FastMCP(
+    "chefkoch",
+    instructions=(
+        "Read-only Zugriff auf Chefkoch.de: Rezepte suchen, Rezeptdetails mit "
+        "skalierten Zutaten anzeigen und Einkaufslisten aus mehreren Rezepten "
+        "erstellen. Alle Tools sind lesend und benötigen keinen Login."
+    ),
+)
+
+
+def _result(text: str, data: dict[str, Any]) -> CallToolResult:
+    return CallToolResult(
+        content=[TextContent(type="text", text=text)],
+        structuredContent=data,
+    )
+
+
+def _error(message: str) -> CallToolResult:
+    return CallToolResult(
+        content=[TextContent(type="text", text=message)],
+        isError=True,
+    )
+
+
+_CLI_NEXT_STEP_REWRITES = (
+    (
+        re.compile(r"suche mit `chefkoch suche \.\.\.`"),
+        "nutze search_recipes",
+    ),
+    (
+        re.compile(r"oder `chefkoch suche \.\.\.`"),
+        "oder search_recipes",
+    ),
+    (
+        re.compile(r"Beispiel: chefkoch suche lasagne"),
+        "Nutze search_recipes mit einem Suchbegriff, z. B. 'lasagne'.",
+    ),
+    (
+        re.compile(r'Beispiel: chefkoch rezept "vegane lasagne"'),
+        "Nutze get_recipe mit Name, ID oder URL.",
+    ),
+    (
+        re.compile(
+            r"Nutze eine ID/URL oder die interaktive Auswahl im Terminal\."
+        ),
+        "Nutze eine eindeutige ID/URL mit get_recipe.",
+    ),
+    (
+        re.compile(r"`chefkoch suche [^`]*`"),
+        "search_recipes",
+    ),
+    (
+        re.compile(r"`chefkoch rezept [^`]*`"),
+        "get_recipe",
+    ),
+    (
+        re.compile(r"`chefkoch einkaufsliste [^`]*`"),
+        "shopping_list",
+    ),
+)
+
+
+def _next_step_for_mcp(next_step: str) -> str:
+    """Ersetzt CLI-Befehle im nächsten Schritt durch die passenden MCP-Tools."""
+    text = next_step
+    for pattern, replacement in _CLI_NEXT_STEP_REWRITES:
+        text = pattern.sub(replacement, text)
+    return text
+
+
+def _guard(action: Callable[[], CallToolResult]) -> CallToolResult:
+    try:
+        return action()
+    except CliError as exc:
+        message = exc.message
+        if exc.next_step:
+            next_step = _next_step_for_mcp(exc.next_step)
+            message = f"{message} Nächster Schritt: {next_step}"
+        return _error(message)
+    except (httpx.TimeoutException, TimeoutError):
+        return _error(
+            "Zeitüberschreitung beim Abruf von Chefkoch.de. "
+            "Nächster Schritt: Verbindung prüfen und erneut versuchen."
+        )
+    except httpx.HTTPError as exc:
+        return _error(
+            f"Netzwerkfehler beim Abruf von Chefkoch.de: {exc}. "
+            "Nächster Schritt: Verbindung prüfen und erneut versuchen."
+        )
+    except OSError as exc:
+        return _error(
+            f"Verbindungsfehler zu Chefkoch.de: {exc}. "
+            "Nächster Schritt: CHEFKOCH_BASE_URL und Netzwerk prüfen."
+        )
+    except Exception as exc:  # noqa: BLE001 - nie einen Traceback an den Client geben
+        logger.exception("Unerwarteter Fehler in einem MCP-Tool")
+        return _error(
+            f"Unerwarteter Fehler: {exc}. "
+            "Nächster Schritt: Eingaben prüfen oder es später erneut versuchen."
+        )
+
+
+@mcp.tool(
+    name="search_recipes",
+    description=(
+        "Sucht Rezepte auf Chefkoch.de mit Filtern und liefert eine sortierte "
+        "Trefferliste. Search Chefkoch recipes with filters; read-only."
+    ),
+    annotations=ToolAnnotations(
+        title="Rezepte suchen",
+        readOnlyHint=READ_ONLY.readOnlyHint,
+        destructiveHint=READ_ONLY.destructiveHint,
+        idempotentHint=READ_ONLY.idempotentHint,
+        openWorldHint=READ_ONLY.openWorldHint,
+    ),
+)
+def search_recipes(
+    query: Annotated[
+        str,
+        Field(description="Suchbegriff, z. B. 'lasagne' oder 'vegane suppe'."),
+    ],
+    limit: Annotated[
+        int,
+        Field(description="Treffer pro Seite (1 bis 100).", ge=1, le=100),
+    ] = 10,
+    vegetarisch: Annotated[
+        bool,
+        Field(description="Nur vegetarische Rezepte (Detailprüfung über Tags)."),
+    ] = False,
+    vegan: Annotated[
+        bool,
+        Field(description="Nur vegane Rezepte; schließt vegetarisch ein."),
+    ] = False,
+    max_zeit: Annotated[
+        int | None,
+        Field(
+            description="Maximale Zubereitungszeit in Minuten (>= 0).",
+            ge=0,
+        ),
+    ] = None,
+    min_bewertung: Annotated[
+        float | None,
+        Field(
+            description="Minimale Bewertung von 0 bis 5 Sternen.",
+            ge=0,
+            le=5,
+        ),
+    ] = None,
+    schwierigkeit: Annotated[
+        Literal["simpel", "normal", "pfiffig"] | None,
+        Field(description="Schwierigkeitsgrad: simpel, normal oder pfiffig."),
+    ] = None,
+    sort: Annotated[
+        Literal["bewertung", "zeit", "neu"],
+        Field(
+            description=(
+                "Sortierung: bewertung (Standard), zeit oder neu."
+            )
+        ),
+    ] = "bewertung",
+    seite: Annotated[
+        int,
+        Field(description="Seite der clientseitig sortierten Treffer (>= 1).", ge=1),
+    ] = 1,
+) -> CallToolResult:
+    """Sucht Rezepte über dieselbe Service-Funktion wie ``chefkoch suche``."""
+
+    def action() -> CallToolResult:
+        with ApiClient() as client:
+            data = service.search_recipes(
+                client,
+                query,
+                vegetarisch=vegetarisch,
+                vegan=vegan,
+                max_zeit=max_zeit,
+                min_bewertung=min_bewertung,
+                schwierigkeit=schwierigkeit,
+                sort=sort,
+                limit=limit,
+                seite=seite,
+            )
+        text = "\n".join(
+            format_search_line(index, item)
+            for index, item in enumerate(data.get("results") or [], start=1)
+        )
+        return _result(text, data)
+
+    return _guard(action)
+
+
+@mcp.tool(
+    name="get_recipe",
+    description=(
+        "Zeigt ein Chefkoch-Rezept per ID, URL oder Suchbegriff mit auf "
+        "Portionen skalierten Zutaten. Show a Chefkoch recipe; read-only."
+    ),
+    annotations=ToolAnnotations(
+        title="Rezept anzeigen",
+        readOnlyHint=READ_ONLY.readOnlyHint,
+        destructiveHint=READ_ONLY.destructiveHint,
+        idempotentHint=READ_ONLY.idempotentHint,
+        openWorldHint=READ_ONLY.openWorldHint,
+    ),
+)
+def get_recipe(
+    recipe: Annotated[
+        str | int,
+        Field(
+            description=(
+                "Rezept-ID (auch als Zahl), Chefkoch-URL oder Suchbegriff, z. B. "
+                "'2812481433250378', 2812481433250378, "
+                "'https://www.chefkoch.de/rezepte/...' oder 'vegane lasagne'."
+            )
+        ),
+    ],
+    portions: Annotated[
+        int | None,
+        Field(
+            description=(
+                "Zielportionen für die Zutaten (>= 1); ohne Angabe gelten die "
+                "Portionen des Rezepts."
+            ),
+            ge=1,
+        ),
+    ] = None,
+) -> CallToolResult:
+    """Lädt ein Rezept über dieselbe Service-Funktion wie ``chefkoch rezept``."""
+
+    def action() -> CallToolResult:
+        servings = service.validate_servings(portions)
+        with ApiClient() as client:
+            data = service.load_recipe(client, str(recipe), servings)
+        return _result(format_recipe_text(data), data)
+
+    return _guard(action)
+
+
+@mcp.tool(
+    name="shopping_list",
+    description=(
+        "Erstellt aus mehreren Chefkoch-Rezepten eine zusammengefasste "
+        "Einkaufsliste mit skalierten Mengen. Build a shopping list; read-only."
+    ),
+    annotations=ToolAnnotations(
+        title="Einkaufsliste erstellen",
+        readOnlyHint=READ_ONLY.readOnlyHint,
+        destructiveHint=READ_ONLY.destructiveHint,
+        idempotentHint=READ_ONLY.idempotentHint,
+        openWorldHint=READ_ONLY.openWorldHint,
+    ),
+)
+def shopping_list(
+    recipes: Annotated[
+        list[str | int],
+        Field(
+            description=(
+                "Rezept-IDs (auch als Zahl), Chefkoch-URLs oder Suchbegriffe; "
+                "mindestens ein Eintrag."
+            ),
+            min_length=1,
+        ),
+    ],
+    portions: Annotated[
+        int | None,
+        Field(
+            description=(
+                "Zielportionen für jedes Rezept (>= 1); ohne Angabe gelten die "
+                "Portionen der Rezepte."
+            ),
+            ge=1,
+        ),
+    ] = None,
+) -> CallToolResult:
+    """Baut die Einkaufsliste über dieselben Funktionen wie ``chefkoch einkaufsliste``."""
+
+    def action() -> CallToolResult:
+        servings = service.validate_servings(portions)
+        loaded: list[dict[str, Any]] = []
+        with ApiClient() as client:
+            for reference in recipes:
+                loaded.append(
+                    service.load_recipe(client, str(reference), servings)
+                )
+        data = service.build_shopping_list(loaded, servings)
+        return _result(format_shopping_text(data["items"], servings), data)
+
+    return _guard(action)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="chefkoch-mcp",
+        description=(
+            "MCP-Server für Chefkoch.de (stdio, ausschließlich lesend). "
+            "Startet ohne Argumente den Server."
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"chefkoch-mcp {__version__}",
+    )
+    parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.WARNING,
+        stream=sys.stderr,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    )
+    mcp.run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

chefkoch_mcp-0.1.0/src/chefkoch_mcp.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: chefkoch-mcp
+Version: 0.1.0
+Summary: MCP-Server für Chefkoch.de: Rezepte suchen, anzeigen und Einkaufslisten erstellen
+Author-email: smlfg <186922365+smlfg@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/smlfg/chefkoch-mcp
+Project-URL: Repository, https://github.com/smlfg/chefkoch-mcp
+Keywords: chefkoch,recipes,mcp,model-context-protocol
+Classifier: Environment :: Console
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.20
+Requires-Dist: chefkoch-cli>=0.1.1
+Dynamic: license-file
+
+# chefkoch-mcp
+
+MCP-Server für Chefkoch.de: Rezepte suchen, Rezeptdetails anzeigen und
+Einkaufslisten aus mehreren Rezepten erstellen. Ausschließlich lesend, ohne
+Login.
+
+Der Server ist eine dünne Hülle um den Kern der
+[`chefkoch-cli`](https://github.com/smlfg/chefkoch-cli): Er importiert
+`chefkoch_cli.service` und `chefkoch_cli.client` und ruft dieselben Funktionen
+wie `chefkoch suche`, `chefkoch rezept` und `chefkoch einkaufsliste` auf.
+
+## Was es kann
+
+- **Rezepte suchen** mit Filtern für vegetarisch/vegan, maximale Zeit,
+  Mindestbewertung, Schwierigkeit, Sortierung und Seite.
+- **Rezeptdetails** per ID, Chefkoch-URL oder Suchbegriff, Zutaten auf
+  Wunschportionen skaliert.
+- **Einkaufsliste** aus mehreren Rezepten, Zutaten nach Name und Einheit
+  zusammengefasst.
+
+## Schnellstart
+
+```bash
+uvx chefkoch-mcp
+```
+
+Der Befehl startet den MCP-Server über stdio. In der Praxis wird er aus dem
+MCP-Client heraus gestartet, nicht von Hand.
+
+## In Claude Desktop / Cursor nutzen
+
+```json
+{"mcpServers":{"chefkoch":{"command":"uvx","args":["chefkoch-mcp"]}}}
+```
+
+## Claude Code
+
+```bash
+claude mcp add chefkoch -- uvx chefkoch-mcp
+```
+
+## Tools
+
+| Tool | Beschreibung |
+|---|---|
+| `search_recipes` | Rezepte mit Filtern suchen |
+| `get_recipe` | Rezept per ID, URL oder Name anzeigen |
+| `shopping_list` | Einkaufsliste aus mehreren Rezepten erstellen |
+
+Alle Tools sind lesend (`readOnlyHint`) und liefern strukturierte Daten plus
+lesbaren Text. Fehler kommen als lesbare Meldung mit nächstem Schritt zurück.
+
+## Datenquelle
+
+Die Daten stammen von [chefkoch.de](https://www.chefkoch.de) über die
+inoffizielle API. Das Projekt ist nicht mit Chefkoch verbunden, greift nur
+lesend zu und benötigt keinen Login. Die API kann sich jederzeit ändern.
+
+## Konfiguration
+
+| Variable | Default | Bedeutung |
+|---|---|---|
+| `CHEFKOCH_BASE_URL` | `https://api.chefkoch.de` | API-Basis (Test/Fake-Server) |
+
+## Lizenz
+
+MIT, Copyright 2026 smlfg. Siehe `LICENSE`.
+
+<!-- mcp-name: io.github.smlfg/chefkoch-mcp -->

chefkoch_mcp-0.1.0/src/chefkoch_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/chefkoch_mcp/__init__.py
+src/chefkoch_mcp/__main__.py
+src/chefkoch_mcp/server.py
+src/chefkoch_mcp.egg-info/PKG-INFO
+src/chefkoch_mcp.egg-info/SOURCES.txt
+src/chefkoch_mcp.egg-info/dependency_links.txt
+src/chefkoch_mcp.egg-info/entry_points.txt
+src/chefkoch_mcp.egg-info/requires.txt
+src/chefkoch_mcp.egg-info/top_level.txt
+tests/test_server.py

chefkoch_mcp-0.1.0/src/chefkoch_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chefkoch_mcp-0.1.0/src/chefkoch_mcp.egg-info/entry_points.txt

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

chefkoch_mcp-0.1.0/src/chefkoch_mcp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp<2,>=1.20
+chefkoch-cli>=0.1.1

chefkoch_mcp-0.1.0/src/chefkoch_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+chefkoch_mcp

chefkoch_mcp-0.1.0/tests/test_server.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import socket
+import subprocess
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.types import CallToolResult
+
+FIXTURES = Path(__file__).resolve().parent / "fixtures" / "mcp"
+
+SEARCH_ROUTES = (
+    ("ultimative", "search_ultimative_vegane_lasagne.json"),
+    ("spinat", "search_vegetarische_spinat_lasagne.json"),
+    ("vegane", "search_vegane_lasagne.json"),
+    ("lasagne", "search_lasagne.json"),
+)
+
+
+class _FakeChefkochHandler(BaseHTTPRequestHandler):
+    def do_GET(self) -> None:  # noqa: N802 - von BaseHTTPRequestHandler vorgegeben
+        parts = urlsplit(self.path)
+        if parts.path == "/v2/recipes":
+            query = " ".join(parse_qs(parts.query).get("query", []))
+            for needle, filename in SEARCH_ROUTES:
+                if needle in query:
+                    self._send_json(filename)
+                    return
+            self._send_status(404)
+            return
+        if parts.path.startswith("/v2/recipes/"):
+            recipe_id = parts.path.rsplit("/", 1)[-1]
+            filename = f"recipe_{recipe_id}.json"
+            if (FIXTURES / filename).is_file():
+                self._send_json(filename)
+                return
+        self._send_status(404)
+
+    def _send_json(self, filename: str) -> None:
+        body = (FIXTURES / filename).read_bytes()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _send_status(self, status: int) -> None:
+        body = json.dumps({"error": status}).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format: str, *args: Any) -> None:  # noqa: A002
+        pass
+
+
+@pytest.fixture(scope="module")
+def fake_api() -> str:
+    server = ThreadingHTTPServer(("127.0.0.1", 0), _FakeChefkochHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_address[1]}"
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+
+
+def _server_params(base_url: str) -> StdioServerParameters:
+    env = dict(os.environ)
+    env["CHEFKOCH_BASE_URL"] = base_url
+    env["CHEFKOCH_MIN_INTERVAL"] = "0"
+    return StdioServerParameters(
+        command=sys.executable,
+        args=["-m", "chefkoch_mcp"],
+        env=env,
+    )
+
+
+def _text(result: CallToolResult) -> str:
+    return "\n".join(
+        block.text for block in result.content if getattr(block, "type", None) == "text"
+    )
+
+
+def _list_tools(base_url: str):
+    async def run():
+        async with stdio_client(_server_params(base_url)) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                return await session.list_tools()
+
+    return asyncio.run(run())
+
+
+def _call(base_url: str, name: str, arguments: dict[str, Any]) -> CallToolResult:
+    async def run():
+        async with stdio_client(_server_params(base_url)) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                return await session.call_tool(name, arguments)
+
+    return asyncio.run(run())
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def test_tools_list_has_three_read_only_tools(fake_api: str) -> None:
+    result = _list_tools(fake_api)
+    tools = {tool.name: tool for tool in result.tools}
+
+    assert set(tools) == {"search_recipes", "get_recipe", "shopping_list"}
+    for tool in tools.values():
+        assert tool.description
+        assert len(tool.description) >= 40
+        assert tool.annotations is not None
+        assert tool.annotations.title
+        assert tool.annotations.readOnlyHint is True
+        assert tool.annotations.destructiveHint is False
+        assert tool.annotations.idempotentHint is True
+        assert tool.annotations.openWorldHint is True
+        properties = tool.inputSchema.get("properties") or {}
+        assert properties
+        for name, prop in properties.items():
+            assert prop.get("description"), f"{tool.name}.{name} ohne Beschreibung"
+
+
+def test_search_recipes_returns_structured_and_readable_result(fake_api: str) -> None:
+    result = _call(fake_api, "search_recipes", {"query": "lasagne", "limit": 5})
+
+    assert result.isError is False
+    text = _text(result)
+    assert "Lasagne" in text
+    assert "745721177147257" in text
+    assert result.structuredContent is not None
+    assert result.structuredContent["query"] == "lasagne"
+    assert result.structuredContent["results"][0]["id"] == "745721177147257"
+
+
+def test_get_recipe_scales_ingredients(fake_api: str) -> None:
+    result = _call(
+        fake_api,
+        "get_recipe",
+        {"recipe": "2812481433250378", "portions": 4},
+    )
+
+    assert result.isError is False
+    text = _text(result)
+    assert "Die ultimative vegane Lasagne" in text
+    assert "Portionen: 4 (Basis: 8)" in text
+    assert result.structuredContent is not None
+    assert result.structuredContent["requestedServings"] == 4
+
+
+def test_get_recipe_accepts_numeric_id(fake_api: str) -> None:
+    result = _call(
+        fake_api,
+        "get_recipe",
+        {"recipe": 2812481433250378, "portions": 4},
+    )
+
+    assert result.isError is False
+    text = _text(result)
+    assert "Die ultimative vegane Lasagne" in text
+    assert result.structuredContent is not None
+    assert result.structuredContent["id"] == "2812481433250378"
+
+
+def test_shopping_list_accepts_numeric_ids(fake_api: str) -> None:
+    result = _call(
+        fake_api,
+        "shopping_list",
+        {
+            "recipes": [2812481433250378, 2114131340630587],
+            "portions": 4,
+        },
+    )
+
+    assert result.isError is False
+    text = _text(result)
+    assert "Knoblauchzehe(n)" in text
+    assert result.structuredContent is not None
+    assert [
+        recipe["id"] for recipe in result.structuredContent["recipes"]
+    ] == ["2812481433250378", "2114131340630587"]
+
+
+def test_shopping_list_aggregates_ingredients(fake_api: str) -> None:
+    result = _call(
+        fake_api,
+        "shopping_list",
+        {
+            "recipes": ["2812481433250378", "2114131340630587"],
+            "portions": 4,
+        },
+    )
+
+    assert result.isError is False
+    text = _text(result)
+    assert "Einkaufsliste (4 Portionen je Rezept)" in text
+    assert "Knoblauchzehe(n)" in text
+    assert "Käse, geriebener" in text
+    assert result.structuredContent is not None
+    items = {
+        (item["name"], item["unit"]): item
+        for item in result.structuredContent["items"]
+    }
+    assert items[("Knoblauchzehe(n)", "")]["amount"] == pytest.approx(4.67)
+
+
+def test_error_next_steps_name_mcp_tools_instead_of_cli_commands(
+    fake_api: str,
+) -> None:
+    missing = _call(fake_api, "get_recipe", {"recipe": "0000000000"})
+    missing_text = _text(missing)
+    assert missing.isError is True
+    assert "Traceback" not in missing_text
+    assert "Nächster Schritt: Prüfe die ID/URL oder nutze search_recipes." in (
+        missing_text
+    )
+    assert "chefkoch suche" not in missing_text.lower()
+
+    empty_query = _call(fake_api, "search_recipes", {"query": "   "})
+    empty_text = _text(empty_query)
+    assert empty_query.isError is True
+    assert "Traceback" not in empty_text
+    assert "search_recipes" in empty_text
+    assert "chefkoch suche" not in empty_text.lower()
+
+
+def test_unreachable_server_is_error_without_traceback() -> None:
+    base_url = f"http://127.0.0.1:{_free_port()}"
+    result = _call(base_url, "search_recipes", {"query": "lasagne"})
+
+    assert result.isError is True
+    text = _text(result)
+    assert "Traceback" not in text
+    assert "Netzwerkfehler" in text
+    assert "Prüfe die Verbindung" in text
+
+
+def test_version_and_help_exit_without_starting_server() -> None:
+    for flag in ("--version", "--help"):
+        completed = subprocess.run(
+            [sys.executable, "-m", "chefkoch_mcp", flag],
+            capture_output=True,
+            text=True,
+            timeout=20,
+            env=dict(os.environ),
+        )
+        assert completed.returncode == 0, completed.stderr
+        assert completed.stdout