Aller au contenu
FR
Obtenir une clé API

Flux de travail / Python

Ajouter des outils de recherche Google et YouTube à un agent IA

Exposez la recherche et la récupération de transcriptions comme outils Python, conservez les références des sources et laissez votre agent décider quand récupérer les données.

FlashData · Publié

Un agent connecté à des outils de recherche web et de données vidéo

Définir le rôle de chaque outil

Donnez à votre agent des outils ciblés, avec des entrées et des sorties claires : rechercher sur le Web, trouver des vidéos et lire une transcription disponible. L’agent choisit quand les appeler et comment exploiter les sources.

Le code ci-dessous fournit les fonctions de récupération des données. Enregistrez-les dans votre framework d’agents ; elles sont indépendantes du modèle et de la bibliothèque d’orchestration utilisés.

bash
# Replace YOUR_API_KEY near the top of the code below.

Implémenter les outils de récupération

Le code Python 3 suivant utilise la bibliothèque standard. Enregistrez-le dans tools.py. Son exécution directe lance une recherche Google ; son import permet à votre application d’enregistrer les trois fonctions comme outils.

python
import json
import gzip
import os
import urllib.error
import urllib.request

API_URL = "https://data.flashdata.dev"
API_KEY = "YOUR_API_KEY"


def api_request(path, payload=None, response_headers=None, base_url=API_URL):
    target = path if path.startswith(("https://", "http://")) else base_url + path
    request = urllib.request.Request(
        target,
        data=json.dumps(payload).encode() if payload is not None else None,
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        method="POST" if payload is not None else "GET",
    )
    with urllib.request.urlopen(request, timeout=60) as response:
        if response_headers is not None:
            response_headers.update(response.headers)
        return json.load(response)


class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, request, file_pointer, code, message, headers, new_url):
        return None


def result_request(url):
    request = urllib.request.Request(url, headers={"X-API-Key": API_KEY}, method="GET")
    try:
        with urllib.request.build_opener(NoRedirect).open(request, timeout=60):
            raise RuntimeError("Results endpoint did not redirect to storage")
    except urllib.error.HTTPError as response:
        if response.code != 302 or not response.headers.get("Location"):
            raise
        storage_url = response.headers["Location"]
        response.close()
    storage_request = urllib.request.Request(storage_url, headers={"Accept-Encoding": "gzip"})
    with urllib.request.urlopen(storage_request, timeout=60) as response:
        body = response.read()
        if response.headers.get("Content-Encoding") == "gzip":
            body = gzip.decompress(body)
        return json.loads(body)["results"]


def search_web(query):
    """Search the web and return titles, URLs and result snippets."""
    response = api_request("/v1/queries/realtime", {
        "source": "google_search", "query": query,
    })
    return response["results"][0]


def find_videos(query):
    """Discover YouTube videos and their video IDs."""
    response = api_request("/v1/queries/realtime", {
        "source": "youtube_search", "query": query,
        "params": {"max_results": 5},
    })
    return response["results"][0]["results"]


def read_video_transcript(video_id, language="en"):
    """Read available captions with timestamps; captions may be unavailable."""
    response = api_request("/v1/queries/realtime", {
        "source": "youtube_transcript", "video_id": video_id,
        "params": {"language": language, "auto": True},
    })
    return response["results"][0]


# Register these functions as tools in your own agent framework.
# The agent chooses when to call them and how to use the evidence.
if __name__ == "__main__":
    print(json.dumps(search_web("distributed systems"), indent=2))
bash
python3 tools.py

Connecter les outils à votre agent

Décrivez les arguments et les résultats de chaque outil dans le schéma de votre framework. Gardez query, video_id et language comme entrées explicites pour que le modèle puisse demander les données nécessaires.

  • search_web(query) renvoie les résultats Google avec les URL des sources et des extraits.

  • find_videos(query) renvoie les vidéos et leurs ID pour les requêtes complémentaires.

  • read_video_transcript(video_id, language) renvoie les segments de sous-titres disponibles avec leurs horodatages.

Renvoyez une erreur d’outil utile lorsqu’une requête échoue ou qu’une piste de sous-titres est absente. Appliquez les budgets de crédits et de requêtes de votre application, puis laissez l’agent choisir une autre recherche ou une autre source.

Conserver les sources et les horodatages

Un extrait de recherche donne un aperçu d’une page. Conservez son URL et ne le traitez pas comme l’article complet. Pour les transcriptions, conservez l’ID vidéo, la langue et les horodatages des segments afin que l’agent puisse citer le passage d’origine.

Pour une base de connaissances vidéo, associez à chaque fragment de texte le titre de la vidéo et un lien horodaté vers la source. Votre système de recherche pourra ainsi renvoyer le contenu et la référence qui étaye la réponse.