---
name: schema-markup-setup
description: >-
  Richtet Schema-Markup (strukturierte Daten) auf einer Webseite ein, um die Darstellung in den Suchergebnissen zu verbessern. Dieser Skill wird aktiviert, wenn Schema-Markup implementiert werden soll. Typische Trigger-Phrasen sind 'Schema-Markup einrichten', 'Strukturierte Daten für [Webseite] erstellen' oder 'Rich Snippets generieren'.
metadata:
  abteilung: Marketing
  disziplin: SEO
  phase: Setup
  projekt: WVM
  input: Website-URL, zu markierende Inhalte (z.B. Produkte, Bewertungen, Veranstaltungen)
  output: Implementiertes Schema-Markup, Test der strukturierten Daten, Dokumentation
---

# Skill: Schema Markup Setup

Dieser Skill implementiert Schema-Markup zur Verbesserung der Suchmaschinen-Darstellung und der Klickrate in den organischen Suchergebnissen durch Rich Snippets. Er liefert Suchmaschinen detaillierte Informationen über die Inhalte einer Webseite und verbessert die Sichtbarkeit für spezifische Inhaltstypen wie Produkte, Bewertungen oder Veranstaltungen.

## Wann nutzen?
- Wenn die Klickrate in den organischen Suchergebnissen durch Rich Snippets erhöht werden soll.
- Um Suchmaschinen detaillierte Informationen über die Inhalte einer Webseite zu liefern.
- Zur Verbesserung der Sichtbarkeit für bestimmte Inhaltstypen wie Produkte, Bewertungen oder Veranstaltungen.
- Bei der On-Page-SEO-Optimierung einer Webseite.

## Workflow

### Schritt 1: Analyse der Webseite und Identifikation relevanter Schema-Typen
Der Skill analysiert die bereitgestellte Website-URL und identifiziert basierend auf den Inhalten und dem Geschäftszweck die passenden Schema-Typen (z.B. `Product`, `Organization`, `LocalBusiness`, `Article`, `Event`, `Review`).

**Aktionen:**
1.  **Eingabevalidierung:** Überprüfung der `Website-URL` auf Gültigkeit.
    *   **Tool:** `shell` (für grundlegende URL-Validierung oder `python` Skript)
    *   **Beispiel:** `shell(brief='URL validieren', action='exec', session='s1', command='python3.11 -c "import re; url = \"[Website-URL]\"; if not re.match(r\"^https?://\\S+\", url): raise ValueError(\"Ungültige URL\")"')`
2.  **Webseiten-Crawling und Inhaltsanalyse:** Besuch der Webseite, um den Inhalt zu erfassen und potenzielle Schema-Typen zu identifizieren.
    *   **Tool:** `browser` (für initialen Besuch und Content-Extraktion)
    *   **Beispiel:** `browser(brief='Webseite crawlen', url='[Website-URL]', intent='informational', focus='Hauptinhalte und Struktur der Webseite')`
    *   **Tool:** `file` (zum Speichern des extrahierten HTML-Inhalts)
    *   **Beispiel:** `file(brief='HTML-Inhalt speichern', action='write', path='/home/ubuntu/website_content.html', text='[Extrahiertes HTML]')`
3.  **Schema-Typ-Vorschlag:** Basierend auf der Analyse werden die relevantesten Schema-Typen vorgeschlagen.
    *   **Tool:** `search` (für Best Practices und Beispiele zu Schema-Typen)
    *   **Beispiel:** `search(brief='Schema.org Typen recherchieren', type='info', queries=['schema.org product markup', 'schema.org local business', 'schema.org article json-ld examples'])`

### Schritt 2: Erstellung des Schema-Markups im JSON-LD-Format
Generierung des spezifischen JSON-LD-Codes für die identifizierten Schema-Typen unter Berücksichtigung der bereitgestellten Inhalte.

**Aktionen:**
1.  **Datenextraktion:** Identifizierung und Extraktion der notwendigen Datenpunkte von der Webseite (z.B. Produktname, Preis, Adresse, Autor, Datum).
    *   **Tool:** `file` (zum Lesen des gespeicherten HTML-Inhalts)
    *   **Beispiel:** `file(brief='Webseiten-Inhalt lesen', action='read', path='/home/ubuntu/website_content.html')`
    *   **Tool:** `python` (Skript zur Datenextraktion mittels BeautifulSoup oder ähnlichem)
    *   **Beispiel:** `shell(brief='Daten extrahieren', action='exec', session='s2', command='python3.11 /home/ubuntu/extract_data.py "/home/ubuntu/website_content.html" > /home/ubuntu/extracted_data.json')`
