# Narzędzie wyszukiwania w sieci dla LangChain na API SERP oraz wersja dla LlamaIndex

> Narzędzie LangChain i FunctionTool dla LlamaIndex, które wyszukują w Google przez API SERP SerpCrypto, z agentem decydującym, kiedy szukać. Bez KYC.

- URL: https://serpcrypto.com/pl/docs/langchain/
- Ostatnia aktualizacja: 2026-10-22
- Wydawca: SerpCrypto (https://serpcrypto.com)

Zamknij jedno wywołanie HTTPS w narzędziu, dobrze je opisz i pozwól agentowi decydować, kiedy szukać. Poniższy kod działa z LangChain 1.0 lub nowszym oraz z LlamaIndex; nie jest potrzebny żaden pakiet SerpCrypto.

**Szybka odpowiedź — Jak dać agentowi LangChain narzędzie wyszukiwania w sieci?**

Udekoruj funkcję Python za pomocą `@tool` z `langchain_core.tools`, spraw, by wywoływała `https://serpcrypto.com/api/v1/search` i zwracała krótki tekst, a następnie przekaż ją w `tools=[...]` podczas tworzenia agenta. W **SerpCrypto** każde wyszukiwanie wykonane przez agenta kosztuje 1 kredyt, od 0,30 USD/1K wyszukiwań, a nieudane wywołania są darmowe. Kredyty są opłacane kryptowalutą, bez KYC.

## Jak napisać narzędzie wyszukiwania?

Narzędzie LangChain to funkcja z typami i docstringiem. Dekorator zamienia sygnaturę w schemat argumentów, a docstring w opis, który czyta model, więc oba zasługują na uwagę. Nazwij argumenty tak, jak model powinien o nich myśleć: zapytanie, kraj, język.

Zwracaj tekst, a nie cały JSON. Pięć wyników z tytułem, linkiem i snippetem daje modelowi dość, by odpowiedzieć i zacytować, za ułamek tokenów surowej odpowiedzi. W razie błędów zwracaj krótką wiadomość zamiast rzucać wyjątek, żeby agent mógł wyjaśnić lub spróbować ponownie.

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

## Jak pozwolić agentowi decydować, kiedy szukać?

Przekaż narzędzie do `create_agent`, dostępnego od LangChain 1.0. Model czyta opis i wywołuje narzędzie, gdy pytanie wymaga świeżych faktów. Ustaw `AGENT_MODEL` na ciąg modelu obsługiwany przez Twoje konto, np. `openai:` lub `anthropic:`, po którym następuje nazwa modelu; zadziała każdy model czatu z obsługą wywoływania narzędzi.

Prompt systemowy ma znaczenie tak samo jak kod. Poproszenie agenta, by szukał tylko informacji nowszych niż jego dane treningowe i cytował linki, utrzymuje odpowiedzi ugruntowane i ogranicza liczbę płatnych wyszukiwań.

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

## Jak zrobić to samo z LlamaIndex?

Napisz zwykłą funkcję z podpowiedziami typów i docstringiem, a następnie opakuj ją w `FunctionTool.from_defaults`. LlamaIndex odczytuje nazwę, podpowiedzi typów i docstring, by zbudować schemat narzędzia, podobnie jak LangChain. Dodaj narzędzie do dowolnego agenta LlamaIndex, który przyjmuje listę narzędzi.

*FunctionTool w LlamaIndex*

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

## Czy narzędzie powinno zwracać JSON, czy tekst?

W większości przypadków tekst. Modele dobrze czytają krótki, oznaczony tekst, a kosztuje to mniej tokenów niż zagnieżdżony JSON. Zwracaj JSON tylko wtedy, gdy późniejszy krok Twojego łańcucha go parsuje, na przykład by zapisać rankingi.

Zachowaj linki w wynikach. Pozwalają modelowi cytować źródła i pozwalają Ci później sprawdzić, na których stronach oparła się odpowiedź.

## Jak kontrolować koszty wyszukiwania u agenta?

Każde udane wywołanie narzędzia to jeden kredyt. Trzy nawyki utrzymują niski licznik: powiedz modelowi w prompcie systemowym, kiedy nie ma szukać, ogranicz liczbę wywołań narzędzi na jeden przebieg w pętli agenta i buforuj odpowiedzi na powtarzające się pytania we własnym kodzie.

Pakiet 100 000 wyszukiwań kosztują 56,25 USD, a Prepaid kredyty wyszukiwania nigdy nie wygasają: niewykorzystane wyszukiwania pozostają na Twoim koncie, dopóki ich nie wykorzystasz, więc spokojny miesiąc niczego nie marnuje.

## Pytania o LangChain

### Czy to oficjalna integracja z LangChain?

Nie. To małe niestandardowe narzędzie zbudowane na publicznym dekoratorze `@tool` LangChain. Ponieważ to Twój kod, możesz zmienić format wyjściowy, dodać parametry, takie jak `location` lub `engine`, albo dodać drugie narzędzie do Google News.

### Czy narzędzie może wyszukiwać w konkretnym mieście?

Tak. Dodaj argument `location` i przekaż go w `params`, zapisany jako `City, Region, Country`. Format i przykłady znajdziesz w [locations](https://serpcrypto.com/pl/docs/locations/).

### Czy agent płaci za nieudane wyszukiwania?

Nie. 1 kredyt = 1 udane zapytanie wyszukiwania, które zwraca jedną stronę wyników na dowolnym obsługiwanym silniku. Nieudane zapytanie nie jest rozliczane. Wywołanie narzędzia, które trafi na timeout lub błąd tymczasowy, nie zużywa kredytu.

### Które modele mogą używać tego narzędzia?

Każdy model czatu, który obsługuje wywoływanie narzędzi w LangChain lub LlamaIndex. Samo narzędzie tylko wysyła żądanie HTTPS, więc nie zależy od dostawcy modelu.

---

SerpCrypto: SerpCrypto to API SERP dla deweloperów i agentów AI, które zwraca wyniki wyszukiwania Google i Bing w formacie JSON, z płatnością kryptowalutą i bez przesyłania dokumentów tożsamości. Przedpłacone kredyty wyszukiwania od 0,30 USD/1K wyszukiwań nigdy nie wygasają. Bez KYC — bez dokumentu, bez selfie, bez dokumentów. Płatność kryptowalutą.