Ga naar de inhoud
NL
API-sleutel ophalen
Documentatie bekijken

Handleidingen

Resultaten opslaan en hergebruiken

Houd een resultaat met zijn oorspronkelijke invoer, bron links en gebruik, dan overhandig het aan een ander proces zonder een andere query.

Op deze pagina

Eenmaal opvragen, het resultaat gebruiken in verschillende taken

Maak een rapport, heronderzoek je parser of geef een latere agent hetzelfde bewijs. Deze workflow slaat één zoekopdracht op als een draagbaar archief; het lezen van dat archief heeft noch een FlashData-sleutel, noch de oorspronkelijke CLI-status nodig.

Wat je zult houden
archive/saved-search/
  request.json originele query en parameters
  response.json onveranderd API-respons
  citations.ndjson titels, bron URLs en knipsels
  manifest.json draait ID, gebruik, bestandsgroottes en SHA-256

Voordat u begint

Gebruik een nieuwe werkmap, de FlashData CLI met google_search toestemming en beschikbare credits. Hergebruik een geauthentiseerd profiel of FLASHDATA_API_KEY. Bash-inspectie gebruikt jq; Windows gebruikt PowerShell 7. De lokale archiefscripts gebruiken Python 3.10+ en de standaardbibliotheek.

Ga verder wanneer data.accessVerified true is. Voor CLI retries, houd hetzelfde profiel, OS gebruiker en state directory. Een agent moet zijn bestaande geloofwaardigheid uit zijn geheime winkel laden.

Controleer uw opgeslagen toegang
flashdata auth status --json

1. Houd de invoer en sla één antwoord op

Spaar request.json hieronder op en voer dan één commando uit. --input gebruikt dit exacte verzoek; houd het bestand daarna ongewijzigd. --output slaat de API body op in search.json; --json print CLI metadata. saved-search is de lokale run ID van deze taak.

request.json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
Een zoekopdracht uitvoeren
flashdata query --input request.json \
  --run-id saved-search --output search.json --json

2. Het opgeslagen antwoord valideren

Verwacht bron: google_search, status: done en een resultatenreeks. Print de titel, link en knipsel van elk biologisch resultaat. De werkelijke resultaten variëren; een lege succesvolle collectie is anders dan een mislukt verzoek of een ontbrekend veld.

Valideren en lezen van search.json
jq -e '.source == "google_search" and .status == "done"
  and (.results | type == "array")
  and all(.results[]; (.organic | type == "array"))' search.json > /dev/null &&
jq -c '.results[] | .organic[] | {title, link, snippet}' search.json

3. Archiveer de invoer, reactie en citaten

Sla archive.py hieronder op en voer het uit met de ID van stap 1. Het bewaart de ruwe bestanden, haalt bron links en schrijft manifest.json laatste met bestand controlesums en gebruik. Verwacht complete: true; het aantal citaties hangt af van de zoekresultaten. Er worden geen netwerkverzoeken gedaan.

archive.py opslaan

Maak archive.py naast request.json en search.json in uw werkmap. Kopieer de volledige code hieronder in het en sla het op.

Het voorbeeld archiveert Google Search resultaten. Bestaande archiefmappen worden intact gehouden. Houd request.json, search.json en de bijbehorende run samen totdat archivering voltooid is.

archive.py
# archive.py — Python 3.10+, standard library only; no network requests.
import argparse
import hashlib
import json
import re
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlsplit

parser = argparse.ArgumentParser()
parser.add_argument('--run-id', required=True)
args = parser.parse_args()
if not re.fullmatch(r'[A-Za-z0-9_-]+', args.run_id):
    raise ValueError('Use the CLI run ID from this task.')
request_bytes = Path('request.json').read_bytes()
result_bytes = Path('search.json').read_bytes()
request = json.loads(request_bytes.decode('utf-8-sig'))
result = json.loads(result_bytes.decode('utf-8-sig'))
if (request.get('source') != 'google_search' or result.get('source') != request['source']
        or result.get('status') not in ['done', 'completed']
        or not isinstance(result.get('results'), list)):
    raise ValueError('Inspect the request and result before archiving.')