2.  **JSON-LD-Generierung:** Erstellung des JSON-LD-Codes basierend auf den extrahierten Daten und den ausgewählten Schema-Typen.
    *   **Tool:** `python` (Skript zur Generierung des JSON-LD)
    *   **Beispiel:** `shell(brief='JSON-LD generieren', action='exec', session='s3', command='python3.11 /home/ubuntu/generate_jsonld.py "/home/ubuntu/extracted_data.json" "[Schema-Typ]" > /home/ubuntu/schema_markup.json')`
    *   **Referenzdatei:** `json_ld_templates.py` (siehe unten)

### Schritt 3: Implementierung des Markups und Test mit Google Rich Results Test-Tool
Das generierte Schema-Markup wird auf der Webseite implementiert und anschließend mit dem offiziellen Google-Tool auf Gültigkeit und Rich-Snippet-Fähigkeit getestet.

**Aktionen:**
1.  **Markup-Implementierung (Anleitung/Vorschlag):** Bereitstellung von Anweisungen zur Implementierung des JSON-LD-Codes (z.B. im `<head>`-Bereich oder über einen Tag Manager).
    *   **Tool:** `file` (zum Schreiben der Implementierungsanleitung)
    *   **Beispiel:** `file(brief='Implementierungsanleitung erstellen', action='write', path='/home/ubuntu/implementation_guide.md', text='[Anleitungstext]')`
2.  **Test mit Google Rich Results Test:** Besuch des Tools und Durchführung des Tests mit der Webseite oder dem Code-Snippet.
    *   **Tool:** `browser` (zum Navigieren zum Google Rich Results Test-Tool)
    *   **Beispiel:** `browser(brief='Google Rich Results Test aufrufen', url='https://search.google.com/test/rich-results', intent='transactional', focus='Test des generierten Schema-Markups')`
    *   **Tool:** `browser` (zum Eingeben des Codes oder der URL und Ausführen des Tests)
    *   **Beispiel:** `browser(brief='Schema-Markup testen', url='https://search.google.com/test/rich-results', intent='transactional', focus='Ergebnisse des Rich Results Tests erfassen')`
3.  **Erfassung der Testergebnisse:** Speichern der Ergebnisse des Rich Results Tests.
    *   **Tool:** `file` (zum Speichern der Testergebnisse)
    *   **Beispiel:** `file(brief='Testergebnisse speichern', action='write', path='/home/ubuntu/rich_results_test_report.md', text='[Testergebnisse]')`

### Schritt 4: Bereitstellung der Dokumentation und Bestätigung
Zusammenstellung aller Ergebnisse in einer umfassenden Dokumentation und Bestätigung des erfolgreichen Setups.

**Aktionen:**
1.  **Dokumentationserstellung:** Erstellung eines Markdown-Berichts, der die identifizierten Schema-Typen, den generierten JSON-LD-Code, die Implementierungsanleitung und die Testergebnisse enthält.
    *   **Tool:** `file` (zum Zusammenführen der Informationen in einer `SKILL_REPORT.md`)
    *   **Beispiel:** `file(brief='Abschlussbericht erstellen', action='write', path='/home/ubuntu/SKILL_REPORT.md', text='[Zusammengeführter Berichtsinhalt]')`
2.  **Optional: Monday.com Update:** Aktualisierung eines Monday.com-Items mit dem Status des Schema-Markup-Setups und Verlinkung zum Bericht.
    *   **Tool:** `manus-mcp-cli` (monday-com)
    *   **Beispiel:** `manus-mcp-cli tool call monday-com_update_item_column_values --server monday-com --input '{"boardId": [Board-ID], "itemId": [Item-ID], "columnValues": {"status": "Done", "schema_markup_report": "[Link zum SKILL_REPORT.md]"}}'`

## Tools & Integrationen
- `browser`: Für Webseiten-Crawling und Interaktion mit dem Google Rich Results Test-Tool.
- `shell`: Für grundlegende Systembefehle, Skriptausführung und URL-Validierung.
- `file`: Zum Speichern und Lesen von Webseiten-Inhalten, generiertem JSON-LD und Berichten.
- `search`: Zur Recherche von Schema.org-Typen und Best Practices.
- `manus-mcp-cli` mit `monday-com` Server: Optional zur Aktualisierung von Projektstatus in Monday.com.

