> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/deployment/hi/monitoring-and-analytics/vision-events/query-events.md).

# इवेंट्स क्वेरी करें

dashboard में Vision Events खोजें, फ़िल्टर करें, और ब्राउज़ करें, Agent से प्राकृतिक भाषा में पूछें, या API के माध्यम से query करें

## के बारे में

यह पृष्ठ बताता है कि विशिष्ट [Vision Events](/deployment/hi/monitoring-and-analytics/vision-events.md) - आपके तैनात मॉडलों ने क्या देखा, उसके समय-चिह्नित रिकॉर्ड—उन्हें Vision Events डैशबोर्ड में फ़िल्टर और खोजकर, या REST API के माध्यम से प्रोग्रामेटिक रूप से। उत्पादन व्यवहार का ऑडिट करने और रिपोर्ट बनाने के लिए तारीख सीमा, इवेंट प्रकार, डिवाइस, स्ट्रीम, वर्कफ़्लो, पता चली क्लास, या फ़ीडबैक स्थिति के आधार पर परिणाम सीमित करें। आप यह भी पूछ सकते हैं [Roboflow Agent](https://docs.roboflow.com/agents/roboflow-agent) अपने इवेंट्स के बारे में प्राकृतिक भाषा में प्रश्न।

## वेब ऐप

### इवेंट्स को क्वेरी और फ़िल्टर करें

Vision Events डैशबोर्ड में फ़िल्टर का उपयोग करके विशिष्ट इवेंट्स खोजें या उन्हें REST API के माध्यम से प्रोग्रामेटिक रूप से क्वेरी करें।

#### डैशबोर्ड में इवेंट्स ब्राउज़ करें

**एक उपयोग केस चुनें**

Vision Events पृष्ठ से, उसके इवेंट्स देखने के लिए किसी उपयोग केस पर क्लिक करें। इवेंट्स उल्टे कालानुक्रमिक क्रम में प्रदर्शित होते हैं।

<figure><img src="https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-95c770d9d0c869e1e12457c562341ea39479ffd2%2Fimage%20(457).png?alt=media" alt="" width="375"><figcaption></figcaption></figure>

**इवेंट्स फ़िल्टर करें**

परिणामों को सीमित करने के लिए इवेंट्स सूची के शीर्ष पर स्थित फ़िल्टर नियंत्रणों का उपयोग करें:

* **तारीख सीमा** - प्रारंभ और समाप्ति टाइमस्टैम्प
* **इवेंट प्रकार** - quality\_check, inventory\_count, safety\_alert, custom, operator\_feedback
* **डिवाइस** - डिवाइस ID के आधार पर फ़िल्टर करें
* **स्ट्रीम** - स्ट्रीम या कैमरा ID के आधार पर फ़िल्टर करें
* **वर्कफ़्लो** - उन इवेंट्स को फ़िल्टर करें जिन्हें इस वर्कफ़्लो ने उत्पन्न किया
* **डिटेक्शन** - किसी पता चली ऑब्जेक्ट क्लास के आधार पर फ़िल्टर करें, वैकल्पिक confidence threshold के साथ
* **फ़ीडबैक स्थिति** - correct, incorrect, inconclusive, या no feedback
* **कस्टम metadata** - किसी भी कस्टम मेटाडेटा फ़ील्ड और मान के आधार पर फ़िल्टर करें
* **वीडियो गिनती** - संलग्न वीडियो क्लिप्स की संख्या के आधार पर फ़िल्टर करें (उदा.: वीडियो वाले इवेंट्स खोजने के लिए "Greater Than or Equal" 1)
* **चेतावनियाँ** - केवल वे इवेंट्स दिखाएँ जिनमें ingestion चेतावनियाँ थीं

आप इवेंट विवरण साइडबार में मानों पर भी क्लिक कर सकते हैं (जैसे डिवाइस ID, स्ट्रीम, quality check परिणाम, या कस्टम मेटाडेटा मान) ताकि उन्हें जल्दी से फ़िल्टर के रूप में जोड़ सकें।

फ़िल्टर चिप्स संपादन योग्य हैं — किसी भी सक्रिय फ़िल्टर चिप पर क्लिक करें ताकि उसका मान या ऑपरेटर हटाए और फिर से जोड़े बिना बदला जा सके।

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

<figure><img src="https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-6dd0ace6246d420942f5311802af38fd5988065d%2Fimage%20(458).png?alt=media" alt="" width="375"><figcaption></figcaption></figure>

**इवेंट विवरण देखें**

सूची में किसी भी इवेंट पर क्लिक करके उसके पूर्ण विवरण देखें:

* स्रोत छवि, कोई भी आउटपुट छवियाँ, और कोई भी वीडियो क्लिप्स
* सभी स्रोत मेटाडेटा (डिवाइस, स्ट्रीम, वर्कफ़्लो)
* ऑब्जेक्ट डिटेक्शन्स, क्लासिफिकेशन्स, और सेगमेंटेशन्स उनके confidence scores के साथ
* इवेंट-प्रकार-विशिष्ट डेटा (उदा.: पास/फेल परिणाम, आइटम गिनती, अलर्ट गंभीरता)
* कस्टम मेटाडेटा की key-value जोड़ियाँ

**डिटेक्शन्स बनाएं**

जब किसी इवेंट में prediction डेटा (ऑब्जेक्ट डिटेक्शन्स, instance segmentations, या keypoints) होता है, तो छवि के ऊपर एक "Draw Detections" चेकबॉक्स दिखाई देता है। इसे सक्षम करें ताकि source image के ऊपर confidence scores के साथ bounding boxes, segmentation polygons, और labels ओवरले हो सकें।

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

{% hint style="info" %}
दिखाई नहीं देता जब आप एक अलग आउटपुट छवि देख रहे होते हैं, क्योंकि उनमें पहले से ही डिटेक्शन्स रेंडर किए गए होते हैं।
{% endhint %}

**वीडियो क्लिप्स**

प्ले आइकन वाले इवेंट कार्ड में एक या अधिक [वीडियो क्लिप्स](/deployment/hi/monitoring-and-analytics/vision-events/upload-a-vision-event-video.md) संलग्न होते हैं। विवरण दृश्य में, छवियों के बाद "Media" पट्टी में क्लिप्स दिखाई देते हैं, जिनका नाम उनके लेबल या "Clip 1", "Clip 2" आदि के अनुसार होता है। ब्राउज़र के वीडियो प्लेयर में चलाने के लिए किसी क्लिप पर क्लिक करें, और उसकी अवधि नीचे दिखाई जाती है।

जो क्लिप अभी भी Roboflow द्वारा संसाधित की जा रही है, उसमें "अभी संसाधित हो रहा है। यह तैयार होते ही चल जाएगा।" दिखता है। प्लेयर कुछ मिनटों तक फिर से जाँच करता है, फिर "अभी संसाधित हो रहा है।" के साथ एक "फिर से जाँचें" बटन दिखाता है। जिसके अपलोड में विफलता हुई है, उस क्लिप में "वीडियो अपलोड नहीं हो सका" दिखता है, और जिसे लोड नहीं किया जा सकता उसमें "वीडियो उपलब्ध नहीं है" दिखता है। डिटेक्शन ओवरले और फ़ुलस्क्रीन केवल छवियों पर लागू होते हैं, और क्लिप्स को [प्रशिक्षण के लिए जोड़ा नहीं जा सकता](/deployment/hi/monitoring-and-analytics/vision-events/add-images-for-training.md).

**स्वतः-समाप्त इवेंट्स**

स्वतः-समाप्त के रूप में चिह्नित एक इवेंट उसके वीडियो के अपलोड होने से पहले एज डिवाइस पर स्वतः बंद कर दिया गया था, इसलिए वीडियो अनुपस्थित है। इवेंट फिर भी अपना परिणाम और स्थिर छवियाँ रखता है। इवेंट कार्ड पर एक काटे हुए वीडियो आइकन ("Auto-finalized: video missing") दिखता है, और विवरण दृश्य में वह समय दिखता है जब इसे अंतिम रूप दिया गया था। यह केवल उन इवेंट्स पर लागू होता है जो के माध्यम से सिंक किए गए हैं [एज डिवाइस बैकअप](/deployment/hi/monitoring-and-analytics/vision-events/send-events.md#edge-device-backup).

### एजेंट से पूछें

आप हाथ से फ़िल्टर बनाने के बजाय प्राकृतिक भाषा में इवेंट्स क्वेरी कर सकते हैं। [Roboflow Agent](https://docs.roboflow.com/agents/roboflow-agent) "Agent" पर क्लिक करके बाएँ साइडबार में इसे खोलें, फिर किसी उपयोग केस के बारे में पूछें (उदा.: "पिछले हफ्ते assembly-line-qa में कितनी विफलताएँ थीं?", "समय के साथ दोष दर कैसे बदली है?", "प्रति स्ट्रीम औसत आइटम गिनती क्या है?").

आप किसी उपयोग केस पर "AI के साथ विश्लेषण करें" पर भी क्लिक कर सकते हैं। बटन Overview और Search टैब पर दिखाई देता है और उस उपयोग केस के बारे में एक प्रश्न के साथ Agent को नए टैब में खोलता है, जिसे भेजने के लिए तैयार किया गया होता है। Search टैब पर, प्रश्न में आपके लागू किए गए फ़िल्टर भी शामिल होते हैं, इसलिए Agent उन्हीं इवेंट्स को देखता है जिन्हें आप देख रहे हैं।

Agent आपके इवेंट डेटा को क्वेरी करके उत्तर देता है, इसलिए संख्याएँ वही दर्शाती हैं जो आपके इवेंट्स में वास्तव में मौजूद है। यह कर सकता है:

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

यदि कोई प्रश्न आपके workspace के [रिटेंशन विंडो](/deployment/hi/monitoring-and-analytics/vision-events.md#data-retention)से आगे बढ़ जाता है, तो Agent शून्य का उत्तर देने के बजाय आपको वह सबसे शुरुआती तारीख बताता है जिसे वह क्वेरी कर सकता है। तारीख सीमाएँ और समय बकेट UTC का उपयोग करते हैं।

इवेंट्स के बारे में पूछने के लिए "View Vision Events" [अनुमति](https://docs.roboflow.com/platform/enterprise-features/role-based-access-control).

एक-बार के उत्तर के बजाय नियमित ईमेल डाइजेस्ट के लिए, देखें [सारांश रिपोर्ट](/deployment/hi/monitoring-and-analytics/vision-events/summary-reports.md).

## HTTP API

### API के माध्यम से इवेंट्स क्वेरी करें

क्वेरी एंडपॉइंट डैशबोर्ड के समान फ़िल्टर, साथ ही cursor-आधारित पृष्ठीकरण का समर्थन करता है। पैरामीटर और प्रतिक्रिया फ़ील्ड्स की पूरी सूची के लिए, देखें [Vision Events API Reference](/deployment/hi/monitoring-and-analytics/vision-events.md#http-api).

#### मूल क्वेरी

```bash
curl -X POST "https://api.roboflow.com/vision-events/query" \\
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "useCaseId": "assembly-line-qa",
    "startTime": "2026-03-01T00:00:00Z",
    "endTime": "2026-03-31T23:59:59Z",
    "limit": 25
  }'
```

**प्रतिक्रिया:**

```json
{
  "events": [
    {
      "eventId": "evt-789ghi",
      "eventType": "quality_check",
      "timestamp": "2026-03-30T14:30:00.000Z",
      "deviceId": "factory-cam-01",
      "streamId": "line-3",
      "images": [],
      "eventData": { "result": "fail" },
      "customMetadata": {
        "line_id": "line-3",
        "shift": "morning",
        "part_number": "PN-4421"
      }
    }
  ],
  "nextCursor": "eyJ0cyI6IjIwMjYtMDMtMzAifQ==",
  "hasMore": true
}
```

#### पृष्ठीकरण

परिणाम cursor का उपयोग करके पृष्ठों में विभाजित किए जाते हैं। यदि प्रतिक्रिया में एक `nextCursor` मान और `hasMore` है `सही`तो अगले पृष्ठ को प्राप्त करने के लिए अपने अगले अनुरोध में cursor पास करें:

```bash
curl -X POST "https://api.roboflow.com/vision-events/query" \\
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "useCaseId": "assembly-line-qa",
    "limit": 25,
    "cursor": "eyJ0cyI6IjIwMjYtMDMtMzAifQ=="
  }'
```

तब तक जारी रखें जब तक `hasMore` है `गलत`.

#### इवेंट प्रकार के अनुसार फ़िल्टर करें

एकल इवेंट प्रकार को क्वेरी करें:

```json
{
  "useCaseId": "assembly-line-qa",
  "eventType": "quality_check"
}
```

या कई इवेंट प्रकार (अधिकतम 20):

```json
{
  "useCaseId": "assembly-line-qa",
  "eventTypes": ["quality_check", "operator_feedback"]
}
```

#### फ़ीडबैक स्थिति के अनुसार फ़िल्टर करें

उपयोग करें `feedbackStatus` यह पता लगाने के लिए कि ऑपरेटरों ने उन्हें समीक्षा किया है या नहीं और उन्हें कैसे रेट किया गया है:

```json
{
  "useCaseId": "assembly-line-qa",
  "feedbackStatus": ["incorrect", "none"]
}
```

मान्य मान: `correct`, `incorrect`, `inconclusive`, `none`. उपयोग करें `none` उन इवेंट्स को खोजने के लिए जिनकी अभी तक समीक्षा नहीं हुई है।

#### कस्टम मेटाडेटा के अनुसार फ़िल्टर करें

उपयोग करें `customMetadataFilters` अपने स्वयं के मेटाडेटा फ़ील्ड्स के आधार पर इवेंट्स फ़िल्टर करने के लिए:

```json
{
  "useCaseId": "assembly-line-qa",
  "customMetadataFilters": [
    { "key": "line_id", "operator": "eq", "value": "line-3" },
    { "key": "shift", "operator": "eq", "value": "morning" }
  ]
}
```

### Vision Events क्वेरी करें

फ़िल्टर, समय सीमाओं, और पृष्ठीकरण के साथ vision events क्वेरी करें। यह एंडपॉइंट इवेंट प्रकार, डिवाइस संदर्भ, डिटेक्शन क्लासेस, कस्टम मेटाडेटा, और इवेंट-विशिष्ट फ़ील्ड्स के आधार पर फ़िल्टरिंग का समर्थन करता है।

**आवश्यक स्कोप:** `vision-events:read` या `device:read`

{% openapi src="/files/84d8c4861456d267a4e6a39f6a1609041832d8bb" path="/vision-events/query" method="post" %}
[openapi.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-dca3d4f164ead71d7f0d6953b9ac101065bf210f%2Fopenapi.yaml?alt=media)
{% endopenapi %}

#### अनुरोध का उदाहरण

```bash
curl -X POST "https://api.roboflow.com/vision-events/query" \\
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "useCaseId": "a1b3c8e1",
    "startTime": "2024-01-14T00:00:00Z",
    "endTime": "2024-01-15T23:59:59Z",
    "eventTypes": ["quality_check", "safety_alert"],
    "customMetadataFilters": [
      {
        "field": "temperature",
        "operator": "gt",
        "value": 70,
        "type": "number"
      }
    ],
    "limit": 50
  }'
```

#### अनुरोध बॉडी पैरामीटर

**आवश्यक फ़ील्ड्स:**

* **`useCaseId`** (string): इवेंट्स क्वेरी करने के लिए उपयोग केस ID। देखें [उपयोग मामले](/deployment/hi/monitoring-and-analytics/vision-events/use-cases.md) यह जानने के लिए कि अपना उपयोग केस ID कैसे खोजें।

**समय सीमा फ़िल्टर:**

* **`startTime`** (string, ISO 8601, वैकल्पिक): समय सीमा की शुरुआत।
* **`endTime`** (string, ISO 8601, वैकल्पिक): समय सीमा का अंत।

**इवेंट प्रकार फ़िल्टर:**

* **`eventTypes`** (strings की array, अधिकतम 20, वैकल्पिक): एक या अधिक इवेंट प्रकारों तक फ़िल्टर करें।

**संदर्भ फ़िल्टर:**

प्रत्येक संदर्भ फ़िल्टर एक ऑब्जेक्ट है जिसमें `operator` और `value`:

* **`deviceId`** (object, वैकल्पिक): डिवाइस के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`.
* **`streamId`** (object, वैकल्पिक): स्ट्रीम के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`.
* **`workflowId`** (object, वैकल्पिक): वर्कफ़्लो के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`.
* **`externalId`** (object, वैकल्पिक): बाहरी ID के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`.

```json
{
  "deviceId": { "operator": "eq", "value": "camera-node-5" }
}
```

**डिटेक्शन फ़िल्टर:**

* **`detection`** (object, वैकल्पिक): डिटेक्शन क्लास नाम के आधार पर इवेंट्स फ़िल्टर करें, वैकल्पिक रूप से प्रति-डिटेक्शन confidence threshold के साथ। ऑपरेटर: `eq`, `neq`, `in`, `not_in`. के लिए `in` और `not_in`, मान के रूप में strings की एक array पास करें (अधिकतम 50)।
  * **`confidence`** (object, वैकल्पिक): प्रति-डिटेक्शन confidence threshold। केवल के साथ समर्थित `eq` और `in` क्लास ऑपरेटर। क्लास और confidence एक ही डिटेक्शन पर मेल खानी चाहिए।
    * **`operator`** (string): इनमें से एक `gt`, `gte`, `lt`, `lte`.
    * **`value`** (number): 0 और 1 के बीच confidence threshold।

```json
{
  "detection": { "operator": "in", "value": ["defect", "crack"] }
}
```

न्यूनतम confidence के साथ क्लास के अनुसार फ़िल्टर करें:

```json
{
  "detection": {
    "operator": "eq",
    "value": "scratch",
    "confidence": { "operator": "gte", "value": 0.8 }
  }
}
```

{% hint style="info" %}
The `detection` फ़िल्टर का पहले नाम था `detectionClass`. पुराना नाम अब स्वीकार नहीं किया जाता।
{% endhint %}

**मीडिया और चेतावनी फ़िल्टर:**

* **`imageCount`** (object, वैकल्पिक): इवेंट से संलग्न छवियों की संख्या के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`.
* **`videoCount`** (object, वैकल्पिक): इवेंट से संलग्न वीडियो की संख्या के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`. उपयोग करें `{ "operator": "gte", "value": 1 }` वीडियो वाले इवेंट्स खोजने के लिए।
* **`hasWarnings`** (boolean, वैकल्पिक): उन इवेंट्स के लिए फ़िल्टर करें जिनमें ingestion चेतावनियाँ हैं या नहीं हैं।

```json
{
  "imageCount": { "operator": "gte", "value": 1 }
}
```

**कस्टम मेटाडेटा फ़िल्टर:**

* **`customMetadataFilters`** (array, अधिकतम 20, वैकल्पिक): कस्टम मेटाडेटा फ़ील्ड्स के आधार पर फ़िल्टर करें। प्रत्येक फ़िल्टर में है:
  * **`field`** (string): मेटाडेटा फ़ील्ड का नाम।
  * **`operator`** (string): तुलना ऑपरेटर।
  * **`value`**: तुलना करने के लिए मान।
  * **`type`** (string): मान का प्रकार, इनमें से एक `string`, `number`, या `boolean`.

प्रकार के अनुसार उपलब्ध ऑपरेटर:

| प्रकार    | ऑपरेटर                                |
| --------- | ------------------------------------- |
| `string`  | `eq`, `neq`, `in`, `not_in`           |
| `number`  | `eq`, `neq`, `gt`, `gte`, `lt`, `lte` |
| `boolean` | `eq`, `neq`                           |

**इवेंट फ़ील्ड फ़िल्टर:**

* **`eventFieldFilters`** (array, अधिकतम 20, वैकल्पिक): इवेंट-विशिष्ट फ़ील्ड्स के आधार पर फ़िल्टर करें। प्रत्येक फ़िल्टर में है:
  * **`column`** (string): इनमें से एक `result`, `location`, `item_count`, `item_type`, `alert_type`, `severity`, या `feedback`.
  * **`operator`** (string): तुलना ऑपरेटर (`eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `in`, `not_in`).
  * **`value`**: तुलना करने के लिए मान।

```json
{
  "eventFieldFilters": [
    { "column": "result", "operator": "eq", "value": "fail" }
  ]
}
```

**पृष्ठीकरण:**

* **`cursor`** (string, वैकल्पिक): अगले पृष्ठ को लाने के लिए पिछले प्रतिक्रिया से cursor।
* **`limit`** (number, वैकल्पिक, डिफ़ॉल्ट 100, अधिकतम 1000): प्रति पृष्ठ लौटाए जाने वाले इवेंट्स की संख्या।

#### उदाहरण प्रतिक्रिया

{% tabs %}
{% tab title="200" %}

```json
{
  "events": [
    {
      "eventId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "eventType": "quality_check",
      "timestamp": "2024-01-15T10:30:00.000Z",
      "images": [
        {
          "label": "inspection-photo",
          "objectDetections": [
            {
              "class": "defect",
              "x": 100,
              "y": 200,
              "width": 50,
              "height": 30,
              "confidence": 0.95
            }
          ]
        }
      ],
      "videos": [
        { "sourceId": "Kq4vX8mNp2RtY6wZ1bCd", "label": "line-3 camera" }
      ],
      "eventData": {
        "result": "fail",
        "externalId": "batch-001"
      },
      "customMetadata": {
        "line": "A1",
        "temperature": 72.5
      }
    }
  ],
  "hasMore": false,
  "lookbackDays": 14
}
```

प्रत्येक वीडियो में केवल उसका `sourceId` और `लेबल`. इसे चलाने या डाउनलोड करने के लिए, [प्लेबैक URL प्राप्त करें](/deployment/hi/monitoring-and-analytics/vision-events/upload-a-vision-event-video.md#get-a-playback-url) इसके `sourceId`.

जब `hasMore` है `सही`, उपयोग करें `nextCursor` अपने अगले अनुरोध में मान का उपयोग करके परिणामों का अगला पृष्ठ प्राप्त करें:

```json
{
  "events": [...],
  "hasMore": true,
  "nextCursor": "eyJ0aW1lc3RhbXAiOiIyMDI0LTAxLTE1IiwiZXZlbnRJZCI6InFjLTAwMSJ9",
  "lookbackDays": 14
}
```

{% endtab %}

{% tab title="400" %}

```json
{
  "error": "Invalid query: useCaseId is required"
}
```

{% endtab %}

{% tab title="403" %}

```json
{
  "error": "इस संसाधन के लिए पर्याप्त अनुमतियाँ नहीं हैं."
}
```

{% endtab %}
{% endtabs %}

## Python SDK

फ़िल्टर, समय सीमाओं, और पृष्ठीकरण के साथ vision events क्वेरी करें।

### एक-पृष्ठ क्वेरी

उपयोग करें `query_vision_events()` परिणामों का एकल पृष्ठ लाने के लिए:

```python
import roboflow

roboflow.login()

rf = roboflow.Roboflow()
ws = rf.workspace()

page = ws.query_vision_events(
    "a1b3c8e1",                          # उपयोग केस ID (आवश्यक)
    event_type="quality_check",          # एकल इवेंट प्रकार के अनुसार फ़िल्टर करें
    start_time="2024-01-14T00:00:00Z",   # ISO 8601 प्रारंभ समय
    end_time="2024-01-15T23:59:59Z",     # ISO 8601 समाप्ति समय
    limit=50,                            # प्रति पृष्ठ अधिकतम इवेंट्स
)

for evt in page["events"]:
    print(evt["eventId"], evt["eventData"])
```

आप अतिरिक्त फ़िल्टर भी keyword arguments के रूप में पास कर सकते हैं। इन्हें सीधे API को भेज दिया जाता है:

```python
page = ws.query_vision_events(
    "a1b3c8e1",
    event_types=["quality_check", "safety_alert"],
    deviceId={"operator": "eq", "value": "camera-node-5"},
    customMetadataFilters=[
        {"field": "temperature", "operator": "gt", "value": 70, "type": "number"}
    ],
    eventFieldFilters=[
        {"column": "result", "operator": "eq", "value": "fail"}
    ],
)
```

मैनुअल पृष्ठीकरण के लिए, इसका उपयोग करें `cursor` पैरामीटर के साथ `nextCursor` पिछले प्रतिक्रिया से मान:

```python
all_events = []
page = ws.query_vision_events("a1b3c8e1", limit=100)
all_events.extend(page.get("events", []))

while page.get("hasMore"):
    page = ws.query_vision_events("a1b3c8e1", cursor=page["nextCursor"], limit=100)
    all_events.extend(page.get("events", []))
```

### सभी परिणामों में पृष्ठीकरण करें

उपयोग करें `query_all_vision_events()` सभी मिलते-जुलते इवेंट्स में स्वतः पृष्ठीकरण करने के लिए। यह एक बार में इवेंट्स का एक पृष्ठ देता है:

```python
all_events = []

for page in ws.query_all_vision_events(
    "a1b3c8e1",
    event_type="quality_check",
    start_time="2024-01-14T00:00:00Z",
    end_time="2024-01-15T23:59:59Z",
):
    all_events.extend(page)

print(f"{len(all_events)} इवेंट्स मिले")
```

उपलब्ध फ़िल्टर, ऑपरेटर, और प्रतिक्रिया प्रारूपों के पूर्ण विवरण के लिए, देखें [REST API संदर्भ](#http-api).

## MCP Server

अपने AI agent को [MCP Server](https://docs.roboflow.com/agents/mcp-server) और यह इन टूल्स के साथ आपके इवेंट्स के बारे में प्रश्नों का उत्तर दे सकता है:

<table data-search="false"><thead><tr><th width="290">टूल</th><th>विवरण</th></tr></thead><tbody><tr><td><code>vision_events_query</code></td><td>फ़िल्टर और पृष्ठीकरण के साथ production vision events क्वेरी करें।</td></tr><tr><td><code>vision_events_use_cases_list</code></td><td>workspace में vision event use cases सूचीबद्ध करें।</td></tr><tr><td><code>vision_events_custom_metadata_schema_get</code></td><td>किसी use case के लिए खोजा गया custom metadata schema प्राप्त करें।</td></tr></tbody></table>