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

# 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="/files/6d0a523754b27150958f4a890ecedbee2797f4ac" alt="" width="375"><figcaption></figcaption></figure>

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

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

* **तिथि सीमा** - प्रारंभ और समाप्त टाइमस्टैम्प
* **इवेंट प्रकार** - quality\_check, inventory\_count, safety\_alert, custom, operator\_feedback
* **डिवाइस** - डिवाइस ID के अनुसार फ़िल्टर करें
* **स्ट्रीम** - स्ट्रीम या कैमरा ID के अनुसार फ़िल्टर करें
* **वर्कफ़्लो** - उस वर्कफ़्लो के अनुसार फ़िल्टर करें जिसने इवेंट्स उत्पन्न किए
* **डिटेक्शन** - किसी पहचानी गई ऑब्जेक्ट श्रेणी के अनुसार फ़िल्टर करें, वैकल्पिक विश्वास-स्तर सीमा के साथ
* **फ़ीडबैक स्थिति** - सही, गलत, अनिश्चित, या कोई फ़ीडबैक नहीं
* **कस्टम मेटाडेटा** - किसी भी कस्टम मेटाडेटा फ़ील्ड और मान के अनुसार फ़िल्टर करें
* **चेतावनियाँ** - केवल वे इवेंट्स दिखाएँ जिनमें ingestion चेतावनियाँ थीं

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

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

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

<figure><img src="/files/17ae67b936d58a0772b9e843221323074760521c" alt="" width="375"><figcaption></figcaption></figure>

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

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

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

**डिटेक्शन दिखाएँ**

जब किसी इवेंट में प्रेडिक्शन डेटा (ऑब्जेक्ट डिटेक्शन, इंस्टेंस सेगमेंटेशन, या कीपॉइंट्स) होता है, तो छवि के ऊपर "Draw Detections" चेकबॉक्स दिखाई देता है। स्रोत छवि के ऊपर विश्वास स्कोर सहित बाउंडिंग बॉक्स, सेगमेंटेशन बहुभुज, और लेबल ओवरले करने के लिए इसे सक्षम करें।

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

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

**स्वतः-अंतिमीकृत इवेंट्स**

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

### Agent से पूछें

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

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

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

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

यदि कोई प्रश्न आपके वर्कस्पेस की [रिटेंशन विंडो](/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 के माध्यम से इवेंट्स क्वेरी करें

क्वेरी एंडपॉइंट डैशबोर्ड जैसे ही फ़िल्टरों का समर्थन करता है, साथ ही कर्सर-आधारित पृष्ठांकन भी। पैरामीटरों और प्रतिक्रिया फ़ील्ड्स की पूरी सूची के लिए देखें [Vision Events API संदर्भ](/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
}
```

#### पृष्ठांकन

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

```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` है `false`.

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

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

```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-2afefc06c784ca78eb7ec96a99bee48f8a2daaa5%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`** (स्ट्रिंग्स की array, अधिकतम 20, वैकल्पिक): एक या अधिक इवेंट प्रकारों तक फ़िल्टर करें।

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

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

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

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

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

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

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

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

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

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

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

* **`imageCount`** (ऑब्जेक्ट, वैकल्पिक): इवेंट से संलग्न छवियों की संख्या के आधार पर फ़िल्टर करें। ऑपरेटर: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`.
* **`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, वैकल्पिक): अगला पृष्ठ लाने के लिए पिछली प्रतिक्रिया का कर्सर।
* **`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
            }
          ]
        }
      ],
      "eventData": {
        "result": "fail",
        "externalId": "batch-001"
      },
      "customMetadata": {
        "line": "A1",
        "temperature": 72.5
      }
    }
  ],
  "hasMore": false,
  "lookbackDays": 14
}
```

जब `hasMore` है `true`तो `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": "Insufficient permissions for this resource."
}
```

{% 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"])
```

आप अतिरिक्त फ़िल्टर भी कीवर्ड आर्ग्युमेंट्स के रूप में पास कर सकते हैं। इन्हें सीधे 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", []))

जब 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 सर्वर

अपने AI एजेंट को कनेक्ट करें [MCP सर्वर](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>फ़िल्टर और पेजिनेशन के साथ प्रोडक्शन विज़न इवेंट्स को क्वेरी करें।</td></tr><tr><td><code>vision_events_use_cases_list</code></td><td>वर्कस्पेस में विज़न इवेंट उपयोग मामलों की सूची बनाएँ।</td></tr><tr><td><code>vision_events_custom_metadata_schema_get</code></td><td>किसी उपयोग मामले के लिए खोजी गई कस्टम मेटाडेटा स्कीमा प्राप्त करें।</td></tr></tbody></table>
