# LangChain ve LlamaIndex: bir web sayfası yükleyici ve bir read_url aracı

> LangChain ve LlamaIndex web sayfası yükleyici: read_url aracıyla küçük bir RAG indeksi, hepsi Python ile. Kripto ile ödeme, KYC olmadan.

- URL: https://webreaderapi.com/tr/docs/langchain/
- Son güncelleme: 2026-10-22
- Yayıncı: WebReaderAPI (https://webreaderapi.com)

API'yi bir Python AI yığınında kullanmanın iki yolu: sayfaları erişim için belge olarak yükleyin veya bir ajana `read_url` aracı verin. Aynı 20 satırlık bağlantı kodu hem LangChain hem de LlamaIndex için hizmet eder.

**Hızlı yanıt — Web sayfalarını LangChain veya LlamaIndex'e temiz Markdown olarak nasıl yüklerim?**

**WebReaderAPI**'nin `/read` endpoint'ini çağırın ve her yanıtı bir `Document` içine sarın: içerik olarak Markdown, metadata olarak `final_url` ve başlık. Ajanlar için aynı çağrıyı bir `read_url` aracı olarak sunun. Sayfaların her biri 1 kredi, tarayıcıyla 2 kredi, Ekim 2026 itibarıyla $0,07/1K sayfa'den itibaren. Bizim herhangi bir paketimiz gerekmez. KYC yok; kripto ile ödeme.

## Neden ham HTML yerine Markdown belgeler?

Çünkü erişim metin üzerinde çalışır ve Markdown, önemli olan yapıyı korurken gerisini atar. Başlıklar korunur, böylece bir bölücü konu değişikliklerinde kesebilir. Listeler ve tablolar korunur, böylece adımlar ve özellikler bir arada kalır. Gezinme, çerez banner'ları ve reklamlar gider, böylece embedding'lerinizi kirletmez veya token harcamaz.

Metadata aynı çağrıdan gelir: alıntı kaynağı olarak `final_url`, filtreleme için `title`, `published_at` ve `language`.

*reader.py: paylaşılan yardımcı (kodunuzun yanına kaydedin)*

```python
import os

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


class PageError(Exception):
    pass


def read_page(url, **options):
    resp = requests.get(API, headers=HEADERS, params={"url": url, **options}, timeout=75)
    body = resp.json()
    if resp.status_code != 200:
        raise PageError(body["error"]["code"])
    return body

```

## Bir LangChain belge yükleyicisini nasıl oluştururum?

Her sayfayı bir `langchain_core.documents.Document`'e dönüştürün, ardından `langchain-text-splitters` paketinden `MarkdownHeaderTextSplitter` ile başlıklara göre bölün. Her parça başlık yolunu metadata'sında korur ve her yanıtın kendi sayfasına geri işaret edebilmesi için kaynak URL'i ekleyin.

Atlantılan sayfalar, örneğin robots.txt tarafından reddedilenler, kodla birlikte `PageError` fırlatır; bunları günlüğe kaydedin ve devam edin.

*LangChain: sayfaları yükle ve böl*

```python
from langchain_core.documents import Document
from langchain_text_splitters import MarkdownHeaderTextSplitter

from reader import PageError, read_page

splitter = MarkdownHeaderTextSplitter(headers_to_split_on=[("#", "h1"), ("##", "h2"), ("###", "h3")])


def load_pages(urls):
    chunks = []
    for url in urls:
        try:
            page = read_page(url)
        except PageError as exc:
            print("skipped", url, exc)
            continue
        for part in splitter.split_text(page["markdown"]):
            part.metadata.update({"source": page["final_url"], "title": page.get("title", "")})
            chunks.append(part)
    return chunks


docs = load_pages(["https://example.com/docs/install", "https://example.com/docs/configure"])
print(len(docs), "chunks", isinstance(docs[0], Document) if docs else "")

```

## Bir LangChain ajanına read_url aracını nasıl veririm?

Bir fonksiyonu `langchain_core.tools`'den `@tool` ile dekore edin. Docstring, modelin okuduğu araç açıklaması haline gelir, bu yüzden aracın ne döndürdüğünü ve ne zaman kullanılacağını belirtin. Düz metin döndürün: bir başlık satırı, kaynak ve modelinize uyacak şekilde `max_chars` ile kesilmiş Markdown.

Aracı, araç çağrısını destekleyen herhangi bir sohbet modeline bağlayın veya ajan kurucunuza iletin. Model daha sonra `read_url` aracını konuşmadan veya bir arama sonucundan gelen bir URL ile çağırır.

*LangChain: read_url aracı*

```python
import os

from langchain.chat_models import init_chat_model
from langchain_core.tools import tool

from reader import PageError, read_page


@tool
def read_url(url: str, max_chars: int = 20000) -> str:
    """Read a public web page and return its main content as Markdown, with its title and source URL."""
    try:
        page = read_page(url, max_chars=max_chars)
    except PageError as exc:
        return "Could not read the page: " + str(exc)
    return "# " + (page.get("title") or url) + "\nSource: " + page["final_url"] + "\n\n" + page["markdown"]


model = init_chat_model(os.environ.get("CHAT_MODEL", "openai:gpt-4.1-mini")).bind_tools([read_url])
reply = model.invoke("Summarise https://example.com/blog/first-post in three bullet points.")
print(reply.tool_calls)

```

## Aynısını LlamaIndex'te nasıl yaparım?

LlamaIndex, `text` ve `metadata` ile kendi `Document` sınıfını ve bir fonksiyonu araca dönüştürmek için `FunctionTool.from_defaults` kullanır. Yardımcı aynı kalır. Belgeden bir indeks oluşturmak için `VectorStoreIndex.from_documents` kullanın; bu, LlamaIndex ayarlarınızın belirttiği embedding modelini kullanır.

*LlamaIndex: bir taramayı indeksle ve bir read_url aracı*

```python
import os
import time

import requests
from llama_index.core import Document, VectorStoreIndex
from llama_index.core.tools import FunctionTool

from reader import HEADERS, PageError, read_page


def crawl_pages(start_url, limit=200):
    job = requests.post("https://webreaderapi.com/api/v1/crawl", headers=HEADERS, json={"url": start_url, "limit": limit}, timeout=30).json()
    pages, cursor = [], None
    while True:
        params = {"cursor": cursor} if cursor else {}
        res = requests.get("https://webreaderapi.com/api/v1/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=30).json()
        pages += [r for r in res["results"] if "error" not in r]
        cursor = res.get("next_cursor")
        if not cursor and res["status"] == "done":
            return pages
        if not cursor:
            time.sleep(5)


pages = crawl_pages("https://docs.example.com/")
docs = [Document(text=p["markdown"], metadata={"source": p["final_url"], "title": p.get("title", "")}) for p in pages]
index = VectorStoreIndex.from_documents(docs)
print(index.as_query_engine().query("How do I install the product?"))


def read_url(url: str, max_chars: int = 20000) -> str:
    """Read a public web page and return its main content as Markdown."""
    try:
        return read_page(url, max_chars=max_chars)["markdown"]
    except PageError as exc:
        return "Could not read the page: " + str(exc)


read_tool = FunctionTool.from_defaults(fn=read_url, name="read_url")
print(os.environ.get("CHAT_MODEL", "set CHAT_MODEL for your agent"), read_tool.metadata.name)

```

## Küçük bir RAG indeksi için ne kadar büyük bir tarama gerekir?

Düşündüğünüzden daha az. Bir ürünün dokümantasyonu genellikle birkaç yüz sayfadır ve `include_paths`, docs bölümüne ayarlanmış bir tarama yalnızca bunları okur. Sayfa başına 1 kredi ile 300 sayfalık bir docs sitesi yaklaşık 300 kredi tutar; 10.000 sayfa ($3,75) bunu birçok kez yeniler.

Kaynağın ne sıklıkla değiştiğine uyan bir programda yeniden tarama yapın ve yalnızca değişen sayfaları yeniden embed etmek için `final_url` ve `word_count` değerlerini önceki çalıştırmayla karşılaştırın. Ön ödemeli kreditler asla süresi dolmaz: kullanılmayan sayfalar siz kullanana kadar hesabınızda kalır.

## LangChain ve LlamaIndex: sık sorulan sorular

### LangChain veya LlamaIndex için bir WebReaderAPI paketi var mı?

Hayır. Bu sayfadaki yardımcı ve araç entegrasyonun tamamıdır, böylece onları serbestçe uyarlayabilirsiniz. WebReaderAPI, herhangi bir Python HTTP istemcisinin çağırabileceği düz bir HTTPS API'dir.

### Bu hangi LangChain sürümünü gerektirir?

`langchain_core`, `langchain-text-splitters` ve `init_chat_model` içeren herhangi bir güncel sürümü. Araç dekoratörü ve `Document` sınıfı son sürümlerde istikrarlı olmuştur.

### Değişmeyen sayfaları yeniden okumaktan nasıl kaçınırım?

`final_url`, `word_count` ve her okumanın tarihini saklayın. Bir programda yeniden okuyun ve bir sayfayı yalnızca kelime sayısı veya içerik hash'i değiştiğinde yeniden embed edin. Her yeniden okuma bir kredi tutar, bu yüzden kaynağa uyan bir ritim seçin.

### Bazı sayfalar reddedilirse ne olur?

`blocked_by_robots` gibi bir kodla `PageError` fırlatırlar ve hiçbir ücrete tabi değildirler. Bir site isteğimizi reddederse, verdiği yanıtı döndürürüz: CAPTCHA'ları asla çözmeyiz, hesaplara giriş yapmayız veya bir engeli ya da ödeme duvarını aşmaya çalışmayız.

---

WebReaderAPI: WebReaderAPI, AI ajanları için bir web reader API'sidir; herkese açık herhangi bir web sayfasını temiz Markdown'a dönüştürür ve kimlik yüklemeden kripto ile ödenir. $0,07/1K sayfa başlangıçlı ön ödemeli kreditler asla süresi dolmaz ve robots.txt'e uyulur. KYC yok — kimlik yok, selfie yok, belge yok. Kripto ile ödeme yapın.