citations = []
for page in result['results']:
    if not isinstance(page, dict) or not isinstance(page.get('organic'), list):
        raise ValueError('Expected an organic results array, including when it is empty.')
    for item in page['organic']:
        if not isinstance(item, dict) or not isinstance(item.get('link'), str):
            raise ValueError('A result is missing its source URL.')
        url = urlsplit(item['link'])
        if url.scheme not in ['http', 'https'] or not url.netloc:
            raise ValueError('Inspect an unexpected source URL.')
        citations.append({key: item.get(key, '') for key in ['title', 'link', 'snippet']})
files = {'request.json': request_bytes, 'response.json': result_bytes,
         'citations.ndjson': ''.join(json.dumps(row, ensure_ascii=False) + '\n'
                                    for row in citations).encode('utf-8')}
manifest = {'version': 1, 'run_id': args.run_id, 'source': request['source'],
            'archived_at': datetime.now(timezone.utc).isoformat(),
            'usage': result.get('usage'), 'citation_count': len(citations),
            'files': {name: {'bytes': len(data), 'sha256': hashlib.sha256(data).hexdigest()}
                      for name, data in files.items()}}
folder = Path('archive') / args.run_id
folder.mkdir(parents=True)  # Existing archives are preserved. Choose a new run ID for new work.
for name, data in files.items():
    with (folder / name).open('xb') as output:
        output.write(data)
# Write the manifest last. Without it, the archive is incomplete.
with (folder / 'manifest.json').open('x', encoding='utf-8') as output:
    json.dump(manifest, output, ensure_ascii=False, indent=2)
print(json.dumps({'archive': str(folder), 'citations': len(citations), 'complete': True}))

Archief aanmaken

Uitvoeren vanuit de map met archive.py, request.json en search.json.

Bouw een nieuw archief
python3 archive.py --run-id saved-search

4. Het archief opnieuw gebruiken zonder referenties

Bewaar reuse.py hieronder. Kopieer de volledige archive/saved-search map naar het proces dat het nodig heeft, en voer vervolgens deze reader uit. Het controleert elk bestand voordat u de oorspronkelijke query, gebruik en citaten afdrukt. Het werkt na API-sleutel intrekking of gehost-resultaat verlopen omdat het alleen leest uw opgeslagen exemplaar.

reuse.py opslaan

reuse.py aanmaken in de werkmap met archive/. Op een andere machine, kopieer zowel reuse.py als de complete archive/saved-search directory, met behoud van deze lay-out.

reuse.py
# reuse.py — run without a FlashData key or CLI.
import hashlib
import json
import sys
from pathlib import Path

folder = Path(sys.argv[1])
manifest = json.loads((folder / 'manifest.json').read_text(encoding='utf-8'))
expected = {'request.json', 'response.json', 'citations.ndjson'}
if manifest.get('version') != 1 or set(manifest.get('files', {})) != expected:
    raise ValueError('Unknown or incomplete archive manifest.')
files = {}
for name in sorted(expected):
    data = (folder / name).read_bytes()
    record = manifest['files'][name]
    if len(data) != record['bytes'] or hashlib.sha256(data).hexdigest() != record['sha256']:
        raise ValueError('Archive changed or was not fully copied: ' + name)
    files[name] = data
request = json.loads(files['request.json'].decode('utf-8-sig'))
citations = [json.loads(line) for line in files['citations.ndjson'].decode('utf-8').splitlines()]
if len(citations) != manifest['citation_count']:
    raise ValueError('Citation count does not match the manifest.')
print(json.dumps({'run_id': manifest['run_id'], 'query': request['query'],
                  'archived_at': manifest['archived_at'], 'usage': manifest['usage'],
                  'citations': citations}, indent=2))

Het opgeslagen archief lezen

Sla reuse.py op en voer vervolgens uit de map. Het laatste argument is het pad naar het gekopieerde archief.

Het gekopieerde archief lezen
python3 reuse.py archive/saved-search

Exporteren uit het CLI journal in plaats daarvan

Als je nog steeds het originele CLI-profiel en de statusmap hebt, exporteer dan de opgeslagen run naar een nieuwe bestandsnaam. Dit maakt geen nieuwe vraag, maar het controleert live toegang eerst. Een bestaand resultaatbestand of archief kan lokaal gelezen worden zonder die controle.

Uitvoeren van voltooid programma
flashdata runs show saved-search --result --output search-copy.json --json

Beslis wanneer hergebruik of opfris

archived_at registreert wanneer u de bestanden hebt opgeslagen, niet wanneer een bronpagina is veranderd. Uw aanvraag bepaalt hoe recent het bewijs moet zijn; het kopiëren van een bestand ververst de inhoud niet.

TaakActie
Herstart een parser, regenereer een rapport of zet een agent stapHergebruik het opgeslagen antwoord. Houd bron URLs, zoekparameters en gebruik mee.
Maak een nieuwe dagelijkse briefing of beantwoord een gewijzigde vraagMaak een nieuwe task/run ID, werkmap en archief. Houd oudere snapshots als geschiedenis.
Tel het gebruik in afgeleide bestandenTel de oorspronkelijke vraag één keer. Het kopiëren van een antwoord of het maken van een ander rapport creëert geen andere lading.

Weten wat afloopt

ResultaatWat te houdenBewaring
Realtime queryHet antwoordbestand en de oorspronkelijke invoerUw opgeslagen kopie volgt uw opslagbeleid
Async / Batch-taakJob ID, ontvangst en resultaat JSON24 uren na voltooiing
BulkManifest en alle NDJSON delen24 uren nadat de hele job is voltooid; controleer expiresAt
YouTube DownloadLevering JSON en media op uw bestemmingLevering JSON: vacaturebehoud. Media: uw emmerlevenscyclus
MCP chunk cacheHet volledig geassembleerde resultaat10 minuten; alleen de vier nieuwste grote resultaten per API sleutel worden bewaard

Houd een klein zijspan in plaats daarvan

Hou de oorspronkelijke reactie onveranderd. Sla een klein zijspan op met de invoer, bron, bespaar tijd en gebruik, zodat een later proces kan begrijpen wat het bestand heeft geproduceerd. Houd bron URLs en video tijdstempels bij het transformeren van resultaten.

Bash / jq · search-record.json
(
set -euC
jq --arg run_id 'saved-search' --slurpfile request request.json \
  '{run_id: $run_id, source, input: $request[0],
    saved_at: (now | todateiso8601), result_file: "search.json", usage}' \
  search.json > search-record.json
cat search-record.json
)

Direct opslaan met HTTP

Gebruik dit in plaats van de CLI query in stap 1. Sla eerst dezelfde request.json op; dit draait een nieuwe query met Bash, cURL 7.76+ en jq. Hergebruik FLASHDATA_API_KEY en kies een map zonder search.json. Na validatie werken dezelfde archiefscripts met dit resultaat; kies je eigen taak ID voor --run-id.

Een nonzero cURL uitgang betekent dat het resultaat niet klaar is voor gebruik. Controleer het opgeslagen antwoord voordat u het opnieuw probeert; een timeout van de verbinding kan gebeuren nadat een query is geaccepteerd. Gebruik het validatie commando in stap 2.

Stel uw sleutel in indien nodig
# Bash: paste the key into a hidden prompt, not into this command.
read -r -s -p "FlashData API key: " FLASHDATA_API_KEY
printf '\n'
export FLASHDATA_API_KEY
Het antwoord API opslaan
(
set -euC
: "${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY first}"
test -f request.json
curl --fail-with-body --silent --show-error --max-time 120 \
  --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
  --header "X-API-Key: $FLASHDATA_API_KEY" \
  --header 'Content-Type: application/json' --header 'Accept: application/json' \
  --data-binary @request.json > search.json
jq . search.json
)

Een bestaande achtergrondtaak opslaan

