# LangChain Web Search Tool auf einer SERP-API, plus eine LlamaIndex-Version

> LangChain-Tool und LlamaIndex FunctionTool durchsuchen Google über die SerpCrypto SERP-API, mit einem Agenten, der entscheidet, wann gesucht wird. Ohne KYC.

- URL: https://serpcrypto.com/de/docs/langchain/
- Zuletzt aktualisiert: 2026-10-22
- Herausgeber: SerpCrypto (https://serpcrypto.com)

Packen Sie einen HTTPS-Aufruf in ein Tool, beschreiben Sie es gut, und lassen Sie den Agenten entscheiden, wann gesucht wird. Der Code unten funktioniert mit LangChain 1.0 oder neuer und mit LlamaIndex; ein SerpCrypto-Paket wird nicht benötigt.

**Kurze Antwort — Wie gebe ich einem LangChain-Agenten ein Web-Search-Tool?**

Dekorieren Sie eine Python-Funktion mit `@tool` aus `langchain_core.tools`, lassen Sie sie `https://serpcrypto.com/api/v1/search` aufrufen und kurzen Text zurückgeben, und übergeben Sie sie dann beim Erstellen des Agenten in `tools=[...]`. Mit **SerpCrypto** kostet jede Suche des Agenten 1 Credit, ab 0,30 $/1K Suchanfragen, und fehlgeschlagene Aufrufe sind kostenlos. Credits werden mit Krypto bezahlt, ohne KYC.

## Wie schreibe ich das Such-Tool?

Ein LangChain-Tool ist eine typisierte Funktion mit Docstring. Der Dekorator macht aus der Signatur das Argument-Schema und aus dem Docstring die Beschreibung, die das Modell liest – beide verdienen Sorgfalt. Benennen Sie die Argumente so, wie das Modell über sie denken soll: eine Suchanfrage, ein Land, eine Sprache.

Geben Sie Text zurück, nicht das ganze JSON. Fünf Ergebnisse mit Titel, Link und Snippet geben dem Modell genug zum Antworten und Zitieren, zu einem Bruchteil der Tokens der Rohantwort. Geben Sie bei Fehlern eine kurze Meldung zurück, statt eine Exception auszulösen, damit der Agent erklären oder es erneut versuchen kann.

*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."
```

## Wie lasse ich einen Agenten entscheiden, wann gesucht wird?

Übergeben Sie das Tool an `create_agent`, verfügbar ab LangChain 1.0. Das Modell liest die Beschreibung und ruft das Tool auf, wenn die Frage frische Fakten braucht. Setzen Sie `AGENT_MODEL` auf einen Modell-String, den Ihr Konto unterstützt, etwa `openai:` oder `anthropic:` gefolgt von einem Modellnamen; jedes Chat-Modell mit Tool Calling funktioniert.

Der System-Prompt ist genauso wichtig wie der Code. Wenn Sie den Agenten auffordern, nur nach Informationen zu suchen, die neuer als seine Trainingsdaten sind, und Links zu zitieren, bleiben Antworten fundiert und die Zahl der bezahlten Suchen begrenzt.

*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)
```

## Wie mache ich dasselbe mit LlamaIndex?

Schreiben Sie eine einfache Funktion mit Type Hints und Docstring und wickeln Sie sie mit `FunctionTool.from_defaults` ein. LlamaIndex liest den Namen, die Hints und den Docstring, um das Tool-Schema zu erstellen, genau wie LangChain. Fügen Sie das Tool zu jedem LlamaIndex-Agenten hinzu, der eine Liste von Tools akzeptiert.

*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.
```

## Soll das Tool JSON oder Text zurückgeben?

In den meisten Fällen Text. Modelle lesen kurzen, beschrifteten Text gut, und er kostet weniger Tokens als verschachteltes JSON. Geben Sie JSON nur zurück, wenn ein späterer Schritt Ihrer Chain es parst, etwa um Rankings zu speichern.

Behalten Sie die Links in der Ausgabe. Sie lassen das Modell seine Quellen zitieren, und Sie können im Nachhinein prüfen, auf welche Seiten sich eine Antwort gestützt hat.

## Wie kontrolliere ich die Suchkosten in einem Agenten?

Jeder erfolgreiche Tool-Aufruf ist ein Credit. Drei Gewohnheiten halten die Zahl niedrig: Sagen Sie dem Modell im System-Prompt, wann es nicht suchen soll, begrenzen Sie die Zahl der Tool-Aufrufe pro Lauf in Ihrer Agenten-Schleife und cachen Sie Antworten auf wiederkehrende Fragen in Ihrem eigenen Code.

Ein Pack mit 100.000 Suchanfragen kosten 56,25 $, und Vorausbezahlte Such-Credits verfallen nie: ungenutzte Suchen bleiben auf Ihrem Konto, bis Sie sie verwenden, ein ruhiger Monat verschwendet also nichts.

## Fragen zu LangChain

### Ist das eine offizielle LangChain-Integration?

Nein. Es ist ein kleines eigenes Tool, das auf dem öffentlichen `@tool`-Dekorator von LangChain aufbaut. Da es Ihr Code ist, können Sie das Ausgabeformat ändern, Parameter wie `location` oder `engine` hinzufügen oder ein zweites Tool für Google News ergänzen.

### Kann das Tool eine bestimmte Stadt durchsuchen?

Ja. Fügen Sie ein `location`-Argument hinzu und übergeben Sie es in `params`, geschrieben als `City, Region, Country`. Format und Beispiele finden Sie unter [Locations](https://serpcrypto.com/de/docs/locations/).

### Zahlt der Agent für fehlgeschlagene Suchen?

Nein. 1 Credit = 1 erfolgreiche Suchanfrage, die eine Ergebnisseite auf jeder unterstützten Engine liefert. Eine fehlgeschlagene Anfrage wird nicht berechnet. Ein Tool-Aufruf, der auf ein Timeout oder einen temporären Fehler trifft, verbraucht keinen Credit.

### Welche Modelle können dieses Tool nutzen?

Jedes Chat-Modell, das Tool Calling in LangChain oder LlamaIndex unterstützt. Das Tool selbst sendet nur eine HTTPS-Anfrage und hängt daher nicht vom Modell-Anbieter ab.

---

SerpCrypto: SerpCrypto ist eine SERP-API für Entwickler und KI-Agenten, die Google- und Bing-Ergebnisse als JSON zurückgibt und mit Krypto bezahlt wird, ohne Ausweisupload. Vorausbezahlte Such-Credits ab 0,30 $/1K Suchanfragen verfallen nie. Ohne KYC — kein Ausweis, kein Selfie, keine Dokumente. Mit Krypto bezahlen.