import asyncio

async def query_fanout_search(main_query):
    """
    Gleichzeitige Suche für alle Unterabfragen
    """
    
    # Hauptanfrage zerlegen
    sub_queries = decompose_query(main_query)
    # Ergebnis: ["kamera vlogging anfänger", "kamera für YT meinungen", ...]
    
    # Aufgaben für jede Unterabfrage erstellen
    tasks = []
    for sub_query in sub_queries:
        tasks.append(search_google(sub_query))
        tasks.append(search_youtube_reviews(sub_query))
        tasks.append(search_forums(sub_query))
        tasks.append(search_prices(sub_query))
    
    # Alle gleichzeitig ausführen (asyncio)
    all_results = await asyncio.gather(*tasks)

Der Nutzer sucht: "Laptop zum Programmieren lernen"
→ Deine Seite erscheint auf Position 3
→ Der Nutzer klickt auf den Link
→ Er landet bei dir

Der Nutzer sucht: "Laptop zum Programmieren lernen"
→ Der AI-Modus generiert eine Antwort mit dem Satz:
  "Beliebte Optionen sind: [Zitat von Seite A], [Zitat von Seite B], 
   [Zitat von deiner Seite]"
→ Der Nutzer klickt manchmal auf Links, manchmal nicht – aber deine Marke 
  erscheint in der Antwort

Titel: Laptop zum Programmieren

Der beste Laptop zum Programmieren ist einer, der...
[zwei Seiten dichter Text]

# Laptop zum Programmieren – Der komplette Leitfaden 2025

## Was musst du vor dem Kauf eines Programmier-Laptops wissen?

### 1. Prozessor – Intel oder AMD?
AMD Ryzen 7 ist schneller beim Kompilieren von Code...
[konkrete Tests]

### 2. RAM – wie viel brauchst du?
- Für Python: 8-16 GB
- Für Webentwicklung: 16 GB Minimum
- Für KI/ML: 32 GB

### 3. SSD-Speicher – wie viel?
Minimum: 512 GB
Empfehlung: 1 TB

[Jeder Punkt hat eine klare, eigenständige Antwort]

## Vergleich beliebter Modelle

| Modell | Prozessor | RAM | SSD | Preis | Bewertung |
| --- | --- | --- | --- | --- | --- |
| Modell A | Ryzen 7 | 16GB | 512GB | 929 € | 9.2 |
| Modell B | i7-13 | 16GB | 1TB | 1049 € | 9.5 |

[Jede Zeile ist ein Fragment, das die KI extrahieren kann]

## FAQ – Häufig gestellte Fragen

F: Ist ein MacBook gut zum Programmieren?
A: Ja, aber...

F: Wie viel kostet ein guter Laptop zum Coden?
A: Ab 700 €...

[Jedes F&A-Paar ist eine potenzielle Unteranfrage]

## Nutzerbewertungen

"Ich habe diesen Laptop gekauft, programmiere in Python und verdiene jetzt..." (15 positive Bewertungen)

Der Laptop kostet 929 Euro

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Programmier-Laptop Modell X",
  "price": "929.00",
  "priceCurrency": "EUR",
  "availability": "https://schema.org/InStock",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "ratingCount": "125"
  }
}
</script>

## Wie oft lädt eine 20.000 mAh Powerbank mein Handy auf?

Das hängt von der Akkukapazität Ihres Handys ab:

- iPhone 14 (3200 mAh): ~6-mal
- Samsung Galaxy S24 (4000 mAh): ~5-mal
- OnePlus 12 (5400 mAh): ~3,5-mal
- iPad Air (8600 mAh): ~2-mal

**Wie wird das berechnet?**
20.000 mAh (Powerbank) / 4.000 mAh (Handy) = 5 Ladungen
(in der Praxis weniger aufgrund von Energieverlusten)

## Lädt eine 20.000 mAh Powerbank einen Laptop?

Ja, aber...
- Sie muss einen USB-C Power Delivery Ausgang haben
- Sie muss mindestens 65W leisten
- Ältere Laptops (mit Micro-USB) – nein

Unser Modell: 100W, USB-C PD, lädt das MacBook Air in 2,5 Stunden.

## Powerbank für den Urlaub – passt sie ins Gepäck?

- Maße: 12 x 7 x 3 cm
- Gewicht: 420 g
- Passt in den Rucksack, den Kulturbeutel oder die Tasche einer großen Handtasche
- Ideal für den Urlaub (nimmt keinen Platz weg)

[usw.]
<mycode8>
## Wie oft lädt eine 20.000 mAh Powerbank mein Handy auf?

Das hängt von der Akkukapazität Ihres Handys ab:

- iPhone 14 (3200 mAh): ~6-mal
- Samsung Galaxy S24 (4000 mAh): ~5-mal
- OnePlus 12 (5400 mAh): ~3,5-mal
- iPad Air (8600 mAh): ~2-mal

**Wie wird das berechnet?**
20.000 mAh (Powerbank) / 4.000 mAh (Handy) = 5 Ladungen
(in der Praxis weniger aufgrund von Energieverlusten)

## Lädt eine 20.000 mAh Powerbank einen Laptop?

Ja, aber...
- Sie muss einen USB-C Power Delivery Ausgang haben
- Sie muss mindestens 65W leisten
- Ältere Laptops (mit Micro-USB) – nein

Unser Modell: 100W, USB-C PD, lädt das MacBook Air in 2,5 Stunden.