## Referenzdateien

### `/home/ubuntu/extract_data.py`
Ein Python-Skript, das HTML-Inhalte parst und relevante Datenpunkte für die Schema-Markup-Generierung extrahiert. Verwendet Bibliotheken wie `BeautifulSoup4`.

```python
# Beispielinhalt von extract_data.py
import sys
from bs4 import BeautifulSoup
import json

def extract_data(html_file_path):
    with open(html_file_path, 'r', encoding='utf-8') as f:
        html_content = f.read()
    soup = BeautifulSoup(html_content, 'html.parser')
    data = {}
    # Beispiel: Titel extrahieren
    title_tag = soup.find('title')
    if title_tag:  
        data['title'] = title_tag.get_text()
    # Weitere Extraktionslogik hier hinzufügen (z.B. Produktpreise, Beschreibungen, etc.)
    return data

if __name__ == '__main__':
    if len(sys.argv) > 1:
        html_path = sys.argv[1]
        extracted = extract_data(html_path)
        print(json.dumps(extracted, indent=2))
    else:
        print("Usage: python3.11 extract_data.py <html_file_path>")
```

### `/home/ubuntu/generate_jsonld.py`
Ein Python-Skript, das basierend auf extrahierten Daten und einem Schema-Typ den entsprechenden JSON-LD-Code generiert.

```python
# Beispielinhalt von generate_jsonld.py
import sys
import json

def generate_jsonld(data_json_path, schema_type):
    with open(data_json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    json_ld = {
        "@context": "https://schema.org",
        "@type": schema_type,
    }

    # Beispiel: Daten basierend auf Schema-Typ zuweisen
    if schema_type == "Product":
        json_ld["name"] = data.get("product_name", data.get("title"))
        json_ld["description"] = data.get("product_description")
        json_ld["offers"] = {
            "@type": "Offer",
            "priceCurrency": data.get("currency", "EUR"),
            "price": data.get("price")
        }
    elif schema_type == "Article":
        json_ld["headline"] = data.get("title")
        json_ld["articleBody"] = data.get("article_content")
        json_ld["author"] = {"@type": "Person", "name": data.get("author")}
    # Weitere Schema-Typen und deren Logik hier hinzufügen

    return json_ld

if __name__ == '__main__':
    if len(sys.argv) > 2:
        data_path = sys.argv[1]
        s_type = sys.argv[2]
        generated = generate_jsonld(data_path, s_type)
        print(json.dumps(generated, indent=2))
    else:
        print("Usage: python3.11 generate_jsonld.py <data_json_path> <schema_type>")
```

## Deliverables
- **`SKILL_REPORT.md`**: Ein umfassender Markdown-Bericht, der die Analyse, das generierte Schema-Markup, die Implementierungsanleitung und die Testergebnisse zusammenfasst.
- **`schema_markup.json`**: Die generierte JSON-LD-Datei mit dem strukturierten Daten-Markup.
- **`rich_results_test_report.md`**: Die detaillierten Ergebnisse des Google Rich Results Tests.
- Optional: Ein aktualisiertes Item in Monday.com mit dem Status und einem Link zum Bericht.

## Fehlerbehandlung
- **Ungültige URL:** Wenn die bereitgestellte `Website-URL` ungültig ist, wird der Skill dies erkennen und eine Fehlermeldung ausgeben, die den Benutzer zur Korrektur auffordert.
- **Fehlende Datenpunkte:** Sollten bei der Datenextraktion notwendige Informationen auf der Webseite fehlen, wird der Skill dies protokollieren und versuchen, mit den verfügbaren Daten fortzufahren oder den Benutzer um manuelle Eingabe bitten.
- **Fehlgeschlagener Rich Results Test:** Wenn der Google Rich Results Test Fehler aufzeigt, wird der Skill die Fehler im Bericht festhalten und gegebenenfalls Vorschläge zur Korrektur unterbreiten.
- **Zugriffsprobleme:** Bei Problemen beim Zugriff auf die Webseite (z.B. 404, Timeout) wird der Skill dies melden und den Benutzer informieren.
- **MCP-Fehler:** Bei Fehlern bei der Interaktion mit Monday.com (z.B. falsche Board-ID) wird der Skill dies protokollieren und den Benutzer auf das Problem hinweisen, ohne den Hauptworkflow zu unterbrechen.