De meeste AI-agenten, ML-pijpleidingen, AI-verrijkingsprocessen, diepgaande onderzoekssystemen en op gegevens gebaseerde beslissingsmotoren falen niet omdat de modellen slecht zijn. Specifiek, de gegevens hebben de neiging om verouderd te zijn, buiten de context, niet te verifiëren, of alle drie tegelijk. dat is het kernprobleem. In dit artikel zie je wat In feite betekent, hoe het werkt onder de hoed, waarom het belangrijker is dan de meeste mensen denken, en hoe het eind-tot-eind te implementeren met een concreet voorbeeld! Zoeken en extraheren De behoefte aan verse, contextuele en betrouwbare, controleerbare informatie Volgens Statista worden elke dag ongeveer 402,74 miljoen terabytes aan gegevens gegenereerd. Dat gegevens doordringen in het web, data warehouses, analytics stacks en pipelines op een schaal die eerlijk gezegd moeilijk te redeneren is. Maar hier is de vangst: meer gegevens betekent geen betere gegevens! Op dat volume is het onrealistisch om te veronderstellen dat alles de werkelijkheid weerspiegelt - of dat het zelfs in de eerste plaats kan worden vertrouwd ... Bedrijven maken nog steeds zakelijke beslissingen, automatisering en AI-gedreven oproepen op basis van De data. dat En wanneer de bron verouderd, onvolledig of gewoon verkeerd is... de inzichten die erop gebouwd zijn, kunnen niet betrouwbaar zijn. Dit is precies waarom LLM's hallucineren, AI-agenten overtuigende maar onjuiste antwoorden geven en datapijpleidingen rustig falen in de productie. In de meeste real-world gevallen is het probleem niet het model, de tooling of de implementatie. Of u nu een klassieke analytics workflow of een volledig autonome AI-agent uitvoert, alles hangt af van de kwaliteit van de brongegevens. 
 
 
 
 Fresh Contextueel Controleerbaar Immers, als je niet weet De gegevens zijn afkomstig van of het werd verzameld, je kunt het resultaat niet realistisch vertrouwen. Waar Wanneer Dat is de echte vraag. 
 
 Hoe haal je informatie op betrouwbare wijze terug die up-to-date is, relevant is voor een specifieke taak en waarschijnlijk aan de bron is gekoppeld? Hoe haal je informatie op betrouwbare wijze terug die up-to-date is, relevant is voor een specifieke taak en waarschijnlijk aan de bron is gekoppeld? Dat is waar de Pattern komt binnen! laten we het breken. Search and Extract Search and Extract: wat het is en waarom het de oplossing is “Search and Extract” is een proces voor het ophalen van up-to-date, verifieerbare en contextrijke informatie van het web . Het is eenvoudig in structuur, maar uiterst effectief in de praktijk. De facto standaard Op een hoog niveau werkt het in twee verschillende stappen: 
 
 
 Zoek: Het systeem voert een live webzoekopdracht uit op zoekmachines zoals Google om de meest relevante en betrouwbare bronnen voor een bepaalde query te vinden. Uittreksel: Uit de zoekresultaten identificeert het systeem de meest relevante URL's, bezoekt deze pagina's en haalt de meest nuttige inhoud of gegevens uit. Dit kan feiten, statistieken, definities of gestructureerde informatie bevatten die zijn geanalyseerd vanuit de pagina. Dit patroon is vooral nuttig in AI-gerelateerde toepassingen, zoals AI-agenten, Ook is het van toepassing op traditionele machine learning, feitencontrole en data-verrijking pijpleidingen. agentic RAG systems Agentische RAG systemen Het uiteindelijke doel van het "Search and Extract" -patroon is om de moderne data-uitdagingen aan te pakken door ervoor te zorgen dat de verzamelde informatie: 
 
 
 
 Fresh , omdat de gesneden openbare webgegevens afkomstig zijn van recente webzoekopdrachten, die de nieuwste informatie en nieuws kunnen bevatten. Contextueel, omdat de informatie nauw is afgestemd op de onderwerpen die zijn opgegeven in de zoekopdracht. Verificeerbaar, omdat de gegevens rechtstreeks afkomstig zijn van specifieke webpagina's, met URL's die iedereen kan bezoeken en controleren. Hoe werkt zoeken en extraheren? Op een hoog niveau kan "Zoek en uittrekken" worden samengevat met de volgende workflow: Deze worden over het algemeen contextueel geëxtraheerd uit documenten, datasets of gegeven informatiebronnen met behulp van AI/ML. Dat is wat vaak voorkomt in AI-verrijking, gegevensverificatie, RAG-werkstromen of diepgaande onderzoekstoepassingen. Ongeacht de bron worden de zoekbare onderwerpen doorgegeven aan het onderdeel "Zoek", waar een SERP API-oplossing geautomatiseerde webzoekopdrachten uitvoert op de doelzoekmachines.Na het ophalen van de zoekresultaten kunt u alle geretourneerde webpagina's overwegen of alleen de meest relevante webpagina's filteren met behulp van AI/ML of strikte regels (bijv. pagina's houden van specifieke domeinen, talen of andere criteria). Bij het richten op meerdere zoekopdrachten tegelijk (of het nu gaat om verschillende query's of meerdere pagina's voor dezelfde query), moet u mogelijk een aangepast re-ranking-algoritme uitvoeren.De ranglijst die door Google of elke zoekmachine wordt verstrekt, is geoptimaliseerd voor SEO, wat misschien niet weerspiegelt wat belangrijk is voor uw gebruik. De geselecteerde URL's worden vervolgens naar de "Extract" -knop gestuurd, waar een webscraping-service elke pagina opent en de belangrijkste informatie extrahert. Laten we vervolgens de diensten verkennen die in de fasen “Zoek” en “Extract” in werking komen, respectievelijk! Zoeken Zoekmachines zoals Google, Bing, DuckDuckGo, Baidu en Yandex beschermen hun SERPs (Search Engine Results Pages) met tarieflimieten en CAPTCHAs om geautomatiseerde scraping te voorkomen. De meest betrouwbare manier om de "Zoek" -fase uit te voeren is door een SERP API-oplossing te gebruiken.Deze diensten onthullen eindpunten om zoekopdrachten in de cloud te activeren met behulp van een infrastructuur die is ontworpen om schaalbaarheid en anti-bot maatregelen voor u te verwerken. Het ondersteunt wereldwijde zoekopdrachten via een proxy-netwerk van meer dan 150 miljoen IP's in 195 landen, kan volledig geanalyseerde SERP-gegevens retourneren in JSON, biedt vele paginatieopties en ondersteunt integratie in elke gegevens- of ML-pijplijn met behulp van standaard HTTP-verzoeken, evenals meer dan 50 AI-agent frameworks en workflows. De SERP API van Bright Data De SERP API van Bright Data Plus, de SERP API van Bright Data stelt u in staat om een onbeperkt aantal zoekopdrachten parallel uit te voeren. Dit betekent dat u duizenden resultaten kunt vinden tijdens de "Zoek" -fase. Extract ️ De reden is dat elke website anders is, en zelfs pagina's binnen hetzelfde domein kunnen verschillende rendering, data-visualisatie en retrieval logica volgen. Dit maakt programmatisch toegang tot hun inhoud vrij moeilijk. Bovendien hebben sites de neiging om anti-scraping maatregelen te nemen om hun waardevolle openbare webgegevens te beschermen. Dat vraagt om diensten van derden die u toelaten om betrouwbaar toegang te krijgen tot de inhoud van webpagina's, ongeacht hoe beschermd ze zijn, en ongeacht uw schaalbaarheidsbehoeften. 
 
 
 Web Unlocker API: Een API die elke publieke webpagina moeiteloos opent, blokken, CAPTCHA's, vingerafdrukken en proxy rotatie automatisch verwerkt. Browser API: Een volledig gehost cloudbrowser compatibel met Puppeteer, Selenium, Playwright en andere automatiseringsframeworks, met ingebouwde CAPTCHA-oplossing en geautomatiseerd proxybeheer. Web Unlocker API Web Unlocker API Browsers API Browsers API Web Unlocker is ideaal voor het ophalen van pagina-inhoud, hetzij in rauwe HTML of AI-ready Markdown (a Voor dynamische sites die interactie of automatisering vereisen om toegang te krijgen tot de gegevens die u nodig hebt, is de Browser API de beste oplossing. great data format for LLM ingestion geweldige data-indeling voor LLM ingestie Samen dekken deze twee oplossingen alles wat nodig is voor de “Extract”-fase van een “Search and Extract”-werkstroom. Hoe een zoek- en uittrekselwerkstroom in Python te implementeren Leer hoe u een realistische werkstroom "Zoek en uittrekken" in Python implementeert: 
 
 
 Voor de zoekfase gebruikt u de SERP API van Bright Data om live webzoekopdrachten uit te voeren. Voor de Extract-fase vertrouwt u op de Web Unlocker API om inhoud van de geselecteerde pagina's te downloaden en te analyseren. Volg de introductie hieronder! Voorwaarden Om samen met deze tutorial sectie te volgen, zorg ervoor dat u: 
 
 
 Python 3.9+ is lokaal geïnstalleerd. Een Bright Data-account geconfigureerd met een SERP API-zone en een Web Unlocker API-zone, samen met uw API-sleutel. Als u niet bekend bent met hoe u kunt beginnen met de SERP API of Web Unlocker API-producten van Bright Data, volg dan de officiële documentatie: 
 
 
 Inleiding tot SERP API Inleiding tot de API van Bright Data's Unlocker Inleiding tot SERP API Inleiding tot SERP API Inleiding tot de API van Bright Data's Unlocker Inleiding tot de API van Bright Data's Unlocker Vanaf nu verwijzen we naar uw SERP API-zone als en naar uw Web Unlocker API-zone als : serp_api web_unlocker Zorg er ook voor dat de de zone is geconfigureerd in de modus "Full JSON" in de sectie "Data Format" in de configuratietafel: serp_api Op deze manier retourneert de Bright Data SERP API geanalyseerde SERP-resultaten in JSON-formaat, waardoor ze gemakkelijker te filteren en opnieuw te rangschikken. Ten slotte Dat wordt gebruikt om verzoeken naar de hierboven genoemde diensten te authenticeren! Uw Bright Data API-sleutel genereren Uw Bright Data API-sleutel genereren Om het proces te versnellen, gaan we ervan uit dat u al een Python-project hebt ingesteld met een virtuele omgeving. Stap #1: Bereid je voor op Bright Data Services via API De eenvoudigste manier om verbinding te maken met Bright Data-services is rechtstreeks via de API. Eerst installeert u een asynchrone HTTP-client zoals AIOHTTP: pip install aiohttp
 Definieer vervolgens de volgende twee functies om de SERP API en de Web Unlocker API te bellen, respectievelijk: # Replace these with your Bright Data API token and zone names
BRIGHT_DATA_API_TOKEN = "<YOUR_BRIGHT_DATA_API_TOKEN>"
SERP_ZONE = "serp_api"  # Your SERP API zone
WEB_UNLOCKER_ZONE = "web_unlocker"  # Your Web Unlocker API zone

HEADERS = {
    "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}", # To authenticate the API requests to Bright Data
    "Content-Type": "application/json"
}

async def fetch_serp(session, query, location="us", language="en"):
    url = "https://api.brightdata.com/request"
    data = {
        "zone": SERP_ZONE,
        "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&hl={language}&gl={location}",
        "format": "json"
    }
    async with session.post(url, json=data, headers=HEADERS) as resp:
        response_data = await resp.json()
        return json.loads(response_data["body"])

async def fetch_page(session, page_url, data_format="markdown"):
    url = "https://api.brightdata.com/request"
    data = {
        "zone": WEB_UNLOCKER_ZONE,
        "url": page_url,
        "format": "raw",
        "data_format": data_format
    }
    async with session.post(url, json=data, headers=HEADERS) as resp:
        return await resp.text()
 De de functie verbindt met de Bright Data SERP API om Google-zoekopdrachten uit te voeren en geanalyseerde JSON SERP-resultaten te halen (zoals geconfigureerd in uw account). fetch_serp() op dezelfde manier, verbindt met de Bright Data Web Unlocker API om webpagina's op te halen.Configureert de output als Markdown, wat ideaal is voor inname in LLM's. fetch_page() Voor meer informatie over de argumenten, parameters en hoe deze twee API's te bellen, raadpleeg de docs! : Vermijd in de productie het hardcoderen van uw Bright Data API-sleutel. Note Nu heb je de bouwstenen om de "Zoek" en "Extract" fasen in te voeren De functie: async import asyncio

async def main():
    # "Search and Extract" logic...

# Run the async main function
asyncio.run(main())
 Stap #2: Voer de extractiefase uit Stel dat je AI-agenten hebt die vertrouwen op MCP-integraties en een rapport willen produceren waarin wordt getoond hoe toekomstige veranderingen in het protocol hen kunnen beïnvloeden, welke nieuwe functies beschikbaar zullen zijn, enzovoort. Regelmatige LLM's kunnen niet veel helpen met die taak, omdat MCP relatief nieuw is en de meeste modellen werden getraind op oudere gegevens. "new version of MCP" 
 Bel de SERP API om geanalyseerde Google SERP-resultaten voor die zoekopdracht te downloaden: # Topics to search
input_topic = "new version of MCP"

async with aiohttp.ClientSession() as session:
    # Search phase: Get SERP results
    serp_results = await fetch_serp(session, input_topic)
 Achter de schermen, de Functie roept de SERP API op met behulp van de opgegeven zoekvraag. Als u meerdere queries moet verwerken, kunt u Concurrerend gebruik . fetch_serp() fetch_serp() asyncio.gather() De SERP API geeft standaard 10 resultaten per query, maar kan worden geconfigureerd om maximaal 100 resultaten terug te geven. Note retourneert gepaste Google SERP-resultaten als een Python-woordenboek. Het attribuut: fetch_serp() organic serp_ranking_results = serp_results.get("organic", [])
 De zoekresultaten afdrukken en u moet een soortgelijke output krijgen: Merk op hoe elk element in de matrix precies overeenkomt met het resultaat dat je zou krijgen door te zoeken naar "nieuwe versie van MCP" op Google: Stap #3: Filter de URL's van belangstelling Van alle SERP-resultaten die worden geretourneerd door de SERP API-oproep, veronderstel dat u geïnteresseerd bent in maximaal de top 3 resultaten van de " Laten we ook de oorspronkelijke rangschikking van Google overwegen als de rangschikking die u wilt behouden. modelcontextprotocol.io modelcontextprotocol.io Filter ze als volgt: # Where to store the page URLs to scrape in the "Extract" phase
pages_of_interest = []

# Iterate over results and filter for URLs containing "modelcontextprotocol.io"
for result in serp_data_results:
    page_url = result.get("url")
    if "modelcontextprotocol.io" in page_url:
        pages_of_interest.append(page_url)
    # Stop once reaching 3 results
    if len(page_url) == 3:
        break
 Het resultaat is een lijst met URL's om te worden geopend tijdens de "Extract"-fase. [
  "http://blog.modelcontextprotocol.io/posts/2025-11-25-first-mcp-anniversary/",
  "https://modelcontextprotocol.io/development/roadmap",
  "https://modelcontextprotocol.io/specification/2025-11-25"
]
 Tijd om informatie uit deze pagina's te halen! Stap #4: Voer de extractfase uit Gebruik de Functie om de Web Unlocker API te bellen en de drie geselecteerde pagina's parallel te scrapen: fetch_page() tasks = [fetch_page(session, url) for url in pages_of_interest]
