Web Crawling Data Connecting Guide to RAG

"Wir möchten einen AI-Chatbot erstellen, der auf unsere Unternehmensdaten antwortet." - Solche Anfragen hören wir heutzutage sehr oft. ChatGPT mag intelligent sein, aber um ihn basierend auf unseren firmeneigenen aktuellen Daten antworten zu lassen, benötigen wir RAG. Und letztendlich hängt die Leistung von RAG von der Datenqualität ab.

In diesem Artikel wird der gesamte Prozess der Verbindung von mit Web-Crawling gesammelten Daten mit dem RAG-Pipeline mit praktischem Code zusammengefasst.

Inhaltsverzeichnis

• Was ist RAG?
• Gesamter Pipelinefluss
• Schritt 1: Crawling - Sammeln von Rohdaten
• Schritt 2: Chunking - Aufteilen von Texten in angemessene Größen
• Schritt 3: Einbetten + Speichern in Vektordatenbank
• Schritt 4: RAG-Abfrage - Fragen an LLM
• Datenqualität beeinflusst die Leistung von RAG
• Integration von Hashscraper MCP + LangChain
• Abschluss

Was ist RAG?

RAG (Retrieval-Augmented Generation) bedeutet einfach "Suche + Generierung".

Bevor LLM eine Antwort generiert, durchsucht es zuerst externe Datenbanken nach relevanten Dokumenten, um Kontext bereitzustellen. Dadurch kann GPT aktuelle Informationen, interne Dokumente und domänenspezifische Daten nutzen, um Halluzinationen erheblich zu reduzieren.

Der Schlüssel hierbei ist: LLM ist intelligent, aber es weiß nicht alles. RAG ist eine Struktur, die LLM durch Suche ergänzt, um das "Nichtwissen" auszugleichen.

Gesamter Pipelinefluss

Der Gesamtfluss der RAG-Pipeline besteht aus 5 Schritten:

웹 크롤링 → 텍스트 청킹 → 임베딩 변환 → 벡터DB 저장 → LLM 쿼리

Wir werden jeden Schritt mit Code genauer betrachten.

Schritt 1: Crawling - Sammeln von Rohdaten

Der Ausgangspunkt von RAG sind die Daten. Produktinformationen, Nachrichten, technische Dokumente und Community-Beiträge, die im Web gesammelt wurden, können alle als Quellen für RAG dienen.

Hierbei ist die Extraktion sauberer Texte wichtig. Wenn HTML-Tags, Werbung und Navigationsmenüs in die Daten eingemischt werden, leidet die Leistung von RAG erheblich.

import requests
from bs4 import BeautifulSoup

def crawl_page(url):
    """단순 크롤링 예시 — 실전에서는 봇 차단, JS 렌더링 등 고려 필요"""
    response = requests.get(url, headers={
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
    })
    soup = BeautifulSoup(response.text, "html.parser")

    # 본문 텍스트만 추출 (네비게이션, 광고 등 제거)
    for tag in soup(["nav", "header", "footer", "script", "style", "aside"]):
        tag.decompose()

    text = soup.get_text(separator="\n", strip=True)
    return text

Aber die Realität ist nicht so einfach. Bei Single-Page-Anwendungen, Seiten, die eine Anmeldung erfordern, und Websites, die Bot-Blockaden haben, stoßen wir mit einfachen Anfragen an Grenzen.

Schritt 2: Chunking - Aufteilen von Texten in angemessene Größen

Wenn Sie ein gesamtes Dokument einbetten, sinkt die Genauigkeit der Suche. Es ist entscheidend, den Text in angemessene Chunks aufzuteilen.

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # 청크당 최대 500자
    chunk_overlap=50,      # 청크 간 50자 겹침 (문맥 유지)
    separators=["\n\n", "\n", ". ", " "]  # 분할 우선순위
)

documents = splitter.split_text(crawled_text)
print(f"총 {len(documents)}개 청크 생성")

Chunking-Tipps:
- Zu klein führt zu Kontextverlust, zu groß verringert die Suchgenauigkeit
- Für koreanische Texte zeigen 500-800 Zeichen pro Chunk in der Regel gute Leistung
- Vermeiden Sie das Zerschneiden von Sätzen, indem Sie chunk_overlap einstellen

Schritt 3: Einbetten + Speichern in Vektordatenbank

Wandeln Sie die Chunks in Vektoren (Zahlenarrays) um und speichern Sie sie in einer Vektordatenbank. Hier verwenden wir die Kombination aus OpenAI Embeddings und ChromaDB.

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

# 임베딩 모델 초기화
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# 벡터DB에 저장
vectorstore = Chroma.from_texts(
    texts=documents,
    embedding=embeddings,
    collection_name="crawled_data",
    persist_directory="./chroma_db"
)

print(f"{len(documents)}개 청크를 벡터DB에 저장 완료")

Andere Vektordatenbanken (Pinecone, Weaviate, Qdrant usw.) können ebenfalls über die gleiche Schnittstelle in LangChain verwendet werden.

Schritt 4: RAG-Abfrage - Fragen an LLM

Wenn eine Benutzerfrage eingeht, werden relevante Dokumente aus der Vektordatenbank gesucht und zusammen mit dem Kontext an LLM übergeben.

from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

# LLM 설정
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# RAG 체인 구성
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# 질문하기
answer = qa_chain.invoke("이 제품의 최신 가격은 얼마인가요?")
print(answer["result"])

Hinweis: RetrievalQA ist die Legacy-Chain-Schnittstelle von LangChain. In der neuesten Version wird die RAG-Konfiguration auf Basis von LangGraph empfohlen, aber zur Veranschaulichung wird hier diese intuitivere Methode verwendet.

Das ist der gesamte Fluss von RAG. Crawling → Chunking → Einbetten → Vektordatenbank → LLM-Abfrage. Die Struktur selbst ist einfach.

Datenqualität beeinflusst die Leistung von RAG

Der am meisten unterschätzte Bereich in RAG ist die Qualität der Eingabedaten.

Selbst mit einem guten Einbettungsmodell und LLM führt schmutzige Eingabe zu einem schlechten Ergebnis. Tatsächlich entstehen die meisten Leistungsprobleme von RAG nicht durch das Modell, sondern durch Datenprobleme.

Häufige Datenqualitätsprobleme:
- Vermischung von Navigations- und Seitenleistentexten mit dem Haupttext → Rauschen bei der Suche
- Unvollständiges Crawling (JavaScript-Rendering fehlgeschlagen) → Fehlende Schlüsselinformationen
- Duplizierte Daten → Verzerrte Suchergebnisse
- Kodierungsfehler, Sonderzeichnungsfehler → Beeinträchtigung der Einbettungsqualität

Müll rein, Müll raus. Die Sicherung sauberer Daten während des Crawling-Schritts bestimmt den Erfolg der gesamten RAG-Pipeline.

Integration von Hashscraper MCP + LangChain

Wenn Sie Ihren eigenen Crawler erstellen, werden Sie Zeit für Nebenprobleme wie Bot-Blockaden, JS-Rendering und Proxy-Verwaltung aufwenden. Durch die Nutzung des MCP (Model Context Protocol) Servers von Hashscraper können Sie sich auf die RAG-Pipeline konzentrieren, ohne sich um das Crawling-Setup kümmern zu müssen.

# 해시스크래퍼 MCP를 LangChain Document Loader로 활용하는 예시
from langchain_core.documents import Document
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

# 해시스크래퍼 API로 데이터 수집 — 봇 차단 사이트도 OK
import requests

response = requests.post(
    "https://api.hashscraper.com/api/scrape",
    json={
        "url": "https://target-site.com/products",
        "format": "markdown"            # markdown 또는 text
    },
    headers={
        "X-API-Key": "YOUR_API_KEY",
        "Content-Type": "application/json; version=2"
    }
).json()

# LangChain Document로 변환
docs = [
    Document(
        page_content=response["data"]["content"],
        metadata={
            "url": response["data"]["url"],
            "title": response["data"]["title"]
        }
    )
]

# 이후는 동일: 청킹 → 임베딩 → 벡터DB → RAG
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)
vectorstore = Chroma.from_documents(chunks, embeddings)

Gründe für die Verwendung von Hashscraper als RAG-Datenquelle:
- Stabile Extraktion sauberer Texte auch von Bot-Blockade-Websites
- Automatisierung von JavaScript-Rendering, Anmeldungsprozessen
- Integriertes Proxy-Management, IP-Rotation - keine Notwendigkeit, sich um die Infrastruktur zu kümmern
- Strukturierte Datenausgabe → Verbesserung der Chunking-/Einbettungsqualität

Abschluss

Die RAG-Pipeline ist strukturell einfach. Aber in der Praxis hängt die Leistung letztendlich von der Qualität der Datenerfassung in der ersten Phase ab.

Anstatt Zeit für die Erstellung und Wartung eines Crawlers zu investieren, kann es effizienter sein, sich auf die RAG-Logik zu konzentrieren, indem man eine validierte Crawling-Infrastruktur verwendet.

Wenn Sie eine RAG-Pipeline auf der Grundlage von Crawling-Daten aufbauen müssen, erhalten Sie bei Hashscraper Beratung. Wir helfen Ihnen von der Datenerfassung bis zur Integration von KI auf der Grundlage unserer praktischen Erfahrung.