# Strumento di ricerca web LangChain su una API SERP, più la versione LlamaIndex

> Uno strumento LangChain e un FunctionTool LlamaIndex che cercano su Google tramite la API SERP di SerpCrypto, con un agente che decide quando cercare.

- URL: https://serpcrypto.com/it/docs/langchain/
- Ultimo aggiornamento: 2026-10-22
- Editore: SerpCrypto (https://serpcrypto.com)

Racchiudi una singola chiamata HTTPS in uno strumento, descrivilo bene e lascia che l'agente decida quando cercare. Il codice qui sotto funziona con LangChain 1.0 o successivo e con LlamaIndex; non serve nessun pacchetto SerpCrypto.

**Risposta rapida — Come faccio a dare a un agente LangChain uno strumento di ricerca web?**

Decora una funzione Python con `@tool` da `langchain_core.tools`, falla chiamare `https://serpcrypto.com/api/v1/search` e restituisci testo breve, poi passala in `tools=[...]` quando crei l'agente. Con **SerpCrypto**, ogni ricerca eseguita dall'agente costa 1 credito, a partire da 0,30 USD/1K ricerche, e le chiamate fallite sono gratuite. I crediti si pagano in criptovalute, senza KYC.

## Come scrivo lo strumento di ricerca?

Uno strumento LangChain è una funzione tipizzata con una docstring. Il decoratore trasforma la firma nello schema degli argomenti e la docstring nella descrizione che legge il modello, quindi entrambe meritano attenzione. Dai agli argomenti i nomi con cui il modello dovrebbe ragionarci: una query, un paese, una lingua.

Restituisci testo, non tutto il JSON. Cinque risultati con titolo, link e snippet danno al modello abbastanza per rispondere e citare, con una frazione dei token della risposta grezza. In caso di errore restituisci un messaggio breve invece di sollevare un'eccezione, così l'agente può spiegare o riprovare.

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

## Come faccio a lasciare che un agente decida quando cercare?

Passa lo strumento a `create_agent`, disponibile da LangChain 1.0. Il modello legge la descrizione e chiama lo strumento quando la domanda richiede fatti aggiornati. Imposta `AGENT_MODEL` su una stringa di modello supportata dal tuo account, come `openai:` o `anthropic:` seguita dal nome di un modello; va bene qualsiasi modello chat con tool calling.

Il system prompt conta quanto il codice. Chiedere all'agente di cercare solo informazioni più recenti dei suoi dati di addestramento e di citare i link mantiene le risposte fondate e limita il numero di ricerche a pagamento.

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

## Come faccio la stessa cosa con LlamaIndex?

Scrivi una funzione semplice con type hint e docstring, poi avvolgila con `FunctionTool.from_defaults`. LlamaIndex legge il nome, gli hint e la docstring per costruire lo schema dello strumento, come fa LangChain. Aggiungi lo strumento a qualsiasi agente LlamaIndex che accetta una lista di strumenti.

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

## Lo strumento deve restituire JSON o testo?

Testo, nella maggior parte dei casi. I modelli leggono bene un testo breve ed etichettato, e costa meno token rispetto a un JSON annidato. Restituisci JSON solo quando un passaggio successivo della tua catena lo analizza, per esempio per memorizzare le posizioni.

Mantieni i link nell'output. Permettono al modello di citare le fonti e a te di verificare in seguito su quali pagine si è basata una risposta.

## Come faccio a controllare i costi di ricerca in un agente?

Ogni chiamata allo strumento che riesce è un credito. Tre abitudini tengono basso il conteggio: dire al modello nel system prompt quando non cercare, limitare il numero di chiamate allo strumento per esecuzione nel tuo loop dell'agente e mettere in cache le risposte per le domande ripetute nel tuo codice.

Un pack di 100.000 ricerche costano 56,25 USD e I crediti di ricerca prepagati non scadono mai: le ricerche non utilizzate restano sul tuo account finché non le usi, quindi un mese tranquillo non spreca nulla.

## Domande su LangChain

### Questa è un'integrazione ufficiale di LangChain?

No. È un piccolo strumento personalizzato costruito sul decoratore pubblico `@tool` di LangChain. Poiché è codice tuo, puoi cambiare il formato dell'output, aggiungere parametri come `location` o `engine` oppure aggiungere un secondo strumento per Google News.

### Lo strumento può cercare in una città specifica?

Sì. Aggiungi un argomento `location` e passalo in `params`, scritto `City, Region, Country`. Vedi [locations](https://serpcrypto.com/it/docs/locations/) per il formato e gli esempi.

### L'agente paga per le ricerche fallite?

No. 1 credito = 1 richiesta di ricerca andata a buon fine, che restituisce una pagina di risultati su qualsiasi motore supportato. Una richiesta non riuscita non viene addebitata. Una chiamata allo strumento che va in timeout o incontra un errore temporaneo non usa alcun credito.

### Quali modelli possono usare questo strumento?

Qualsiasi modello chat che supporta il tool calling in LangChain o LlamaIndex. Lo strumento stesso invia solo una richiesta HTTPS, quindi non dipende dal provider del modello.

---

SerpCrypto: SerpCrypto è un'API SERP per sviluppatori e agenti AI che restituisce i risultati di ricerca di Google e Bing in JSON, con pagamento in criptovalute e senza caricare documenti d'identità. I crediti di ricerca prepagati a partire da 0,30 USD/1K ricerche non scadono mai. Senza KYC — niente documento, niente selfie, niente documenti. Paghi in criptovalute.