web_page_results = await asyncio.gather(*tasks)
 : Als u te maken heeft met een dynamische site die gebruikersinteractie vereist, extraheren van de gegevens ervan met behulp van een browser automatisering technologie zoals Playwright, geïntegreerd met de Browser API. Note Het resultaat is een matrix met de inhoud van elke doelpagina.Toegang tot de ontgrendelde Markdown-inhoud van elke pagina met: markdown_pages = [page for page in web_page_results]
 Controleer of de matrix daadwerkelijk de Markdown van de doelpagina's bevat: for markdown_page in markdown_pages:
    print(markdown_page[:300] + "...\n---\n")
 In dit geval is de output: Dat komt overeen met de Markdown-versie van elke gerichte pagina, wat betekent dat de Web Unlocker API succesvol webdata-extractie kon uitvoeren, ongeacht eventuele anti-bot- of anti-scraping-maatregelen. Gezien deze verse, contextuele en controleerbare gegevens, sla het op voor verdere analyse, doorgeef het aan een LLM voor verwerking, gebruik het om aanvullende onderwerpen van belang te detecteren, doorgaan met dieper onderzoek, of toepassen op vele andere gebruiksgevallen. Stap #5: Volledige code De definitieve versie van het voorbeeld is: # pip install aiohttp

import asyncio
import aiohttp
import urllib.parse
import json

