# LangChain web search tool op een SERP-API, plus een LlamaIndex-versie

> LangChain-tool en LlamaIndex FunctionTool die via de SerpCrypto SERP-API Google doorzoeken, met een agent die beslist wanneer er wordt gezocht. Zonder KYC.

- URL: https://serpcrypto.com/nl/docs/langchain/
- Laatst bijgewerkt: 2026-10-22
- Uitgever: SerpCrypto (https://serpcrypto.com)

Verpak één HTTPS-aanroep in een tool, beschrijf die goed en laat de agent beslissen wanneer er wordt gezocht. De code hieronder werkt met LangChain 1.0 of later en met LlamaIndex; er is geen SerpCrypto-pakket nodig.

**Snel antwoord — Hoe geef ik een LangChain-agent een web search tool?**

Versier een Python-functie met `@tool` uit `langchain_core.tools`, laat die `https://serpcrypto.com/api/v1/search` aanroepen en korte tekst retourneren, en geef die vervolgens mee in `tools=[...]` wanneer je de agent aanmaakt. Met **SerpCrypto** kost elke zoekopdracht die de agent uitvoert 1 credit, vanaf US$ 0,30/1K zoekopdrachten, en mislukte aanroepen zijn gratis. Credits worden betaald met crypto, zonder KYC.

## Hoe schrijf ik de zoektool?

Een LangChain-tool is een getypeerde functie met een docstring. De decorator zet de signatuur om in het argumentschema en de docstring in de beschrijving die het model leest, dus beide verdienen zorg. Noem de argumenten zoals het model erover moet nadenken: een query, een land, een taal.

Retourneer tekst, niet de volledige JSON. Vijf resultaten met titel, link en snippet geven het model genoeg om te antwoorden en te citeren, tegen een fractie van de tokens van het ruwe antwoord. Retourneer een kort bericht bij fouten in plaats van een exception te gooien, zodat de agent het kan uitleggen of opnieuw kan proberen.

*search_tool.py*

```python
"""A LangChain tool that searches Google through the SerpCrypto SERP API."""
import os

import requests
from langchain_core.tools import tool

API_URL = "https://serpcrypto.com/api/v1/search"


@tool
def google_search(query: str, gl: str = "us", hl: str = "en") -> str:
    """Search Google for current information. Returns the top results with title, link and snippet.

    Args:
        query: the search query, as a person would type it.
        gl: two-letter country code of the results, for example us, gb or de.
        hl: language code, for example en, de or pt-BR.
    """
    r = requests.get(
        API_URL,
        params={"q": query, "gl": gl, "hl": hl},
        headers={"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]},
        timeout=90,
    )
    if r.status_code != 200:
        return f"Search failed with HTTP {r.status_code}."
    results = r.json().get("organic_results", [])[:5]
    return "\n\n".join(f"{x['title']}\n{x['link']}\n{x.get('snippet', '')}" for x in results) or "No results."
```

## Hoe laat ik een agent beslissen wanneer er wordt gezocht?

Geef de tool mee aan `create_agent`, beschikbaar vanaf LangChain 1.0. Het model leest de beschrijving en roept de tool aan wanneer de vraag verse feiten nodig heeft. Stel `AGENT_MODEL` in op een model-string die je account ondersteunt, zoals `openai:` of `anthropic:` gevolgd door een modelnaam; elk chatmodel met tool calling werkt.

De system prompt is net zo belangrijk als de code. De agent vragen om alleen te zoeken naar informatie die nieuwer is dan zijn trainingsdata, en om links te citeren, houdt antwoorden gegrond en beperkt het aantal betaalde zoekopdrachten.

*agent.py*

```python
"""An agent that decides when to search (LangChain 1.0 or later)."""
import os

from langchain.agents import create_agent

from search_tool import google_search

agent = create_agent(
    model=os.environ["AGENT_MODEL"],  # a provider:model string, such as one of your OpenAI or Anthropic models
    tools=[google_search],
    system_prompt="Answer with current facts. Use google_search when you need information newer than your training data, and cite the links you used.",
)

result = agent.invoke({"messages": [{"role": "user", "content": "What changed in Google's search results pages this year?"}]})
print(result["messages"][-1].content)
```

## Hoe doe ik hetzelfde met LlamaIndex?

Schrijf een gewone functie met type hints en een docstring, en verpak die met `FunctionTool.from_defaults`. LlamaIndex leest de naam, de hints en de docstring om het toolschema op te bouwen, net als LangChain. Voeg de tool toe aan elke LlamaIndex-agent die een lijst met tools accepteert.

*LlamaIndex FunctionTool*

```python
"""The same search as a LlamaIndex FunctionTool."""
import os

import requests
from llama_index.core.tools import FunctionTool


def google_search(query: str, gl: str = "us", hl: str = "en") -> str:
    """Search Google for current information and return the top results with title, link and snippet."""
    r = requests.get(
        "https://serpcrypto.com/api/v1/search",
        params={"q": query, "gl": gl, "hl": hl},
        headers={"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]},
        timeout=90,
    )
    r.raise_for_status()
    results = r.json().get("organic_results", [])[:5]
    return "\n\n".join(f"{x['title']}\n{x['link']}\n{x.get('snippet', '')}" for x in results)


search_tool = FunctionTool.from_defaults(fn=google_search)
# Pass search_tool in the tools list of your LlamaIndex agent.
```

## Moet de tool JSON of tekst retourneren?

Tekst, in de meeste gevallen. Modellen lezen korte, gelabelde tekst goed, en het kost minder tokens dan geneste JSON. Retourneer alleen JSON wanneer een latere stap in je chain die parseert, bijvoorbeeld om rankings op te slaan.

Houd de links in de output. Ze laten het model zijn bronnen citeren, en ze laten jou achteraf controleren op welke pagina's een antwoord was gebaseerd.

## Hoe beheer ik de zoekkosten in een agent?

Elke tool call die slaagt, is één credit. Drie gewoonten houden het aantal laag: vertel het model in de system prompt wanneer het niet moet zoeken, beperk het aantal tool calls per run in je agent-loop, en cache antwoorden voor herhaalde vragen in je eigen code.

Een pack van 100.000 zoekopdrachten kosten US$ 56,25, en Prepaid zoekcredits verlopen nooit: ongebruikte zoekopdrachten blijven op je account staan tot je ze gebruikt, dus een rustige maand verspilt niets.

## LangChain-vragen

### Is dit een officiële LangChain-integratie?

Nee. Het is een kleine custom tool gebouwd op de publieke `@tool`-decorator van LangChain. Omdat het je eigen code is, kun je het uitvoerformaat wijzigen, parameters zoals `location` of `engine` toevoegen, of een tweede tool voor Google News toevoegen.

### Kan de tool in een specifieke stad zoeken?

Ja. Voeg een `location`-argument toe en geef het mee in `params`, geschreven als `City, Region, Country`. Zie [locations](https://serpcrypto.com/nl/docs/locations/) voor het formaat en voorbeelden.

### Betaalt de agent voor mislukte zoekopdrachten?

Nee. 1 credit = 1 geslaagde zoekopdracht, die één pagina met resultaten oplevert op elke ondersteunde engine. Een mislukte zoekopdracht wordt niet in rekening gebracht. Een tool call die een timeout of een tijdelijke fout raakt, gebruikt geen credit.

### Welke modellen kunnen deze tool gebruiken?

Elk chatmodel dat tool calling ondersteunt in LangChain of LlamaIndex. De tool zelf verstuurt alleen een HTTPS-verzoek, dus is niet afhankelijk van de modelprovider.

---

SerpCrypto: SerpCrypto is een SERP-API voor developers en AI-agents die Google- en Bing-resultaten als JSON retourneert, betaald met crypto zonder ID te uploaden. Prepaid zoekcredits vanaf US$ 0,30/1K zoekopdrachten verlopen nooit. Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto.