सीधे सामग्री पर जाएँ
HI
API कुंजी प्राप्त करें
दस्तावेज़ देखें

गाइड

परिणाम सहेजें और फिर से उपयोग करें

इसके मूल इनपुट, स्रोत लिंक और उपयोग के साथ एक परिणाम रखें, फिर इसे किसी अन्य क्वेरी के बिना किसी अन्य प्रक्रिया को सौंप दें।

इस पेज पर

एक बार क्वेरी, कार्यों के दौरान परिणाम का उपयोग करें

एक रिपोर्ट बनाएं, अपने पार्सर को फिर से शुरू करें या बाद में एजेंट को उसी सबूत को कदम दें। यह वर्कफ़्लो एक पोर्टेबल संग्रह के रूप में एक खोज को बचाता है; पढ़ने कि संग्रह को न तो एक FlashData कुंजी और न ही मूल CLI राज्य की आवश्यकता होती है।

आप क्या करेंगे?
archive/saved-search/
  request.json मूल क्वेरी और पैरामीटर
  response.json ने API प्रतिक्रिया को अपरिवर्तित नहीं किया
  citations.ndjson शीर्षक, स्रोत URLs और स्निपेट
  manifest.json रन ID, उपयोग, फ़ाइल आकार और SHA-256

शुरू करने से पहले

एक नए कार्य फ़ोल्डर का उपयोग करें, FlashData CLI google_search अनुमति और उपलब्ध क्रेडिट के साथ। एक प्रमाणित प्रोफ़ाइल या FLASHDATA_API_KEY का पुन: उपयोग करें। Bash निरीक्षण jq का उपयोग करता है; Windows PowerShell 7 का उपयोग करता है। स्थानीय संग्रह लिपियों का उपयोग Python 3.10+ और इसकी मानक पुस्तकालय है।

जारी रखें जब data.accessVerified true है। CLI retries के लिए, उसी प्रोफ़ाइल को बनाए रखें, OS उपयोगकर्ता और राज्य निर्देशिका। एक एजेंट को अपने मौजूदा क्रेडेंशियल को अपने गुप्त स्टोर से लोड करना चाहिए।

अपनी सेव्ड एक्सेस चेक करें
flashdata auth status --json

1. इनपुट रखें और एक प्रतिक्रिया सहेजें

नीचे request.json सहेजें, फिर एक कमांड चलाएं। --input इस सटीक अनुरोध का उपयोग करता है; बाद में फ़ाइल को अपरिवर्तित रखें। --output search.json में API शरीर को बचाता है; --json प्रिंट CLI मेटाडाटा। बचाया खोज यह कार्य स्थानीय रन ID है।

request.json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
एक खोज रन
flashdata query --input request.json \
  --run-id saved-search --output search.json --json

2. सहेजी गई प्रतिक्रिया को मान्य करें

एक्सपेक्टर सोर्स: google_search, status: done और एक परिणाम सरणी। प्रत्येक कार्बनिक परिणाम का शीर्षक, लिंक और स्निपेट मुद्रित करें। वास्तविक परिणाम भिन्न होते हैं; एक खाली सफल संग्रह असफल अनुरोध या लापता क्षेत्र से अलग होता है।

मान्य और पढ़ने 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. इनपुट, प्रतिक्रिया और प्रशस्ति पत्र संग्रहित करना

नीचे archive.py सहेजें, फिर इसे कदम 1 से चलाने वाले ID के साथ चलाएं। यह कच्ची फ़ाइलों को संरक्षित करता है, स्रोत लिंक को निकालता है और फ़ाइल चेकसम और उपयोग के साथ अंतिम manifest.json लिखता है। complete: true को Expect; प्रशस्ति गणना खोज परिणामों पर निर्भर करती है। कोई नेटवर्क अनुरोध नहीं किया जाता है।

बचाओ archive.py

अपने काम के फ़ोल्डर में archive.py को request.json और search.json के बगल में बनाया गया है। नीचे दिए गए कोड को कॉपी करें और इसे सहेजें।

उदाहरण के संग्रह Google Search परिणाम। मौजूदा संग्रह निर्देशिकाओं को बरकरार रखा जाता है। request.json, search.json और मैचिंग रन को पूरा करने तक रखें।

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

संग्रह बनाएँ

archive.py, request.json और search.json युक्त फ़ोल्डर से भाग लें।

एक नया संग्रह बनाएँ
python3 archive.py --run-id saved-search

4. बिना क्रेडेंशियल के संग्रह का पुन: उपयोग करें

नीचे reuse.py सहेजें। पूरा archive/saved-search फ़ोल्डर को उस प्रक्रिया में कॉपी करें जिसकी आवश्यकता है, फिर इस रीडर को चलाएं। यह हर फ़ाइल को मूल क्वेरी, उपयोग और प्रशस्ति पत्र प्रिंट करने से पहले सत्यापित करता है। यह API-key revocation या होस्ट-result expiry के बाद काम करता है क्योंकि यह केवल आपकी सहेजी गई प्रतिलिपि पढ़ता है।

बचाओ reuse.py

archive/. युक्त कार्य फ़ोल्डर में reuse.py बनाएं दूसरी मशीन पर, दोनों reuse.py और पूरी archive/saved-search निर्देशिका की प्रतिलिपि बनाएँ, इस लेआउट को बनाए रखें।

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

सहेजे गए संग्रह पढ़ें

reuse.py को सेव करें, फिर इसके फ़ोल्डर से चलाएं। अंतिम तर्क कॉपी किए गए संग्रह का रास्ता है।

कॉपी किए गए संग्रह को पढ़ें
python3 reuse.py archive/saved-search

इसके बजाय CLI जर्नल से निर्यात करें

यदि आपके पास अभी भी मूल CLI प्रोफाइल और स्टेट डाइरेक्टरी है, तो बचे हुए रन को एक नया फाइल नाम में निर्यात करें। यह कोई नया क्वेरी नहीं बनाता है, लेकिन यह पहली बार लाइव एक्सेस को सत्यापित करता है। एक मौजूदा परिणाम फ़ाइल या संग्रह स्थानीय रूप से उस चेक के बिना पढ़ा जा सकता है।

पूरा रन निर्यात करें
flashdata runs show saved-search --result --output search-copy.json --json

जब पुन: उपयोग करने या रीफ्रेश करने के लिए निर्णय लें

जब आप फ़ाइलों को सहेजते हैं तो archived_at रिकॉर्ड्स, नहीं जब एक स्रोत पृष्ठ बदल जाता है। आपका आवेदन यह तय करता है कि हाल के सबूत कैसे होना चाहिए; एक फ़ाइल की प्रतिलिपि अपनी सामग्री को ताज़ा नहीं करती है।

कार्यकार्रवाई
एक पार्सर को फिर से शुरू करें, एक रिपोर्ट को फिर से उत्पन्न करें या एजेंट को जारी रखेंबचाया प्रतिक्रिया का पुन: उपयोग करें। स्रोत URLs, क्वेरी पैरामीटर और इसके साथ उपयोग रखें।
एक नया दैनिक ब्रीफिंग का उत्पादन करें या एक बदली हुई क्वेरी का जवाब देंएक नया task/run ID, कार्यशील फ़ोल्डर और संग्रह बनाएँ। पुराने स्नैपशॉट को इतिहास के रूप में रखें।
व्युत्पन्न फ़ाइलों में उपयोग की गणना करेंएक बार मूल क्वेरी गणना करें। एक प्रतिक्रिया की प्रतिलिपि बनाना या एक अन्य रिपोर्ट बनाना एक और शुल्क नहीं बनाती है।

क्या समाप्त हो रहा है पता

