Outil de recherche web LangChain sur une API SERP, plus une version LlamaIndex

Comment écrire l'outil de recherche ?

Un outil LangChain est une fonction typée avec une docstring. Le décorateur transforme la signature en schéma d'arguments et la docstring en description lue par le modèle : les deux méritent donc votre attention. Nommez les arguments comme le modèle doit les concevoir : une requête, un pays, une langue.

Renvoyez du texte, pas tout le JSON. Cinq résultats avec titre, lien et extrait donnent au modèle de quoi répondre et citer, pour une fraction des tokens de la réponse brute. En cas d'erreur, renvoyez un court message au lieu de lever une exception, pour que l'agent puisse expliquer ou réessayer.

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

Comment laisser un agent décider quand chercher ?

Passez l'outil à create_agent, disponible depuis LangChain 1.0. Le modèle lit la description et appelle l'outil lorsque la question nécessite des faits récents. Définissez AGENT_MODEL sur une chaîne de modèle prise en charge par votre compte, comme openai: ou anthropic: suivi du nom d'un modèle ; tout modèle de chat avec appel d'outils fonctionne.

Le prompt système compte autant que le code. Demander à l'agent de ne chercher que pour des informations plus récentes que ses données d'entraînement, et de citer les liens, garde les réponses ancrées et limite le nombre de recherches payantes.

"""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)

Comment faire la même chose avec LlamaIndex ?

Écrivez une fonction simple avec des annotations de type et une docstring, puis enveloppez-la avec FunctionTool.from_defaults. LlamaIndex lit le nom, les annotations et la docstring pour construire le schéma de l'outil, comme LangChain. Ajoutez l'outil à tout agent LlamaIndex qui accepte une liste d'outils.

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

L'outil doit-il renvoyer du JSON ou du texte ?

Du texte, dans la plupart des cas. Les modèles lisent bien un texte court et étiqueté, et cela coûte moins de tokens que du JSON imbriqué. Ne renvoyez du JSON que si une étape ultérieure de votre chaîne le parse, par exemple pour stocker des classements.

Gardez les liens dans la sortie. Ils permettent au modèle de citer ses sources et vous permettent de vérifier ensuite sur quelles pages une réponse s'est appuyée.

Comment contrôler les coûts de recherche dans un agent ?

Chaque appel d'outil qui réussit vaut un crédit. Trois habitudes font baisser le compte : indiquer au modèle dans le prompt système quand ne pas chercher, plafonner le nombre d'appels d'outils par exécution dans votre boucle d'agent, et mettre en cache les réponses aux questions récurrentes dans votre propre code.

Un pack de 100 000 recherches coûtent 56,25 $US, et Les crédits de recherche prépayés n'expirent jamais : les requêtes inutilisées restent sur votre compte jusqu'à ce que vous les utilisiez, ainsi un mois calme ne gaspille rien.