## Powerbank für den Urlaub – passt sie ins Gepäck?

- Maße: 12 x 7 x 3 cm
- Gewicht: 420 g
- Passt in den Rucksack, den Kulturbeutel oder die Tasche einer großen Handtasche
- Ideal für den Urlaub (nimmt keinen Platz weg)

[usw.]
</mycode8>

<strong class="font-semibold">Anleitung 2: Inhalte für Query Fanout schreiben - Vorlage</strong>
<strong class="font-semibold">Überschriftenvorlage (für jeden Aspekt)</strong>
<mycode9>
# [Produkt] – Der komplette Leitfaden [Jahr]

## Was du vor dem Kauf von [Produkt] wissen solltest

### 1. [Erster kritischer Aspekt]
- Definition für Anfänger
- Warum das wichtig ist
- Wie man das in der Praxis prüft

### 2. [Zweiter Aspekt]
[dasselbe]

### 3. [Dritter Aspekt]
[dasselbe]

## Vergleich beliebter Modelle

| Name | Spez1 | Spez2 | Preis | Bewertung |
| --- | --- | --- | --- | --- |
| Modell A | | | | |

## FAQ – Häufig gestellte Fragen

F: [Frage, die in Google Trends erschienen ist]
A: [Konkrete Antwort]

## Nutzererfahrungen

"Nutzergeschichte: warum er gekauft hat, wie seine Erfahrungen sind"
</mycode9>

<strong class="font-semibold">Handbuch 3: Umsetzung </strong><strong class="font-semibold">für das Produkt</strong>
<mycode10>
<!DOCTYPE html>
<html>
<head>
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Powerbank 20000 mAh SuperCharge",
  "image": ["https://...1.jpg"],
  "description": "Powerbank unter 35 Euro mit Schnellladefunktion",
  "brand": {
    "@type": "Brand",
    "name": "TechBrand"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://...produkt",
    "priceCurrency": "EUR",
    "price": "29.99",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "ratingCount": "348",
    "bestRating": "5",
    "worstRating": "1"
  },
  "review": [
    {
      "@type": "Review",
      "author": {
        "@type": "Person",
        "name": "Jan"
      },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5"
      },
      "reviewBody": "Super Powerbank, sehr zu empfehlen"
    }
  ]
}
</script>
</head>
</html>
</mycode10>

<strong class="font-semibold">Daher weiß die KI genau Bescheid:</strong>
<strong class="font-semibold">Szenario 1: Der Kunde sucht nach einem "Vergleich"</strong>
<frame tag="Benutzeraufforderung:">"Schotterrad oder Rennrad - was soll ich wählen?"</frame>
Die Unterabfragen, die AI generiert:
<strong class="font-semibold">Was Ihre Website enthalten sollte, damit sie erscheint:</strong>
<strong class="font-semibold">Szenario 2: Der Kunde hat ein spezifisches Problem</strong>
<frame tag="Benutzeraufforderung:"></frame>
<strong class="font-semibold">Unterfragen:</strong>
<strong class="font-semibold">Was Ihr Inhalt enthalten sollte:</strong>
<strong class="font-semibold">Szenario 3: Kunde vergleicht Marken</strong>
<frame tag="Benutzeraufforderung:">"Xiaomi oder Samsung - Smartphone 2025"</frame>
<strong class="font-semibold">Unterfragen</strong>:
<strong class="font-semibold">Was sie enthalten sollte:</strong>
<strong class="font-semibold">Code 1: Generierung von Unterabfragen aus GPT-5 (Python)</strong>
<mycode12>
import openai