परिणामक्या रखना है?ध्यान देना
Realtime क्वेरीप्रतिक्रिया फ़ाइल और मूल इनपुटआपकी सेव्ड कॉपी आपकी स्टोरेज पॉलिसी का अनुसरण करती है
Async / Batch नौकरीनौकरी ID, जमा रसीद और परिणाम JSONपूरा होने के बाद 24 घंटे
Bulkमैनिफेस्ट और सभी NDJSON भागोंपूरे काम पूरा करने के बाद 24 घंटे; चेक expiresAt
YouTube Downloadअपने गंतव्य में डिलिवरी JSON और मीडियाडिलिवरी JSON: नौकरी प्रतिधारण। मीडिया: आपकी बाल्टी जीवनचक्र
MCP भाग कैशपूरी तरह से इकट्ठे परिणाम10 मिनट; केवल चार नए बड़े परिणाम प्रति API कुंजी को बनाए रखा गया है

इसके बजाय एक छोटा सा साइडकार रखें

मूल प्रतिक्रिया को अपरिवर्तित रखें। इनपुट, स्रोत, समय बचाने और उपयोग के साथ एक छोटा सा साइडकार सहेजें ताकि बाद में प्रक्रिया यह समझ सके कि क्या फाइल का उत्पादन किया गया है। परिणाम बदलने पर स्रोत URLs और वीडियो टाइमस्टैम्प रखें।

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
)

सीधे HTTP के साथ सहेजें

इसके बजाय कदम 1 में CLI क्वेरी का प्रयोग करें। पहले उसी request.json को सेव करें; यह Bash, cURL 7.76+ और jq का उपयोग करके एक नया क्वेरी चलाता है। Reuse FLASHDATA_API_KEY और search.json के बिना एक फ़ोल्डर चुनें। सत्यापन के बाद, एक ही संग्रह स्क्रिप्ट इस परिणाम के साथ काम करते हैं; --run-id के लिए अपना खुद का कार्य ID चुनें।

एक nonzero cURL निकास का मतलब है कि परिणाम उपयोग के लिए तैयार नहीं है। पुनः प्रयास करने से पहले बचाया प्रतिक्रिया का निरीक्षण करें; एक कनेक्शन टाइमआउट एक क्वेरी स्वीकार करने के बाद हो सकता है। चरण 2 में सत्यापन आदेश का उपयोग करें।

यदि आवश्यक हो तो अपनी कुंजी सेट करें
# 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
API प्रतिक्रिया सहेजें
(
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
)

मौजूदा पृष्ठभूमि जॉब सेव करें

Async गाइड और उसी खाता क्रेडेंशियल से submission.json का उपयोग करें। ये आदेश मौजूदा कार्य को पुनः प्राप्त करते हैं; वे एक और क्वेरी प्रस्तुत नहीं करते हैं। CLI पूरा होने के लिए प्रतीक्षा करता है और परिणाम को फिर से निर्देशित करता है। परिणाम को 24 घंटे पूरा होने के भीतर सहेजें।

प्रतीक्षा करें, पुनः प्राप्त करें और सहेजें
(
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
)

प्रत्येक Bulk परिणाम भाग सहेजें

अपने जमा रसीद में ID के साथ BULK_ID बदलें। नौकरी पूरा करने के बाद, CLI प्रकट होने का अनुसरण करता है और प्रत्येक भाग को एक NDJSON फ़ाइल के रूप में बचाता है। जब आपको गिनती और भाग मेटाडाटा की आवश्यकता होती है तो प्रकट होने को भी रखें।

फ़ाइल में सफल और असफल दोनों पंक्तियां हो सकती हैं। पूरे कार्य को पूरा करने से पहले इनपुट सूचकांकों और गिनती को दोहराएं। एक असफल पंक्ति को ठीक करने के लिए पूरे इनपुट फ़ाइल को फिर से शुरू न करें।

पूरा काम लीजिए
flashdata bulk results BULK_ID --output bulk-results.ndjson --timeout 30m --json

डिलीवरी रिकॉर्ड और मीडिया को रखें

delivery.json में एक वितरण रिकॉर्ड है, वीडियो या ऑडियो बाइट्स नहीं। अपने URL, आकार और चेकसम को कार्य के साथ सहेजें। मीडिया आपके गंतव्य भंडारण में रहता है और उस भंडारण के जीवन चक्र का अनुसरण करता है।

