De flesta AI-agenter, ML-rörledningar, AI-berikande arbetsflöden, djupforskningssystem och datadrivna beslutsmotorer misslyckas inte eftersom modellerna är dåliga. Specifikt tenderar data att vara föråldrade, utanför sammanhanget, overifierbara, eller alla tre på en gång. Det är kärnproblemet. I den här artikeln kommer du att se vad faktiskt betyder, hur det fungerar under locket, varför det spelar roll mer än de flesta tror, och hur man implementerar det end-to-end med ett konkret exempel! Sök och extrahera Behovet av färsk, kontextuell och pålitlig, verifierbar information Enligt Statista genereras cirka 402,74 miljoner terabyte data varje dag. Att data strömmar in i webben, data lager, analytics stacks, och pipelines i en skala som ärligt talat svårt att argumentera om. Men här är fångsten: mer data betyder inte bättre data! Vid den volymen är det orealistiskt att anta att allt återspeglar verkligheten - eller att det till och med kan lita på i första hand ... Företag fattar fortfarande affärsbeslut, automatisering och AI-driven samtal baserat på och data. Det där Och när källan är föråldrad, ofullständig eller helt enkelt fel ... insikterna byggda på den kan inte vara tillförlitliga. Detta är exakt varför LLMs hallucinerar, AI-agenter ger övertygande men felaktiga svar, och data pipelines tyst misslyckas i produktionen. I de flesta verkliga fall är problemet inte modellen, verktyget eller implementeringen. Oavsett om du kör ett klassiskt analysarbetsflöde eller en helt autonom AI-agent beror allt på kvaliteten på källdata. 
 
 
 
 Färska Kontextuellt Verifiera När allt kommer omkring, om du inte vet Uppgifterna kommer från eller det samlades, du kan inte realistiskt lita på resultatet. Vart När Det är den verkliga frågan. 
 
 Hur kan du på ett tillförlitligt sätt hämta information som är aktuell, relevant för en viss uppgift och bevisligen kopplad till källan? Hur kan du på ett tillförlitligt sätt hämta information som är aktuell, relevant för en viss uppgift och bevisligen kopplad till källan? Det är där den Pattern kommer in! låt oss bryta ner det. Search and Extract Sök och extrakt: Vad det är och varför det är lösningen ”Search and Extract” är en process för att hämta aktuell, verifierbar och kontextrik information från webben . Det är enkelt i struktur, men extremt effektivt i praktiken. De facto standard På en hög nivå fungerar den i två separata steg: 
 
 
 Sök: Systemet utför en live webbsökning på sökmotorer som Google för att hitta de mest relevanta och tillförlitliga källorna för en given fråga. Utdrag: Från sökresultaten identifierar systemet de mest relevanta webbadresserna, besöker dessa sidor och hämtar det mest användbara innehållet eller data från dem. Detta kan inkludera fakta, statistik, definitioner eller strukturerad information analyserad från sidan. Detta mönster är särskilt användbart i AI-relaterade applikationer, såsom AI-agenter, , och företagsklass AI-arbetsflöden. Det är också tillämpligt på traditionella maskininlärning, fakta-kontroll och data berikning pipelines. agentic RAG systems Agentiska RAG-system Det slutliga målet med mönstret "Sök och extrahera" är att ta itu med de moderna datautmaningarna genom att säkerställa att den insamlade informationen är: 
 
 
 
 Färsk , eftersom den skrapade offentliga webbdata kommer från senaste webbsökningar, som kan innehålla den senaste informationen och nyheterna. Kontextuell, eftersom informationen är nära anpassad till de ämnen som anges i sökfrågan. Verifierbar , eftersom data kommer direkt från specifika webbsidor, med webbadresser som vem som helst kan besöka och kontrollera. Hur fungerar sökning och utvinning? På en hög nivå kan "Sök och extrahera" sammanfattas med följande arbetsflöde: Inmatningen för detta arbetsflöde är en lista över sökbara ämnen. Dessa extraheras i allmänhet kontextuellt från dokument, datamängder eller givna informationskällor med hjälp av AI/ML. Det är vad som vanligtvis förekommer i AI-berikning, dataverifiering, RAG-arbetsflöden eller djupforskningsapplikationer. Oavsett källan skickas de sökbara ämnena till "Sök" -komponenten, där en SERP-API-lösning utför automatiserade webbsökningar på de målbaserade sökmotorerna.Efter att ha hämtat sökresultaten kan du antingen överväga alla returnerade webbsidor eller filtrera endast de mest relevanta med hjälp av AI / ML eller strikta regler (t.ex. hålla sidor från specifika domäner, språk eller andra kriterier). När du riktar flera sökfrågor samtidigt (oavsett om det är olika frågor eller flera sidor för samma fråga) kan du behöva köra en anpassad omrankningsalgoritm. Rankingen som tillhandahålls av Google eller någon sökmotor är optimerad för SEO, vilket kanske inte återspeglar vad som är viktigt för ditt användningsfall. De valda URL-adresserna skickas sedan till "Extrakt" -noden, där en webbskrapningstjänst får åtkomst till varje sida och extraherar huvudinformationen. Nästa, låt oss utforska de tjänster som kommer in i spelet i "Sök" och "Utvinna" faser, respektive! Sök Sökmotorer som Google, Bing, DuckDuckGo, Baidu och Yandex skyddar sina SERPs (Search Engine Results Pages) med prisgränser och CAPTCHAs för att förhindra automatisk skrapning. Det mest tillförlitliga sättet att utföra "Sök" -fasen är genom att använda en SERP API-lösning.Dessa tjänster exponerar slutpunkter för att utlösa sökuppgifter i molnet med hjälp av infrastruktur som är utformad för att hantera skalbarhet och anti-bot-åtgärder för dig. Det stöder globala sökningar via ett proxy-nätverk med mer än 150 miljoner IP-adresser i 195 länder, kan returnera fullständigt analyserade SERP-data i JSON, erbjuder många sidoringsalternativ och stöder integration i alla data eller ML-rörledningar med hjälp av standard HTTP-förfrågningar, samt över 50+ AI-agentramar och arbetsflöden. Serp API för Bright Data Serp API för Bright Data Plus, Bright Data's SERP API låter dig köra ett obegränsat antal sökfrågor parallellt. Detta innebär att du kan hämta tusentals resultat under "Sök" -fasen. Sedan kan du filtrera och omklassificera dem enligt dina behov i de senare stegen av den övergripande "Sök och extrahera" -processen (som nämnts tidigare). Utställning ️ Webbdatautvinning är den svårare delen. Anledningen är att varje webbplats är annorlunda, och även sidor inom samma domän kan följa olika rendering, data-visualisering och hämtningslogik. Detta gör programmatiskt åtkomst till deras innehåll ganska svårt. Det kräver tredjepartstjänster som låter dig på ett tillförlitligt sätt komma åt innehållet på webbsidor, oavsett hur skyddade de är och oavsett dina skalbarhetsbehov.I detta avseende är Bright Data en av de bästa leverantörerna av webbskrapningslösningar på marknaden, tack vare verktyg som: 
 
 
 Web Unlocker API: En API som får åtkomst till alla offentliga webbsidor utan ansträngning, hanterar block, CAPTCHAs, fingeravtryck och proxy rotation automatiskt. Webbläsare API: En fullt värd moln webbläsare som är kompatibel med Puppeteer, Selenium, Playwright och andra automationsramverk, med inbyggd CAPTCHA-lösning och automatiserad proxyhantering. Web Unlocker API för webben Web Unlocker API för webben Webbläsare API Webbläsare API Web Unlocker är idealisk för att hämta sidinnehåll, antingen i rå HTML eller AI-klar Markdown (en För dynamiska webbplatser som kräver interaktion eller automatisering för att komma åt de data du behöver, är Browser API bättre lämpad. great data format for LLM ingestion bra dataformat för LLM ingestion Tillsammans täcker dessa två lösningar allt som krävs för "Utvinna" -fasen i ett arbetsflöde "Sök och Utvinna". Hur man implementerar en sökning och extrahera arbetsflöde i Python Lär dig hur du implementerar ett realistiskt "Sök och extrahera" arbetsflöde i Python: 
 
 
 För sökfasen kommer du att använda Bright Data's SERP API för att köra levande webbsökningar. För extraktfasen kommer du att förlita dig på Web Unlocker API för att hämta och analysera innehåll från de valda sidorna. Följ introduktionen nedanför! Förutsättningar För att följa tillsammans med denna tutorial avsnitt, se till att du har: 
 
 
 Python 3.9+ installerat lokalt. Ett Bright Data-konto konfigurerat med en SERP API-zon och en Web Unlocker API-zon, tillsammans med din API-nyckel. Om du inte är bekant med hur du börjar med Bright Data SERP API eller Web Unlocker API-produkter, följ den officiella dokumentationen: 
 
 
 Introduktion till SERP API Introduktion till Bright Data's Unlocker API Introduktion till SERP API Introduktion till SERP API Introduktion till Bright Data's Unlocker API Introduktion till Bright Data's Unlocker API Från och med nu hänvisar vi till din SERP API-zon som och till din Web Unlocker API-zon som : serp_api web_unlocker Dessutom, se till att den zonen är konfigurerad i "Full JSON" -läge i avsnittet "Data Format" i konfigurationstabellen: serp_api På så sätt kommer Bright Data SERP API att returnera analyserade SERP-resultat i JSON-format, vilket gör dem lättare att filtrera och omrankning. och slutligen, Det kommer att användas för att autentisera förfrågningar till de tjänster som nämns ovan! Generera din Bright Data API-nyckel Generera din Bright Data API-nyckel För att påskynda processen antar vi att du redan har ett Python-projekt installerat med en virtuell miljö på plats. Steg #1: Förbered dig på att komma åt Bright Data Services via API Det enklaste sättet att ansluta till Bright Data-tjänster är direkt via dess API. Först installera en asynkroniserad HTTP-klient som AIOHTTP: pip install aiohttp
 Därefter definierar följande två funktioner för att ringa SERP API och Web Unlocker API, respektive: # 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()
 den Funktionen ansluter till Bright Data SERP API för att utföra Google-sökningar och hämta parade JSON SERP-resultat (som konfigurerats i ditt konto). fetch_serp() på samma sätt, Ansluter till Bright Data Web Unlocker API för att hämta webbsidor. Konfigurera utgången som Markdown, vilket är idealiskt för intag i LLMs. fetch_page() För mer information om argumenten, parametrarna och hur man ringer de två API: erna, se dokumenten! : I produktion, undvik hårdkodning din Bright Data API-nyckel. istället, ladda den från en miljövariabel. Note Nu har du byggstenarna för att implementera "Sök" och "Utvinna" faserna i Funktioner : async import asyncio

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

# Run the async main function
asyncio.run(main())
 Steg #2: Utför extraktfasen Anta att du har AI-agenter som förlitar sig på MCP-integrationer och vill producera en rapport som visar hur framtida ändringar i protokollet kan påverka dem, vilka nya funktioner som kommer att vara tillgängliga, och så vidare. Vanliga LLMs kan inte hjälpa mycket med den uppgiften, eftersom MCP är relativt ny och de flesta modellerna utbildades på äldre data. "new version of MCP" 
 Ring SERP API för att hämta parsade Google SERP-resultat för den sökfrågan: # 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)
 Bakom kulisserna, den funktionen ringer SERP API med hjälp av den angivna sökfrågan. Om du behöver hantera flera frågor kan du ringa Konkurrerande användning . fetch_serp() fetch_serp() asyncio.gather() Som standard returnerar SERP-API 10 resultat per fråga, men kan konfigureras för att returnera upp till 100 resultat. Note returnerar analyserade Google SERP-resultat som en Python-ordbok. Åtkomst till rankningen med hjälp av och attribut: fetch_serp() organic serp_ranking_results = serp_results.get("organic", [])
 Skriv ut sökresultaten, och du bör få en utgång som liknar detta: Observera hur varje element i matrisen motsvarar exakt det resultat du skulle få genom att söka efter "ny version av MCP" på Google: Steg #3: Filtrera webbadresser av intresse Av alla SERP-resultat som returneras av SERP API-samtalet, anta att du är intresserad av upp till de 3 bästa resultaten från " ” domän (det officiella domänen för MCP-specifikationen).Låt oss också överväga Googles ursprungliga ranking som den ranking du vill bevara. modellkontextprotokoll.io modellkontextprotokoll.io Filtrera dem som följer: # 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
 Resultatet blir en lista över webbadresser som du kan komma åt under ”Utvinna”-fasen. I det här fallet är de identifierade webbadresserna: [
  "http://blog.modelcontextprotocol.io/posts/2025-11-25-first-mcp-anniversary/",
  "https://modelcontextprotocol.io/development/roadmap",
  "https://modelcontextprotocol.io/specification/2025-11-25"
]
 Dags att extrahera information från dessa sidor! Steg #4: Utför extraktionsfasen Använd den Funktionen för att ringa till Web Unlocker API och skrapa de tre valda sidorna parallellt: fetch_page() tasks = [fetch_page(session, url) for url in pages_of_interest]
web_page_results = await asyncio.gather(*tasks)
 Om du har att göra med en dynamisk webbplats som kräver användarinteraktion, extrahera data från den med hjälp av en webbläsarautomationsteknik som Playwright, integrerad med webbläsarens API. Note Resultatet blir en matris som innehåller innehållet på varje målsida. Åtkomst till det låsta Markdown-innehållet från varje sida med: markdown_pages = [page for page in web_page_results]
 Kontrollera att arrayet faktiskt innehåller markdown av målsidorna: for markdown_page in markdown_pages:
    print(markdown_page[:300] + "...\n---\n")
 I detta fall är utgången: Det motsvarar markdown-versionen av varje riktad sida, vilket innebär att Web Unlocker API kunde utföra webbdatautvinning framgångsrikt, oavsett eventuella anti-bot eller anti-skrapning åtgärder på plats. Med tanke på denna färska, kontextuella och verifierbara data, lagra den för vidare analys, skicka den till en LLM för bearbetning, använd den för att upptäcka ytterligare ämnen av intresse, fortsätta med djupare forskning eller tillämpa den på många andra användningsfall. Steg #5: Komplett kod Den slutliga versionen av exemplet är: # 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())
 Tack vare Bright Data API-färdiga produkter kan du implementera ett effektivt, företagsklass, produktionsfärdigt "Sök och extrahera" arbetsflöde i mindre än 50 rader Python-kod! Slutsats I det här inlägget tittade du på varför data pipelines och AI-arbetsflöden är beroende av aktuell, kontextuell och tillförlitlig information. Ett tillförlitligt sätt att samla in dessa data är genom AI-mönster, som effektivt har blivit en standardmetod för att få tillgång till högkvalitativa, verifierbara webbdata. fas automatiserar upptäckt över sökmotorer, medan fas drar strukturerad information från de mest relevanta resultaten. Sök och extrahera Sök Utställning ️ Som visas i hela den här artikeln, med hjälp av en AI-klar webbskrapplattform som Bright Data gör implementeringen av detta arbetsflöde både praktisk och skalbar. och utforska alla sina webdatalösningar! Starta en Bright Data gratis provperiod idag Starta en Bright Data gratis provperiod idag 
 
 Den här artikeln publiceras via HackerNoon Business Blogging program. Den här artikeln publiceras via HackerNoon Business Blogging program.

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

Det här ljudet är producerat på berättelsens originalspråk!

Sök och extrahera: Varför detta AI-mönster spelar roll, handledning och exempel

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps