Überspringen zum Inhalt
DE
API-Schlüssel

Workflows / Python

Hinzufügen von Google und YouTube-Suchtools zu einem AI-Agenten

Wrap Such- und Transkriptanfragen als Python-Tools, bewahren Sie die Quellenreferenzen und lassen Sie Ihren Agenten auswählen, wann Sie Daten abrufen möchten.

FlashData · Veröffentlicht

Ein Agent, der mit Web-Such- und Videodaten-Tools verbunden ist

Definieren Sie die Werkzeuggrenze

Geben Sie Ihrem Agenten kleine Tools mit klaren Ein- und Ausgängen: Durchsuchen Sie das Web, discover-Videos und lesen Sie das verfügbare Transkript eines Videos. Ihr Agent entscheidet, wann er sie anrufen und wie er die Beweise verwenden soll.

Der unten stehende Code liefert die Abruffunktionen. Registrieren Sie sie mit Ihrem vorhandenen Agenten-Framework; Sie arbeiten unabhängig davon, welches Modell oder welche Orchestrierungsbibliothek Sie wählen.

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

Implementieren Sie die Retrieval Tools

Der folgende Python 3-Code verwendet die Standardbibliothek. Speichern Sie es als tools.py. Wenn Sie es direkt ausführen, wird eine Google-Suche angefordert; Wenn Sie es importieren, können Sie die drei Funktionen als Tools registrieren.

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

Verbinden Sie die Tools mit Ihrem Agenten

Beschreiben Sie die Argumente und Ergebnisse jedes Tools im Toolschema Ihres Frameworks. Bleiben query, video_id und language als explizite Eingaben, damit das Modell die benötigten Daten anfordern kann.

  • search_web(query) Gibt Google Ergebnisse mit Quelle URLs und Snippets zurück.

  • find_videos(query) Gibt Videos und IDs zurück, die für Folgeanfragen benötigt werden.

  • read_video_transcript(video_id, language) Gibt verfügbare Beschriftungssegmente mit Zeitstempeln zurück.

Geben Sie nützliche Toolfehler zurück, wenn eine Anforderung fehlschlägt oder ein Untertitel nicht verfügbar ist. Tragen Sie die Kredit- und Anforderungsbudgets Ihrer Anwendung auf und lassen Sie den Agenten entscheiden, ob er eine andere Abfrage ausprobieren oder eine andere Quelle verwenden möchte.

Bewahren Sie Quellen und Zeitstempel auf

Ein Such-Snippet ist eine Vorschau einer Seite. Bewahren Sie seinen URL auf und vermeiden Sie es, das Snippet als vollständigen Artikel zu behandeln. Für Transkripte behalten Sie das Video ID, Sprache und Segmentzeiten, damit der Agent die ursprüngliche Passage zitieren kann.

Speichern Sie für eine Video-Wissensdatenbank den Videotitel und den zeitgestempelten Quelllink mit jedem Textblock. Ihr Abrufsystem kann dann sowohl den Inhalt als auch die Referenz zurückgeben, die zur Unterstützung einer Antwort verwendet werden.