# Replace these with your Bright Data API token and zone names
BRIGHT_DATA_API_TOKEN = "<YOUR_BRIGHT_DATA_API_KEY>"
SERP_ZONE = "serp_api"  # Your SERP API zone
WEB_UNLOCKER_ZONE = "web_unlocker"  # Your Web Unlocker API zone

HEADERS = {
    "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}", # To authenticate the API requests to Bright Data
    "Content-Type": "application/json"
}

async def fetch_serp(session, query, location="us", language="en"):
    url = "https://api.brightdata.com/request"
    data = {
        "zone": SERP_ZONE,
        "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&hl={language}&gl={location}",
        "format": "json"
    }
    async with session.post(url, json=data, headers=HEADERS) as resp:
        response_data = await resp.json()
        return json.loads(response_data["body"])

async def fetch_page(session, page_url, data_format="markdown"):
    url = "https://api.brightdata.com/request"
    data = {
        "zone": WEB_UNLOCKER_ZONE,
        "url": page_url,
        "format": "raw",
        "data_format": data_format
    }
    async with session.post(url, json=data, headers=HEADERS) as resp:
        return await resp.text()


async def main():
    # Topics to search
    input_topic = "new version of MCP"

    async with aiohttp.ClientSession() as session:
        # Search phase: Get SERP results
        serp_results = await fetch_serp(session, input_topic)

        # Where to store the page URLs to scrape in the "Extract" phase
        pages_of_interest = []

        # Iterate over results and filter for URLs containing "modelcontextprotocol.io"
        for result in serp_results.get("organic", []):
            page_url = result.get("link")
            if page_url and "modelcontextprotocol.io" in page_url:
                pages_of_interest.append(page_url)
            if len(pages_of_interest) == 3:
                break

        print("Pages to scrape:", pages_of_interest)

        # Extract phase: Scrape pages concurrently
        tasks = [fetch_page(session, url) for url in pages_of_interest]
        web_page_results = await asyncio.gather(*tasks)

        # Access the content from each page
        markdown_pages = [page for page in web_page_results]

        print("Scraped page contents:")
        for markdown_page in markdown_pages:
            print(markdown_page[:300] + "...\n---\n")

        # AI processing, RAG pipelines, or further workflows...