एक निजी गंतव्य के लिए, उस प्रदाता की क्रेडेंशियल्स का उपयोग करें या ऑब्जेक्ट का निरीक्षण करने के लिए URL पर हस्ताक्षर किए। एक लापता अस्थायी परिणाम JSON का मतलब यह नहीं है कि आपके संग्रहीत मीडिया को हटा दिया गया था।

एक बचाया डाउनलोड परिणाम का निरीक्षण करें · jq
jq '.results[] | {file_url, file_size, md5, downloaded_bytes, output_format}' delivery.json

सेव करने से पहले MCP चंक्स इकट्ठा करें

जब कोई उपकरण result_id, चंक और next_offset को लौटाता है, तो उसी API कुंजी का उपयोग करके get_result के साथ शेष हिस्से को पढ़ा जाता है। उपकरण द्वारा लौटाए गए सटीक next_offset का उपयोग करें; नीचे दिए गए मान प्लेसहोल्डर हैं।

  1. प्रत्येक भाग को ऑफ़सेट ऑर्डर में जोड़ें। जब तक यह null है तब तक next_offset का पालन करें।
  2. एक बार JSON के रूप में जुड़े हुए पाठ को पार्स करें, फिर अपनी फ़ाइल या स्टोरेज के लिए पूर्ण परिणाम लिखें।
  3. expires_at से पहले सेव करें। नई बड़ी प्रतिक्रियाएं 10-मिनट की सीमा से पहले पुराने परिणाम को नष्ट कर सकती हैं; कैश प्रति API कुंजी रखता है।
MCP tools/call तर्क
{
  "name": "get_result",
  "arguments": {
    "result_id": "RESULT_ID_FROM_TOOL",
    "offset": 16000
  }
}

बचत और पुनर्प्राप्ति समस्याओं को ठीक करें

समस्याफिक्स
पहले से ही मौजूद हैयह पहले निरीक्षण करें। एक पूर्ण CLI रन के लिए, एक नया आउटपुट फ़ाइल नाम के साथ runs show का उपयोग करने के बजाय एक और क्वेरी जमा करने के लिए किया जाता है।
CLI को रन नहीं मिल सकतामूल OS उपयोगकर्ता, प्रोफ़ाइल और राज्य निर्देशिका का उपयोग करें। यदि आपने दूरस्थ नौकरी ID रखा है, तो उस नौकरी को सीधे पुनः प्राप्त करें।
401 / 403 का पुन: उपयोग करने परफ्लैशडाटा auth status --json को चलाएं और वैध पहुंच को पुनर्स्थापित करें। पहले से ही बचाया एक स्थानीय फ़ाइल अभी भी API पहुँच के बिना पढ़ा जा सकता है।
409 / 410409: मौजूदा नौकरी के लिए प्रतीक्षा करें। 410: अपनी सहेजी गई प्रतिलिपि का उपयोग करें; अस्थायी परिणाम समाप्त हो गया है।
क्वेरी के बाद डिस्क त्रुटिचलाने वाले ID या नौकरी ID रखें। नए जमा करने पर विचार करने से पहले भंडारण को ठीक करें और मौजूदा कार्य को पुनर्प्राप्त करें।
पुरालेख में कोई प्रकट नहीं होता है या एक जांच विफल रहता हैफिर से मूल फ़ाइलों को पुनर्स्थापित या कॉपी करें। निरीक्षण के लिए एक अधूरे संग्रह रखें; संग्रह को पुनर्निर्माण करने के लिए एक नई क्वेरी की आवश्यकता नहीं है।
MCP · result_unavailableपरिणाम ID, ऑफसेट, API कुंजी और समाप्ति की जाँच करें। अगर कैश समाप्त हो गया है, तो सहेजी गई प्रतिलिपि का उपयोग करें; भुगतान की गई क्वेरी को दोहराकर लूप न करें।
Markdown