def generate_sub_queries(main_query, num_queries=10):
    """
    Generiert Unterabfragen zur Hauptfrage
    """
    
    # Prompt przetłumaczony na niemiecki, aby model generował wyniki po niemiecku
    prompt = f"""
    Du bist ein Experte für SEO und AI Search Optimization.
    
    Der Nutzer hat folgende Frage gestellt:
    "{main_query}"
    
    Generiere {num_queries} verwandte Unterabfragen, die der Nutzer 
    im Kopf haben könnte oder die der AI Mode generieren könnte.
    
    Die Unterabfragen sollten folgende Bereiche abdecken:
    - Definitionen und Erklärungen
    - Vergleiche und Alternativen
    - Preise und Verfügbarkeit
    - Bewertungen und Erfahrungen
    - Problemlösung
    
    Gib nur die Liste der Unterabfragen zurück, eine pro Zeile.
    """
    
    response = openai.ChatCompletion.create(
        # ZMIANA: gpt-5 nie istnieje (API zwróci błąd). Ustawiłem gpt-4o.
        model="gpt-4o", 
        messages=[
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=1000
    )
    
    sub_queries = response.choices[0].message.content.strip().split('\n')
    return [q.strip() for q in sub_queries if q.strip()]

# Verwendungsbeispiel:
# Przeliczyłem 150 PLN na ok. 40 EUR, aby zapytanie miało sens rynkowy.
# Szukanie "Powerbanka do 150 EUR" dałoby wyniki stacji ładowania kempingowego.
main_q = "Welche Powerbank bis 40 Euro kaufen"
subs = generate_sub_queries(main_q)

for i, sub in enumerate(subs, 1):
    print(f"{i}. {sub}")

# Mögliches Ergebnis:
# 1. Wie viel mAh sollte eine Powerbank fürs Handy haben?
# 2. Powerbank 20000 mAh oder 10000 mAh – was ist besser?
# 3. Beste Powerbanks unter 40 Euro 2025
# usw.
</mycode12>

<strong class="font-semibold">Code 2: Abfrage-Fanout-Simulation - mehrkanalige Suche (Python)</strong>
<mycode13>
import asyncio
from typing import List, Dict

class QueryFanoutSimulator:
    """
    Simuliert das Query-Fanout-Verfahren
    """
    
    def __init__(self):
        self.databases = {
            'products': self.search_products,
            'reviews': self.search_reviews,
            'forums': self.search_forums,
            'prices': self.search_prices,
            'youtube': self.search_youtube
        }
    
    async def execute_fanout(self, main_query: str, sub_queries: List[str]) -> Dict:
        """
        Führt Query-Fanout für die Hauptfrage aus
        """
        
        print(f"Hauptfrage: {main_query}\n")
        print(f"Generierte Unterabfragen ({len(sub_queries)}):")
        for sq in sub_queries:
            print(f"  - {sq}")
        
        print("\n--- Gleichzeitige Suche ---\n")
        
        # Für jede Unterabfrage suchen wir gleichzeitig in allen Datenbanken
        tasks = []
        for sub_query in sub_queries:
            for db_name, search_func in self.databases.items():
                tasks.append(
                    self._search_with_metadata(db_name, search_func, sub_query)
                )
        
        # Alle Aufgaben gleichzeitig ausführen
        results = await asyncio.gather(*tasks)
        
        # Ergebnisse aggregieren
        aggregated = self._aggregate_results(results)
        
        return aggregated
    
    async def _search_with_metadata(self, source: str, search_func, query: str):
        """
        Suche mit Metadaten (welche Quelle, Ranking)
        """
        results = await search_func(query)
        return {
            'source': source,
            'query': query,
            'results': results,
            'count': len(results)
        }
    
    async def search_products(self, query: str) -> List[Dict]:
        """Simulation der Produktsuche"""
        await asyncio.sleep(0.5)  # Verzögerung simulieren
        return [
            {'title': f'Produkt A für "{query}"', 'rank': 1},
            {'title': f'Produkt B für "{query}"', 'rank': 2}
        ]
    
    async def search_reviews(self, query: str) -> List[Dict]:
        """Simulation der Bewertungssuche"""
        await asyncio.sleep(0.3)
        return [
            {'title': f'Rezension: {query}', 'rank': 1, 'rating': 4.8}
        ]
    
    async def search_forums(self, query: str) -> List[Dict]:
        """Simulation der Forensuche"""
        await asyncio.sleep(0.4)
        return [
            {'title': f'Forum - {query}', 'rank': 1, 'replies': 23}
        ]
    
    async def search_prices(self, query: str) -> List[Dict]:
        """Simulation der Preissuche"""
        await asyncio.sleep(0.2)
        return [
            {'title': f'Preise - {query}', 'price_min': 100, 'price_max': 300}
        ]
    
    async def search_youtube(self, query: str) -> List[Dict]:
        """Simulation der YouTube-Suche"""
        await asyncio.sleep(0.6)
        return [
            {'title': f'Video: {query}', 'views': '1M', 'rating': 4.9}
        ]
    
    def _aggregate_results(self, all_results: List[Dict]) -> Dict:
        """
        Aggregation und Ranking der Ergebnisse (vereinfachtes RRF)
        """
        
        aggregated = {}
        source_count = {}
        
        for result_group in all_results:
            source = result_group['source']
            query = result_group['query']
            
            # Zählen, wie oft eine Quelle erscheint
            source_count[source] = source_count.get(source, 0) + 1
            
            for result in result_group['results']:
                title = result['title']
                if title not in aggregated:
                    aggregated[title] = {
                        'title': title,
                        'sources': [],
                        'score': 0
                    }
                
                aggregated[title]['sources'].append(source)
                aggregated[title]['score'] += 1
        
        # Sortieren nach Score (wie viele Quellen das Ergebnis bestätigen)
        ranked = sorted(
            aggregated.values(),
            key=lambda x: x['score'],
            reverse=True
        )
        
        return {
            'total_results': len(ranked),
            'top_results': ranked[:5],
            'sources_used': source_count
        }

# Verwendung:
async def main():
    simulator = QueryFanoutSimulator()
    
    main_query = "Beste Powerbank für Büroarbeit"
    sub_queries = [
        "Powerbank für Laptops",
        "Powerbank – längste Laufzeit",
        "Powerbank fürs Büro – Meinungen",
        "Powerbank Schnellladen"
    ]
    
    results = await simulator.execute_fanout(main_query, sub_queries)
    
    print("\n--- Aggregierte Ergebnisse ---\n")
    print(f"Gefunden: {results['total_results']} einzigartige Ergebnisse")
    print(f"Quellen: {results['sources_used']}\n")
    
    print("Top 5 Ergebnisse (sortiert nach Beliebtheit):")
    for i, result in enumerate(results['top_results'], 1):
        print(f"{i}. {result['title']}")
        print(f"   Score: {result['score']} | Quellen: {', '.join(result['sources'])}\n")

# Starten
if __name__ == "__main__":
    asyncio.run(main())
</mycode13>

<strong class="font-semibold">Code 3: Passagenextraktion (Python)</strong>
<mycode14>
from typing import List, Dict

def extract_passages_for_fanout(content: str, query: str) -> List[Dict]:
    """
    Extrahiert Textpassagen, die die Unteranfrage beantworten
    """
    
    # Aufteilung in Absätze
    paragraphs = content.split('\n\n')
    
    relevant_passages = []
    
    for para in paragraphs:
        # Suche nach wichtigen Wörtern aus der Anfrage
        score = calculate_relevance(para, query)
        
        if score > 0.6:  # Schwellenwert: 60% Relevanz
            # Begrenzung auf 2-3 Sätze (Fragment)
            # HINWEIS: Naives Splitting bei '. ' ist im Deutschen riskant (z.B. bei Abkürzungen)
            sentences = para.split('. ')
            passage = '. '.join(sentences[:3]) + '.'
            relevant_passages.append({
                'text': passage,
                'score': score,
                'length': len(passage)
            })
    
    # Sortierung nach Score
    relevant_passages = sorted(
        relevant_passages,
        key=lambda x: x['score'],
        reverse=True
    )
    
    return relevant_passages[:5]  # Top 5 Fragmente

def calculate_relevance(text: str, query: str) -> float:
    """
    Berechnet, wie relevant der Text für die Anfrage ist (0-1)
    """
    
    query_words = query.lower().split()
    text_lower = text.lower()
    
    # Einfache Wortübereinstimmung
    matches = sum(1 for word in query_words if word in text_lower)
    relevance = matches / len(query_words) if query_words else 0
    
    return min(relevance, 1.0)  # Max 100%

# Beispielinhalt (Deutsch):
content = """
Eine Powerbank ist ein Gerät, das Energie speichert und Ihr Telefon auflädt.
20000 mAh bedeutet Kapazität – je mehr mAh, desto öfter wird das Telefon aufgeladen.

Eine Powerbank für Büroarbeit sollte kompakt und bequem sein.
Unser Modell wiegt nur 300 Gramm und passt in jede Handtasche.

Schnelles Laden ist ein wichtiges Merkmal. Unser Modell unterstützt 65W Schnellladen.
"""

# HINWEIS: Im Deutschen sind zusammengesetzte Substantive (Komposita) wichtig.
# "Büro Arbeit" (2 Wörter) vs "Büroarbeit" (1 Wort).
passages = extract_passages_for_fanout(content, "powerbank für büroarbeit")

for i, p in enumerate(passages, 1):
    print(f"{i}. (score: {p['score']:.2f})")
    print(f"   {p['text']}\n")

# Ergebnis:
# 1. (score: 1.00)
#    Eine Powerbank für Büroarbeit sollte kompakt und bequem sein. Unser Modell wiegt nur 300 Gramm und passt in jede Handtasche.
</mycode14>

<cta dark title="Prüfen Sie, ob AI Ihren Shop sehen kann" description="Eine kostenlose Prüfung durchführen" link="https://platform.semly.ai/register" linkText="Jetzt prüfen">
<strong class="font-semibold">Fehler 1: Nur für Menschen schreiben, nicht für KI</strong>
<strong class="font-semibold">Die falsche Seite:</strong>
<mycode15>
<p><strong>Bestseller-Powerbank 2025!</strong> Unsere Produkte sind eine Zufriedenheitsgarantie.</p>
<p>Kaufen Sie jetzt und <strong>sparen Sie 50 EUR</strong>. Versandkostenfrei ab 100 EUR...</p>
</mycode15>

Warum schlecht? Der AI-Modus weiß es nicht:
<strong class="font-semibold">Gute Seite:</strong>
<mycode16>
## Was ist eine 20.000 mAh Powerbank?

Eine Powerbank ist ein Ladegerät mit einer Kapazität von 20.000 mAh.

### Wie oft lädt sie das Telefon auf?

- iPhone 14: 6-mal
- Samsung S24: 5-mal

### Preis

29.99 EUR (Aktion von 49.99 EUR)

### Bewertungen

Bewertung: 4.8/5 (348 Meinungen)
</mycode16>

Daraus kann KI schöpfen: Kapazität, Anwendung, Preis, Feedback.
<strong class="font-semibold">Fehler 2: Unfertige Artikel</strong>
Viele Geschäfte haben Artikel wie "Artikel in Vorbereitung" oder "Demnächst". Dies ist für den AI-Modus unsichtbar - der Artikel wird ignoriert.
<strong class="font-semibold">Die Regel:</strong> Veröffentlichen Sie vollständige Artikel. Wenn Sie keine Zeit haben, sind viele kurze Artikel besser als ein unfertiger langer Artikel.
<strong class="font-semibold">Fehler 3: Strukturelle Daten fehlen</strong>
<mycode17>
Die Kopfhörer kosten 69.99 Euro

<span itemscope itemtype="https://schema.org/Offer">
  <span itemprop="price">69.99</span>
  <span itemprop="priceCurrency">EUR</span>
</span>
</mycode17>
Ohne Schema könnte die KI denken, dass es sich um das Jahr oder die Modellnummer handelt. Mit Schema - weiß sie, dass es der Preis ist.
<strong class="font-semibold">Fehler 4: Kopieren der Konkurrenz</strong>
Wenn alle Shops gleich schreiben ("Die beste Powerbank ist..."), wird keiner herausstechen. Query Fanout begünstigt <strong class="font-semibold">eine einzigartige Perspektive.</strong>
<strong class="font-semibold">Bewährte Verfahren:</strong>
Diese KI wird sich leichter durchsetzen.
<strong class="font-semibold">Gilt Query Fanout für alle Branchen?
</strong>Nein. Sie ist vor allem für Branchen geeignet, in denen Entscheidungen komplex sind:
Weniger besorgt:
<strong class="font-semibold">
Wie lange dauert es, den Shop unter Query Fanout anzupassen?</strong>
Für ein kleines Geschäft (50-100 Produkte): 2-4 Wochen, für einen mittleren (1000 Produkte): 2-3 Monate, für einen großen Laden (10000+ Produkte): 6 Monate+
Dies ist keine einmalige Aufgabe - es ist ein fortlaufender Prozess.

<strong class="font-semibold">Wird ein traditionell gut platziertes Produkt im KI-Modus sichtbar sein?</strong>
Normalerweise ja, aber nicht immer. Der AI-Modus hat andere Kriterien als die traditionelle SEO. Es ist möglich, dass Sie in der traditionellen Suche gut abschneiden, im KI-Modus aber nicht (oder umgekehrt). Daher sind beide Strategien wichtig.

<strong class="font-semibold">Verändert Query Fanout die Art und Weise, wie wir Traffic von Google Ads erhalten?</strong>
Im Moment noch nicht - Google Ads funktioniert noch. Aber langfristig, wenn mehr und mehr Menschen den KI-Modus anstelle der traditionellen Suche nutzen, kann sich das Geschäftsmodell ändern. Es lohnt sich, in andere Kanäle zu investieren (E-Mail, soziale Medien, Partnerschaften).

<strong class="font-semibold">Verwendet ChatGPT auch Query Fanout?</strong>
ChatGPT verwendet eine fortgeschrittene Version (bittet den Nutzer um Erklärungen, schlüsselt Anfragen intern selbst auf). Aber es hat nicht die Sichtbarkeit von Google AI Mode. Andere Tools:

<strong class="font-semibold">Muss mein Inhalt buchstäblich auf meiner Seite stehen?</strong>
Nein. Der AI-Modus kann auch Passagen aus anderen Quellen zitieren. Wenn Sie aber eine eigene Seite haben, erhöht dies die Chancen auf Sichtbarkeit in Antworten erheblich.
<strong class="font-semibold">Ist AMP oder mobile-first wichtig für Query Fanout?
</strong>Ja, aber nicht in der gleichen Weise wie bei der traditionellen SEO. AI Modus wichtig sind:
Aber nicht unbedingt die Geschwindigkeit der Website (obwohl eine schnelle Website immer hilfreich ist).

<strong class="font-semibold">Sollte ich jetzt einen Werbetexter einstellen?</strong>
Wenn Sie noch nie eine hatten - ja. Query Fanout erfordert ein hohes Volumen an qualitativ hochwertigen Inhalten. Ein Texter sollte einen Artikel pro Woche schreiben (mindestens).
<strong class="font-semibold">AI-Modus</strong> - google-Suchmodus, bei dem die Antworten von der KI generiert werden (anstelle einer Liste von Links)
<strong class="font-semibold">Aggregation</strong> - kombination von Ergebnissen aus mehreren Quellen zu einer einzigen Antwort
<strong class="font-semibold">Asyncio</strong> - python-Bibliothek für die gleichzeitige Ausführung von Aufgaben
<strong class="font-semibold">Behörde</strong> - das Wissen von Google, dass die Website zu dem betreffenden Thema vertrauenswürdig ist
<strong class="font-semibold">Backlink </strong>- link von einer anderen Seite zu Ihrer
<strong class="font-semibold">Chatbot</strong> - ein Programm, das mit dem Benutzer spricht
<strong class="font-semibold">Stückchen</strong> - kleiner Textabschnitt (z. B. ein Absatz)
<strong class="font-semibold">Kernabfrage</strong> - die wichtigste Frage, mit der wir beginnen
<strong class="font-semibold">Zersetzung</strong> - aufteilung einer Frage in eine Reihe von kleineren Fragen
<strong class="font-semibold">Einbettung</strong> - umwandlung von Text in Zahlen (Vektoren), die eine Bedeutung darstellen
<strong class="font-semibold">Fanout </strong>- dissemination, dissemination (hier: Verbreitung einer Anfrage)
<strong class="font-semibold">Zwillinge</strong> - das KI-Modell von Google (entspricht ChatGPT)
<strong class="font-semibold">Generator (LLM)</strong> - kI-Modell, das Text erzeugt
<strong class="font-semibold">Halluzination</strong> - wenn AI Informationen erfindet, die nicht wahr sind
<strong class="font-semibold">Absichtserkenntnis</strong> - erkennen, was der Nutzer wirklich will (nicht nur das, was er geschrieben hat)
<strong class="font-semibold">LLM (Großes Sprachmodell)</strong> - großes Sprachmodell (ChatGPT, Gemini, Claude)
<strong class="font-semibold">Passage Extraktion</strong> - extraktion von Textfragmenten, die relevant sind
<strong class="font-semibold">Abfrage</strong> - frage, Abfrage
<strong class="font-semibold">Zerlegung der Abfrage</strong> - aufteilung einer Frage in Teilfragen
<strong class="font-semibold">Abfrage Fanout</strong> - aufteilung der Fragen in mehrere Unterfragen durch AI
<strong class="font-semibold">RAG (Retrieval-Augmented Generation)</strong> - suche nach Informationen + Generierung von Antworten
<strong class="font-semibold">Reciprocal Rank Fusion (RRF) </strong>- ein Algorithmus zur Kombination von Ergebnissen aus mehreren Quellen
<strong class="font-semibold">Relevanz</strong> - ob das Ergebnis für die Abfrage relevant ist
<strong class="font-semibold">Abruf</strong> - suche, Suche nach Informationen
<strong class="font-semibold">Schema.org</strong> - standard für die Kennzeichnung von Daten auf Seiten
<strong class="font-semibold">Semantik</strong> - bedeutung von Wörtern und Texten
<strong class="font-semibold">SEO</strong> - suchmaschinenoptimierung
<strong class="font-semibold">Unterabfrage</strong> - teilfrage, kleinere Frage
<strong class="font-semibold">Synthese</strong> - Kombination von Informationen aus verschiedenen Quellen
<strong class="font-semibold">Vektor-Datenbank</strong> - datenbank, die Text als Vektoren speichert
<strong class="font-semibold">Vektorielle Ähnlichkeit</strong> - wie ähnlich sich die beiden Texte sind
<mylist1>
<strong class="font-semibold">Analyse</strong> - Prüfen Sie, wie Query Fanout für Ihre Hauptprodukte funktioniert (suchen Sie in Google AI Mode)
<strong class="font-semibold">Kartierung</strong> - Erstellen Sie eine Liste von Unterabfragen für die 10 wichtigsten Produkte
<strong class="font-semibold">Audit des Inhalts</strong> - Prüfen, welche Seiten bereits Fragmente haben, die Unterabfragen adressieren
<strong class="font-semibold">Struktur</strong> - Umstrukturierung der Produktseiten: Hinzufügen von FAQs, Hinzufügen von Vergleichen in Tabellen, Hinzufügen von Nutzerbewertungen, Hinzufügen von "Was Sie wissen müssen"-Abschnitten 
<strong class="font-semibold">Schema</strong> - Implementierung von Schema.org auf allen Produktseiten
<strong class="font-semibold">Inhalt</strong> - Verfassen von "Kaufratgeber"-Artikeln für die wichtigsten Kategorien
<strong class="font-semibold">Backlinks</strong> - Beginnen Sie, Autorität aufzubauen (Artikel auf externen Websites)
<strong class="font-semibold">Überwachung</strong> - Spurensichtbarkeit im KI-Modus (neue Tools machen dies möglich)
<strong class="font-semibold">Iteration</strong> - Analyse der Unterabfragen und monatliche Aktualisierung des Inhalts
</mylist1>
Query Fanout ist nicht die Zukunft - es ist die Gegenwart. Ab Mai 2025 ist der Google KI-Modus in Produktion, und die Wettbewerber halten mit (ChatGPT, Claude, Perplexity).
Die wichtigsten Punkte sind zu beachten:
Query Fanout gibt Ihnen neue Möglichkeiten für Ihren Shop. Sie müssen kein Programmierer sein - Sie können damit beginnen, zu analysieren, wie Query Fanout für Ihre Produkte funktioniert, Unterabfragen zuzuordnen und bessere Inhalte vorzubereiten.
Der Rest wird sich von selbst ergeben.
<strong class="font-semibold">Quellen</strong>

## Wie oft lädt eine 20.000 mAh Powerbank mein Handy auf?

Das hängt von der Akkukapazität Ihres Handys ab:

- iPhone 14 (3200 mAh): ~6-mal
- Samsung Galaxy S24 (4000 mAh): ~5-mal
- OnePlus 12 (5400 mAh): ~3,5-mal
- iPad Air (8600 mAh): ~2-mal

**Wie wird das berechnet?**
20.000 mAh (Powerbank) / 4.000 mAh (Handy) = 5 Ladungen
(in der Praxis weniger aufgrund von Energieverlusten)

## Lädt eine 20.000 mAh Powerbank einen Laptop?

Ja, aber...
- Sie muss einen USB-C Power Delivery Ausgang haben
- Sie muss mindestens 65W leisten
- Ältere Laptops (mit Micro-USB) – nein

Unser Modell: 100W, USB-C PD, lädt das MacBook Air in 2,5 Stunden.

## Powerbank für den Urlaub – passt sie ins Gepäck?

- Maße: 12 x 7 x 3 cm
- Gewicht: 420 g
- Passt in den Rucksack, den Kulturbeutel oder die Tasche einer großen Handtasche
- Ideal für den Urlaub (nimmt keinen Platz weg)

[usw.]

# [Produkt] – Der komplette Leitfaden [Jahr]

## Was du vor dem Kauf von [Produkt] wissen solltest

### 1. [Erster kritischer Aspekt]
- Definition für Anfänger
- Warum das wichtig ist
- Wie man das in der Praxis prüft

### 2. [Zweiter Aspekt]
[dasselbe]

### 3. [Dritter Aspekt]
[dasselbe]

## Vergleich beliebter Modelle

| Name | Spez1 | Spez2 | Preis | Bewertung |
| --- | --- | --- | --- | --- |
| Modell A | | | | |

## FAQ – Häufig gestellte Fragen

F: [Frage, die in Google Trends erschienen ist]
A: [Konkrete Antwort]

## Nutzererfahrungen

"Nutzergeschichte: warum er gekauft hat, wie seine Erfahrungen sind"

<!DOCTYPE html>
<html>
<head>
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Powerbank 20000 mAh SuperCharge",
  "image": ["https://...1.jpg"],
  "description": "Powerbank unter 35 Euro mit Schnellladefunktion",
  "brand": {
    "@type": "Brand",
    "name": "TechBrand"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://...produkt",
    "priceCurrency": "EUR",
    "price": "29.99",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "ratingCount": "348",
    "bestRating": "5",
    "worstRating": "1"
  },
  "review": [
    {
      "@type": "Review",
      "author": {
        "@type": "Person",
        "name": "Jan"
      },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5"
      },
      "reviewBody": "Super Powerbank, sehr zu empfehlen"
    }
  ]
}
</script>
</head>
</html>