# Run the async main function
asyncio.run(main())
 Dankzij Bright Data API-klare producten kunt u een effectieve, bedrijfsklasse, productie-klare werkstroom "Zoek en extraheren" implementeren in minder dan 50 rijen Python-code! Conclusie In dit bericht heb je gekeken waarom data pipelines en AI-werkstromen afhankelijk zijn van up-to-date, contextuele en betrouwbare informatie. Een betrouwbare manier om die gegevens te verzamelen is via de AI-patroon, dat effectief een standaardbenadering is geworden voor toegang tot hoogwaardige, verifieerbare webgegevens. fase automatiseert ontdekking over zoekmachines, terwijl de De fase trekt gestructureerde informatie uit de meest relevante resultaten. Zoeken en extraheren Zoeken Extract ️ Zoals in dit artikel wordt getoond, maakt het gebruik van een AI-ready webscrapingplatform zoals Bright Data de implementatie van deze workflow zowel praktisch als schaalbaar. En ontdek al zijn web data-oplossingen! Start a Bright Data free trial today Starten van een Bright Data gratis proefversie vandaag 
 
 Dit artikel is gepubliceerd via het HackerNoon Business Blogging programma. Dit artikel is gepubliceerd via het HackerNoon Business Blogging programma.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

This writer has a vested interest be it monetary, business, or otherwise, with 1 or more of the products or companies mentioned within.

Portfolio

Deze audio wordt geproduceerd in de originele taal van het verhaal!

Zoeken en extraheren: waarom dit AI-patroon telt, tutorial en voorbeeld

About Author

OPMERKINGEN

LABELS

DIT ARTIKEL WERD GEPRESENTEERD IN

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps