AI 中的 Query Fanout 如何运作？完整指南

# Simplified pseudocode of what happens in the background
import asyncio
async def query_fanout_search(main_query):
    """
    Concurrent search for all subqueries
    """
    # We break down the main question
    sub_queries = decompose_query(main_query)
    # Result: ["vlogging camera beginner", "camera for YT reviews", ...]
    # We create tasks for each subquery
    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))
    # We run everything simultaneously (asyncio)
    all_results = await asyncio.gather(*tasks)
    return all_results

User searches for: "laptop for learning programming"
→ Your site appears in position 3
→ The user clicks the link
→ They land on your page

→ AI Mode generates a response with a sentence:
"Popular choices are: [quote from site A], [quote from site B],
[quote from your site]"
→ The user sometimes clicks the links, sometimes not, but your brand
appears in the answer

Title: Laptop for programming
The best laptop for programming is something that has...
[two pages of dense text]

# Laptop for Programming – Full Guide 2025
## What do you need to know before buying a laptop for programming?
### 1. Processor – Intel or AMD?
AMD Ryzen 7 is faster for code compilation...
[specific tests]
### 2. RAM – how much do you need?
- For Python: 8-16 GB
- For Web Dev: 16 GB minimum
- For AI/ML: 32 GB
### 3. SSD Drive – how much?
Minimum: 512 GB
Recommendation: 1 TB
[Each point has a clear, self-contained answer]
## Comparison of popular models
| Model | Processor | RAM | SSD | Price | Rating |
| --- | --- | --- | --- | --- | --- |
| Model A | Ryzen 7 | 16GB | 512GB | 3999 | 9.2 |
| Model B | i7-13 | 16GB | 1TB | 4499 | 9.5 |
[Each row is a fragment that AI can extract]
## FAQ – frequently asked questions
Q: Is a MacBook good for programming?
A: Yes, but...
Q: How much does a good laptop for coding cost?
A: From 700 EUR...
[Each Q&A pair is a potential sub-query]
## User Reviews
"I bought this laptop, I code in Python and now I'm earning..." (15 positive reviews)

The laptop costs 1000 EUR
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Programming Laptop Model X",
  "image": "https://example.com/laptop-x.jpg",
  "description": "High-performance laptop for coding.",
  "brand": {
    "@type": "Brand",
    "name": "BrandName"
  },
  "offers": {
    "@type": "Offer",
    "price": "945",
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "ratingCount": "125"
  }
}
</script>

ZASTOSOWANIE:
USAGE:
- "power bank for iPhone"
- "power bank for laptop"
- "power bank for vacation – test"
- "power bank for office work"
FEATURES:
- "how many times will a power bank charge a phone"
- "power bank 20000 mAh vs 30000 mAh"
- "power bank fast charging – how many watts"
COMPARISONS:
- "Xiaomi vs Samsung power bank"
- "cheap vs expensive power bank – difference"
- "best power bank 2025 – ranking"
PROBLEM-SOLVING:
- "power bank is not charging – what to do"
- "power bank discharges quickly"
- "power bank gets hot"

## How many times will a 20000 mAh power bank charge my phone?
It depends on your phone's battery capacity:
- iPhone 14 (3200 mAh): ~6 times
- Samsung Galaxy S24 (4000 mAh): ~5 times
- OnePlus 12 (5400 mAh): ~3.5 times
- iPad Air (8600 mAh): ~2 times
**How is it calculated?**
20000 mAh (power bank) / 4000 mAh (phone) = 5 charges
(in practice less due to energy loss)
## Will a 20000 mAh power bank charge a laptop?
Yes, but...
- It must have a USB-C Power Delivery output
- It must be at least 65W
- Older laptops (with Micro USB) – no
Our model: 100W, USB-C PD, charges MacBook Air in 2.5 hours.
## Power bank for vacation – will it fit?
- Dimensions: 12 x 7 x 3 cm
- Weight: 420 g
- Fits in a backpack, toiletry bag, pocket of a large handbag
- Ideal for vacation (doesn't take up space)
[etc.]

# [Product] – Complete Guide [Year]
## What should you know before buying [product]?
### 1. [First Critical Aspect]
- Definition for beginners
- Why is it important
- How to check it in practice
### 2. [Second Aspect]
[same as above]
### 3. [Third Aspect]
[same as above]
## Comparison of popular models
| Name | Spec1 | Spec2 | Price | Review |
| --- | --- | --- | --- | --- |
| Model A | | | | |
## FAQ – frequently asked questions
Q: [Question that appeared in Google Trends]
A: [Specific answer]
## User Reviews
"User story, why they bought it, what are their experiences"

<!DOCTYPE html>
<html>
<head>
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Power Bank 20000 mAh SuperCharge",
  "image": ["https://...1.jpg"],
  "description": "Power bank under 35 EUR with fast charging",
  "brand": {
    "@type": "Brand",
    "name": "TechBrand"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://...product",
    "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": "User John"
      },
      "reviewRating": {
        "@type": "Rating",
        "ratingValue": "5"
      },
      "reviewBody": "Great power bank, highly recommended"
    }
  ]
}
</script>
</head>
</html>

import openai

def generate_sub_queries(main_query, num_queries=10):
    """
    Generates sub-queries for the main question
    """
    prompt = f"""
    You are an expert in SEO and AI Search Optimization.
    The user asked the following question:
    "{main_query}"
    Generate {num_queries} related sub-queries that the user 
    might have had in mind or that an AI Mode could generate.
    The sub-queries should cover:
    - Definitions and explanations
    - Comparisons and alternatives
    - Prices and availability
    - Reviews and experiences
    - Problem-solving
    Return only the list of sub-queries, one per line.
    """

    response = openai.ChatCompletion.create(
        model="gpt-5",
        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()]

# Example usage:
main_q = "Which power bank to choose under 50 EUR"
subs = generate_sub_queries(main_q)

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

# Result:
# 1. How many mAh should a phone power bank have
# 2. Power bank 20000 mAh vs 30000 mAh – which is better
# 3. Best power banks under 43 EUR 2025
# etc.

import asyncio
from typing import List, Dict

class QueryFanoutSimulator:
    """
    Simulates query fanout operation
    """
    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:
        """
        Executes query fanout for the main question
        """
        print(f"Main query: {main_query}\n")
        print(f"Generated sub-queries ({len(sub_queries)}):")
        for sq in sub_queries:
            print(f"  - {sq}")
        
        print("\n--- Simultaneous searching ---\n")
        
        # For each sub-query, we search all databases simultaneously
        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)
                )
        
        # Execute all simultaneously
        results = await asyncio.gather(*tasks)
        
        # Aggregation of results
        aggregated = self._aggregate_results(results)
        return aggregated

    async def _search_with_metadata(self, source: str, search_func, query: str):
        """
        Search with metadata (which source, 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 of product search"""
        await asyncio.sleep(0.5)  # Delay simulation
        return [
            {'title': f'Product A for "{query}"', 'rank': 1},
            {'title': f'Product B for "{query}"', 'rank': 2}
        ]

    async def search_reviews(self, query: str) -> List[Dict]:
        """Simulation of reviews search"""
        await asyncio.sleep(0.3)
        return [
            {'title': f'Review: {query}', 'rank': 1, 'rating

import re
from typing import List

def extract_passages_for_fanout(content: str, query: str) -> List[str]:
    """
    Extracts content passages that answer the sub-query
    """
    # Splitting into paragraphs
    paragraphs = content.split('\n\n')
    relevant_passages = []

    for para in paragraphs:
        # Searching for important words from the query
        score = calculate_relevance(para, query)
        
        if score > 0.6:  # Threshold: 60% relevance
            # Limiting to 2-3 sentences (fragment)
            sentences = para.split('. ')
            passage = '. '.join(sentences[:3]) + '.'
            
            relevant_passages.append({
                'text': passage,
                'score': score,
                'length': len(passage)
            })
    
    # Sorting by score
    relevant_passages = sorted(
        relevant_passages,
        key=lambda x: x['score'],
        reverse=True
    )
    
    return relevant_passages[:5]  # Top 5 fragments

def calculate_relevance(text: str, query: str) -> float:
    """
    Calculates how relevant the text is to the query (0-1)
    """
    query_words = query.lower().split()
    text_lower = text.lower()
    
    # Generator expression to count matches
    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%

# Example usage:
content = """
A power bank is a device that stores energy and charges your phone.

20000 mAh means capacity – the more mAh, the more times it charges the phone.

A power bank for office work should be compact and convenient.

Our power bank weighs only 300 grams and fits in a handbag.

Fast charging is an important feature. Our model supports 65W fast charging.
"""

passages = extract_passages_for_fanout(content, "power bank for office work")

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

# Result:
# 1. (score: 0.80)
#    A power bank for office work should be compact and convenient.
#
# 2. (score: 0.40)
#    Our power bank weighs only 300 grams...

2025 Bestseller Power Bank! Our products guarantee satisfaction.
Buy now and save 10 EUR. Free shipping on orders over 30 EUR...

## What is a 20000 mAh power bank?
A power bank is a charging device with a capacity of 20000 mAh.
### How many times will it charge a phone?
- iPhone 14: 6 times
- Samsung S24: 5 times
### Price
40 EUR (promotion from 47 EUR)
### Reviews
Rating: 4.8/5 (348 reviews)

Without Schema:
Headphones cost 70 EUR
With Schema:
<span itemscope itemtype="https://schema.org/Offer">
  <span itemprop="price">70</span>
  <span itemprop="priceCurrency">EUR</span>
</span>