import openai

def generate_sub_queries(main_query, num_queries=10):
    """
    Generiert Unterabfragen zur Hauptfrage
    """
    
    # Prompt przetłumaczony na niemiecki, aby model generował wyniki po niemiecku
    prompt = f"""
    Du bist ein Experte für SEO und AI Search Optimization.
    
    Der Nutzer hat folgende Frage gestellt:
    "{main_query}"
    
    Generiere {num_queries} verwandte Unterabfragen, die der Nutzer 
    im Kopf haben könnte oder die der AI Mode generieren könnte.
    
    Die Unterabfragen sollten folgende Bereiche abdecken:
    - Definitionen und Erklärungen
    - Vergleiche und Alternativen
    - Preise und Verfügbarkeit
    - Bewertungen und Erfahrungen
    - Problemlösung
    
    Gib nur die Liste der Unterabfragen zurück, eine pro Zeile.
    """
    
    response = openai.ChatCompletion.create(
        # ZMIANA: gpt-5 nie istnieje (API zwróci błąd). Ustawiłem gpt-4o.
        model="gpt-4o", 
        messages=[
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=1000
    )
    
    sub_queries = response.choices[0].message.content.strip().split('\n')
    return [q.strip() for q in sub_queries if q.strip()]

# Verwendungsbeispiel:
# Przeliczyłem 150 PLN na ok. 40 EUR, aby zapytanie miało sens rynkowy.
# Szukanie "Powerbanka do 150 EUR" dałoby wyniki stacji ładowania kempingowego.
main_q = "Welche Powerbank bis 40 Euro kaufen"
subs = generate_sub_queries(main_q)

for i, sub in enumerate(subs, 1):
    print(f"{i}. {sub}")

# Mögliches Ergebnis:
# 1. Wie viel mAh sollte eine Powerbank fürs Handy haben?
# 2. Powerbank 20000 mAh oder 10000 mAh – was ist besser?
# 3. Beste Powerbanks unter 40 Euro 2025
# usw.

import asyncio
from typing import List, Dict

class QueryFanoutSimulator:
    """
    Simuliert das Query-Fanout-Verfahren
    """
    
    def __init__(self):
        self.databases = {
            'products': self.search_products,
            'reviews': self.search_reviews,
            'forums': self.search_forums,
            'prices': self.search_prices,
            'youtube': self.search_youtube
        }
    
    async def execute_fanout(self, main_query: str, sub_queries: List[str]) -> Dict:
        """
        Führt Query-Fanout für die Hauptfrage aus
        """
        
        print(f"Hauptfrage: {main_query}\n")
        print(f"Generierte Unterabfragen ({len(sub_queries)}):")
        for sq in sub_queries:
            print(f"  - {sq}")
        
        print("\n--- Gleichzeitige Suche ---\n")
        
        # Für jede Unterabfrage suchen wir gleichzeitig in allen Datenbanken
        tasks = []
        for sub_query in sub_queries:
            for db_name, search_func in self.databases.items():
                tasks.append(
                    self._search_with_metadata(db_name, search_func, sub_query)
                )
        
        # Alle Aufgaben gleichzeitig ausführen
        results = await asyncio.gather(*tasks)
        
        # Ergebnisse aggregieren
        aggregated = self._aggregate_results(results)
        
        return aggregated
    
    async def _search_with_metadata(self, source: str, search_func, query: str):
        """
        Suche mit Metadaten (welche Quelle, Ranking)
        """
        results = await search_func(query)
        return {
            'source': source,
            'query': query,
            'results': results,
            'count': len(results)
        }
    
    async def search_products(self, query: str) -> List[Dict]:
        """Simulation der Produktsuche"""
        await asyncio.sleep(0.5)  # Verzögerung simulieren
        return [
            {'title': f'Produkt A für "{query}"', 'rank': 1},
            {'title': f'Produkt B für "{query}"', 'rank': 2}
        ]
    
    async def search_reviews(self, query: str) -> List[Dict]:
        """Simulation der Bewertungssuche"""
        await asyncio.sleep(0.3)
        return [
            {'title': f'Rezension: {query}', 'rank': 1, 'rating': 4.8}
        ]
    
    async def search_forums(self, query: str) -> List[Dict]:
        """Simulation der Forensuche"""
        await asyncio.sleep(0.4)
        return [
            {'title': f'Forum - {query}', 'rank': 1, 'replies': 23}
        ]
    
    async def search_prices(self, query: str) -> List[Dict]:
        """Simulation der Preissuche"""
        await asyncio.sleep(0.2)
        return [
            {'title': f'Preise - {query}', 'price_min': 100, 'price_max': 300}
        ]
    
    async def search_youtube(self, query: str) -> List[Dict]:
        """Simulation der YouTube-Suche"""
        await asyncio.sleep(0.6)
        return [
            {'title': f'Video: {query}', 'views': '1M', 'rating': 4.9}
        ]
    
    def _aggregate_results(self, all_results: List[Dict]) -> Dict:
        """
        Aggregation und Ranking der Ergebnisse (vereinfachtes RRF)
        """
        
        aggregated = {}
        source_count = {}
        
        for result_group in all_results:
            source = result_group['source']
            query = result_group['query']
            
            # Zählen, wie oft eine Quelle erscheint
            source_count[source] = source_count.get(source, 0) + 1
            
            for result in result_group['results']:
                title = result['title']
                if title not in aggregated:
                    aggregated[title] = {
                        'title': title,
                        'sources': [],
                        'score': 0
                    }
                
                aggregated[title]['sources'].append(source)
                aggregated[title]['score'] += 1
        
        # Sortieren nach Score (wie viele Quellen das Ergebnis bestätigen)
        ranked = sorted(
            aggregated.values(),
            key=lambda x: x['score'],
            reverse=True
        )
        
        return {
            'total_results': len(ranked),
            'top_results': ranked[:5],
            'sources_used': source_count
        }

# Verwendung:
async def main():
    simulator = QueryFanoutSimulator()
    
    main_query = "Beste Powerbank für Büroarbeit"
    sub_queries = [
        "Powerbank für Laptops",
        "Powerbank – längste Laufzeit",
        "Powerbank fürs Büro – Meinungen",
        "Powerbank Schnellladen"
    ]
    
    results = await simulator.execute_fanout(main_query, sub_queries)
    
    print("\n--- Aggregierte Ergebnisse ---\n")
    print(f"Gefunden: {results['total_results']} einzigartige Ergebnisse")
    print(f"Quellen: {results['sources_used']}\n")
    
    print("Top 5 Ergebnisse (sortiert nach Beliebtheit):")
    for i, result in enumerate(results['top_results'], 1):
        print(f"{i}. {result['title']}")
        print(f"   Score: {result['score']} | Quellen: {', '.join(result['sources'])}\n")

# Starten
if __name__ == "__main__":
    asyncio.run(main())

from typing import List, Dict

def extract_passages_for_fanout(content: str, query: str) -> List[Dict]:
    """
    Extrahiert Textpassagen, die die Unteranfrage beantworten
    """
    
    # Aufteilung in Absätze
    paragraphs = content.split('\n\n')
    
    relevant_passages = []
    
    for para in paragraphs:
        # Suche nach wichtigen Wörtern aus der Anfrage
        score = calculate_relevance(para, query)
        
        if score > 0.6:  # Schwellenwert: 60% Relevanz
            # Begrenzung auf 2-3 Sätze (Fragment)
            # HINWEIS: Naives Splitting bei '. ' ist im Deutschen riskant (z.B. bei Abkürzungen)
            sentences = para.split('. ')
            passage = '. '.join(sentences[:3]) + '.'
            relevant_passages.append({
                'text': passage,
                'score': score,
                'length': len(passage)
            })
    
    # Sortierung nach Score
    relevant_passages = sorted(
        relevant_passages,
        key=lambda x: x['score'],
        reverse=True
    )
    
    return relevant_passages[:5]  # Top 5 Fragmente

def calculate_relevance(text: str, query: str) -> float:
    """
    Berechnet, wie relevant der Text für die Anfrage ist (0-1)
    """
    
    query_words = query.lower().split()
    text_lower = text.lower()
    
    # Einfache Wortübereinstimmung
    matches = sum(1 for word in query_words if word in text_lower)
    relevance = matches / len(query_words) if query_words else 0
    
    return min(relevance, 1.0)  # Max 100%

# Beispielinhalt (Deutsch):
content = """
Eine Powerbank ist ein Gerät, das Energie speichert und Ihr Telefon auflädt.
20000 mAh bedeutet Kapazität – je mehr mAh, desto öfter wird das Telefon aufgeladen.

Eine Powerbank für Büroarbeit sollte kompakt und bequem sein.
Unser Modell wiegt nur 300 Gramm und passt in jede Handtasche.

Schnelles Laden ist ein wichtiges Merkmal. Unser Modell unterstützt 65W Schnellladen.
"""

# HINWEIS: Im Deutschen sind zusammengesetzte Substantive (Komposita) wichtig.
# "Büro Arbeit" (2 Wörter) vs "Büroarbeit" (1 Wort).
passages = extract_passages_for_fanout(content, "powerbank für büroarbeit")

for i, p in enumerate(passages, 1):
    print(f"{i}. (score: {p['score']:.2f})")
    print(f"   {p['text']}\n")

# Ergebnis:
# 1. (score: 1.00)
#    Eine Powerbank für Büroarbeit sollte kompakt und bequem sein. Unser Modell wiegt nur 300 Gramm und passt in jede Handtasche.

<p><strong>Bestseller-Powerbank 2025!</strong> Unsere Produkte sind eine Zufriedenheitsgarantie.</p>
<p>Kaufen Sie jetzt und <strong>sparen Sie 50 EUR</strong>. Versandkostenfrei ab 100 EUR...</p>

## Was ist eine 20.000 mAh Powerbank?

Eine Powerbank ist ein Ladegerät mit einer Kapazität von 20.000 mAh.

### Wie oft lädt sie das Telefon auf?

- iPhone 14: 6-mal
- Samsung S24: 5-mal

### Preis

29.99 EUR (Aktion von 49.99 EUR)

### Bewertungen

Bewertung: 4.8/5 (348 Meinungen)

Die Kopfhörer kosten 69.99 Euro

<span itemscope itemtype="https://schema.org/Offer">
  <span itemprop="price">69.99</span>
  <span itemprop="priceCurrency">EUR</span>
</span>