Gebruik submission.json uit de async-gids en dezelfde account credential. Deze commando's halen bestaand werk op; ze sturen geen andere zoekopdracht. De CLI wacht op voltooiing en behandelt de resultaatredirect. Bewaar het resultaat binnen 24 uren na voltooiing.

Wacht, ophalen en opslaan
(
set -euC
JOB_ID=$(jq -er '.remoteId // .id // .submission.id' submission.json)
flashdata jobs wait "$JOB_ID" --json
flashdata jobs result "$JOB_ID" --output job-result.json --json
jq '{source, status, results, usage}' job-result.json
)

Sla elk Bulk resultaatdeel op

Vervang BULK_ID door de ID in uw inzendingsbon. Nadat de taak is voltooid, volgt de CLI het manifest en slaat elk onderdeel op als één NDJSON-bestand. Hou het manifest ook wanneer u tellingen nodig hebt en deelmetadata.

Het bestand kan zowel succesvolle als mislukte rijen bevatten. Reconcile input indexen en tellingen voordat de hele taak is voltooid. Niet opnieuw uitvoeren van het gehele invoerbestand om een mislukte rij te herstellen.

Verzamelen van de voltooide taak
flashdata bulk results BULK_ID --output bulk-results.ndjson --timeout 30m --json

Bewaar het leveringsrecord en de media

delivery.json bevat een leveringsrecord, niet de video of audio bytes. Sla zijn URL, grootte en controlesom naast de taak. De media leven in uw bestemmingsopslag en volgt de levenscyclus van die opslag.

Voor een privé-bestemming, gebruik de referenties van die provider of ondertekend URL om het object te inspecteren. Een ontbrekend tijdelijk resultaat JSON betekent niet dat uw opgeslagen media zijn verwijderd.

Controleer een opgeslagen download resultaat · jq
jq '.results[] | {file_url, file_size, md5, downloaded_bytes, output_format}' delivery.json

MCP brokken samenvoegen voordat u opslaat

Als een hulpmiddel result_id, chunk en next_offset teruggeeft, lees dan de resterende brokken met get_result met dezelfde API sleutel. Gebruik de exacte next_offset die door de tool wordt teruggegeven; de onderstaande waarden zijn plaatshouders.

  1. Voeg elke brok toe in offset volgorde. Volg next_offset tot het null is.
  2. Ontleed de samengevoegde tekst eenmaal als JSON, schrijf dan het volledige resultaat naar uw eigen bestand of opslag.
  3. Opslaan voor expires_at. Nieuwe grote reacties kunnen oudere resultaten verwijderen voordat de 10-minutenlimiet; de cache houdt vier per API-sleutel.
MCP tools/call argumenten
{
  "name": "get_result",
  "arguments": {
    "result_id": "RESULT_ID_FROM_TOOL",
    "offset": 16000
  }
}

Opslaan en ophalen van problemen oplossen

ProbleemRepareren
Uitvoerbestand bestaat alInspecteer het eerst. Voor een voltooide CLI-run, gebruik runs show met een nieuwe uitvoer bestandsnaam in plaats van het indienen van een andere query.
CLI kan de run niet vindenGebruik de originele OS-gebruiker, profiel en statusmap. Als je een externe taak ID hebt behouden, haal die taak dan direct op.
401 / 403 bij hergebruikStart flashdata auth status --json en herstel de geldige toegang. Een lokaal bestand dat al is opgeslagen kan nog steeds worden gelezen zonder toegang tot API.
409 / 410409: wacht op de bestaande taak. 410: gebruik uw opgeslagen kopie; het tijdelijke resultaat is verlopen.
Schijffout na een queryHoud de lopende ID of taak ID. Repareer opslag en herstel bestaande werkzaamheden voordat u een nieuwe indiening overweegt.
Archief heeft geen manifest of een controlesom misluktHerstel of kopieer de originele bestanden opnieuw. Houd een onvolledig archief voor inspectie; herbouwen van het archief vereist geen nieuwe zoekopdracht.
MCP · result_unavailableControleer resultaat ID, offset, API sleutel en verlopen. Gebruik een opgeslagen kopie als de cache is verlopen; loop niet door een betaalde query te herhalen.