> 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/roboflow-cloud/serverless-api.md).

# Serverless Cloud API

Roboflow cloud में GPU-accelerated auto-scaling infrastructure पर Workflows और Model Inference चलाएँ।

## परिचय

Roboflow पर डिप्लॉय किए गए मॉडल में इमेज पर इनफ़रेंस के लिए REST API होता है। इंटरनेट कनेक्शन पर हर अनुरोध के लिए इमेज और Workflow इनफ़रेंस करने के लिए इस पेज का उपयोग करें। प्रबंधित लाइव कैमरों के लिए उपयोग करें [क्लाउड स्ट्रीमिंग](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming.md); स्टोर की गई इमेज और वीडियो जॉब के लिए उपयोग करें [बैच प्रोसेसिंग](https://docs.roboflow.com/deployment/hi/roboflow-cloud/batch-processing.md).

ऐप में इस एंडपॉइंट को "सर्वरलेस क्लाउड API" या जहाँ जगह कम हो, वहाँ "क्लाउड API" कहा जाता है (जैसे Workflow एडिटर के रनटाइम चयनकर्ता में)। एक [डेडिकेटेड डिप्लॉयमेंट](https://docs.roboflow.com/deployment/hi/roboflow-cloud/dedicated-deployments.md) एंडपॉइंट (`*.roboflow.cloud`) को "डेडिकेटेड क्लाउड API" और पुराने v1 एंडपॉइंट को "होस्टेड API (लेगेसी)" कहा जाता है। ये लेबल पहले इस्तेमाल होने वाले "सर्वरलेस होस्टेड API" और "सर्वरलेस API V2" नामों की जगह लेते हैं।

आप सर्वरलेस क्लाउड API का उपयोग कर सकते हैं:

* [Workflows में](https://docs.roboflow.com/deployment/hi/roboflow-cloud/serverless-api/use-in-a-workflow.md)
* [REST API के साथ](#http-api)
* इसके साथ: [Inference Python SDK](#python-sdk)

### Inference सर्वर

सर्वरलेस क्लाउड API [Inference Server](https://docs.roboflow.com/deployment/hi/self-hosted/inference-server.md) के अनुरोध इंटरफ़ेस का उपयोग करता है। समर्थित इमेज इनफ़रेंस मेथड के लिए, नीचे दिखाए अनुसार इसे बदलकर रनटाइम बदलें: `api_url`। इससे कोई वीडियो इंटीग्रेशन क्लाउड स्ट्रीमिंग में माइग्रेट नहीं होता।

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

CLIENT = InferenceHTTPClient(
    # api_url="http://localhost:9001" # सेल्फ़-होस्टेड Inference सर्वर
    api_url="https://serverless.roboflow.com", # हमारा सर्वरलेस क्लाउड API
    api_key="API_KEY" # अपने निजी मॉडल और डेटा तक पहुँचने के लिए वैकल्पिक
).configure(InferenceConfiguration(api_key_transport="header"))

result = CLIENT.infer("image.jpg", model_id="model-id/1")
print(result)
```

यह `api_key_transport="header"` सेटिंग कुंजी को केवल `Authorization: Bearer` हेडर में भेजती है, जिससे वह URL और लॉग में नहीं आती। सभी नए कोड के लिए यही अनुशंसित है। Inference 1.5.0 से पुराने सर्वर हेडर नहीं पढ़ते; अगर आप अब भी ऐसे किसी सर्वर को कॉल करते हैं, तो इसका उपयोग करें: `api_key_transport="both"` । देखें [API कुंजी ट्रांसपोर्ट](https://docs.roboflow.com/reference/inference/inference-sdk/configuration#api-key-transport).

### सीमाएँ

इमेज इनफ़रेंस का बिल प्रति इमेज क्रेडिट में, मॉडल द्वारा तय दर पर लिया जाता है। देखें [सर्वरलेस मूल्य निर्धारण](https://docs.roboflow.com/deployment/hi/roboflow-cloud/serverless-api/model-pricing.md).

हमारा सर्वरलेस क्लाउड API 20MB तक की फ़ाइल अपलोड का समर्थन करता है। अधिक रिज़ॉल्यूशन वाली इमेज के साथ आपको सीमाओं का सामना करना पड़ सकता है। अगर कोई समस्या आए, तो कृपया अपने एंटरप्राइज़ सहायता संपर्क से संपर्क करें या यहाँ संदेश पोस्ट करें: [फ़ोरम](https://discuss.roboflow.com).

{% hint style="info" %}
यदि अनुरोध बहुत बड़े हों, तो हम संलग्न छवियों का आकार घटाने की सलाह देते हैं। आम तौर पर इससे प्रदर्शन खराब नहीं होता, क्योंकि हमारे सर्वर पर प्राप्त होने के बाद छवियों का आकार घटाकर मॉडल आर्किटेक्चर द्वारा स्वीकार किए जाने वाले इनपुट आकार के अनुरूप कर दिया जाता है।\
\
हमारे कुछ SDK, जैसे Python SDK, API को भेजने से पहले छवियों का आकार घटाकर मॉडल आर्किटेक्चर के इनपुट आकार के अनुरूप अपने-आप कर देते हैं।
{% endhint %}

***

देखें [सर्वरलेस क्लाउड API v1](https://docs.roboflow.com/deployment/hi/legacy/legacy-serverless.md) लेगेसी API दस्तावेज़ के लिए।

## HTTP API

### REST API के साथ उपयोग करें

सर्वरलेस क्लाउड API में सभी मॉडल और Workflows के लिए एक ही एंडपॉइंट है:

```
https://serverless.roboflow.com
```

#### HTTP एंडपॉइंट

{% openapi src="/files/9ca3f79038ca18d1a4682517ec9225755432921a" path="/{dataset\_id}/{version\_id}" method="post" %}
[serverless-api.json](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-6960e5f5b0f490b735257ca7203facdf44a31965%2Fserverless-api.json?alt=media)
{% endopenapi %}

{% openapi src="/files/9ca3f79038ca18d1a4682517ec9225755432921a" path="/{workspace\_name}/workflows/{workflow\_id}" method="post" %}
[serverless-api.json](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-6960e5f5b0f490b735257ca7203facdf44a31965%2Fserverless-api.json?alt=media)
{% endopenapi %}

### इमेज पर मॉडल चलाएँ

Roboflow कई रनटाइम के माध्यम से इनफ़रेंस उपलब्ध कराता है। सही विकल्प इस पर निर्भर करता है कि आप एक मॉडल को कॉल कर रहे हैं या Workflow को, आपको कितने थ्रूपुट की ज़रूरत है और वर्कलोड कहाँ चलता है।

यह पेज एक संक्षिप्त अवलोकन है। विस्तृत इनफ़रेंस संदर्भ यहाँ उपलब्ध है: [उत्पाद दस्तावेज़](https://docs.roboflow.com/deployment/hi/readme.md), जो इसी दस्तावेज़ साइट का हिस्सा है। विस्तृत जानकारी के लिए संबंधित लिंक दिए गए हैं।

#### इनफ़रेंस रनटाइम

| रनटाइम                                               | कब उपयोग करें                                                                                                  | संदर्भ                                                                                                                                                                                                                  |
| ---------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Serverless Cloud API** (`serverless.roboflow.com`) | डिफ़ॉल्ट। होस्टेड, ऑटो-स्केलिंग; मॉडल और Workflows को सपोर्ट करता है।                                          | [Serverless Cloud API](https://docs.roboflow.com/deployment/hi/roboflow-cloud/serverless-api.md)                                                                                                                        |
| **Dedicated Deployments**                            | जब आपको अनुमानित लेटेंसी, उच्च थ्रूपुट या GPU का निश्चित प्रकार चाहिए। Roboflow द्वारा प्रबंधित।               | [Dedicated Deployments](https://docs.roboflow.com/deployment/hi/roboflow-cloud/dedicated-deployments.md#http-api) और [उत्पाद का परिचय](https://docs.roboflow.com/deployment/hi/roboflow-cloud/dedicated-deployments.md) |
| **Roboflow Inference** (स्वयं होस्ट किया गया)        | ऑन-प्रिमाइसेस, एज डिवाइस, एयर-गैप्ड परिवेश या ऐसे वर्कलोड जिन्हें आपके VPC से बाहर नहीं जाना चाहिए। ओपन सोर्स। | [सेल्फ-होस्टेड डिप्लॉयमेंट](https://docs.roboflow.com/deployment/hi/self-hosted/self-hosted.md)                                                                                                                         |

{% hint style="info" %}
कुंजी को `?api_key=` क्वेरी पैरामीटर या `api_key` बॉडी फ़ील्ड के रूप में भेजना पुराना तरीका है। यह अब भी काम करता है, लेकिन `Authorization: Bearer` हेडर आपकी कुंजी को URL और लॉग में शामिल होने से बचाता है। देखें [REST API से प्रमाणित करें](https://docs.roboflow.com/reference/platform/rest-api/authenticate-with-the-rest-api).
{% endhint %}

प्रबंधित लाइव वीडियो के लिए, उपयोग करें [Cloud Streaming](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming.md). संग्रहित छवियों और वीडियो के सेट को असिंक्रोनस रूप से प्रोसेस करने के लिए, उपयोग करें [Batch Processing](https://docs.roboflow.com/deployment/hi/roboflow-cloud/batch-processing.md).

#### बहिष्कृत: Serverless v1

पुराने, कार्य-विशिष्ट एंडपॉइंट— `detect.roboflow.com`, `classify.roboflow.com`, `outline.roboflow.com`, `segment.roboflow.com` — **बहिष्कृत**. वे पुराने संस्करणों के साथ संगतता के लिए अब भी जवाब देते हैं, लेकिन नए कोड में इनका उपयोग होना चाहिए `serverless.roboflow.com` इसके बजाय।

अगर आपको ऐसा कोड स्निपेट मिले जो किसी `*.roboflow.com` टास्क होस्ट की ओर संकेत करता हो, तो उसे पुराना मानें और ऊपर दिए गए Serverless Cloud API फ़ॉर्मैट में बदलें।

## Python SDK

### Python SDK के साथ उपयोग करें

अगर आप Python में काम कर रहे हैं, तो Serverless Cloud API के साथ इंटरैक्ट करने का सबसे आसान तरीका Inference Python SDK का उपयोग करना है।

उपयोग करने के लिए [Inference SDK](https://docs.roboflow.com/reference/inference/inference-sdk), पहले इसे इंस्टॉल करें:

```
pip install inference-sdk
```

Serverless Cloud API को अनुरोध भेजने के लिए, निम्नलिखित कोड का उपयोग करें:

<pre class="language-python"><code class="lang-python"><strong>from inference_sdk import InferenceHTTPClient, InferenceConfiguration
</strong>
CLIENT = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key="API_KEY"
).configure(InferenceConfiguration(api_key_transport="header"))

result = CLIENT.infer("image.jpg", model_id="model-id/1")
print(result)
</code></pre>

ऊपर, अपना [मॉडल ID](https://docs.roboflow.com/reference/authentication/authentication/workspace-and-project-ids) और [API key](https://docs.roboflow.com/reference/authentication/authentication/find-your-roboflow-api-key)निर्दिष्ट करें। यह कोड आपका मॉडल चलाएगा और परिणाम लौटाएगा।

#### Roboflow Instant Model

Serverless Cloud API, Roboflow [Instant Model](https://docs.roboflow.com/models/train/roboflow-instant)को चलाने की सुविधा भी देता है। आप Instant Model को किसी भी अन्य मॉडल की तरह चला सकते हैं। ध्यान दें कि Instant Models के लिए confidence threshold संवेदनशील हो सकती है।

{% hint style="info" %}
अनुकूल confidence इस बात पर निर्भर करता है कि मॉडल को कितनी छवियों पर प्रशिक्षित किया गया है। अनुकूल confidence thresholds आमतौर पर 0.85 से 0.99 तक होती हैं।
{% endhint %}

```python
configuration = InferenceConfiguration(
    confidence_threshold=0.95,
    api_key_transport="header",
)
CLIENT.configure(configuration)

result = CLIENT.infer("image.jpg", model_id="roboflow-instant-model-id/1")
```

`configure(...)` पूरे कॉन्फ़िगरेशन को बदल देता है, इसलिए `api_key_transport` को लागू किए जाने वाले किसी भी कॉन्फ़िगरेशन में शामिल रखें।

### Python SDK से वीडियो स्ट्रीम करें

{% hint style="info" %}
नीचे दिए गए उदाहरण में अप्रचलित [Serverless Video Streaming API](https://docs.roboflow.com/deployment/hi/roboflow-cloud/serverless-api/serverless-video-streaming-api.md) का उपयोग किया गया है और इसे मौजूदा इंटिग्रेशन के लिए यहाँ रखा गया है। नए प्रबंधित लाइव-कैमरा प्रोसेसिंग के लिए [Cloud Streaming](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming.md)का उपयोग करें। संग्रहित फ़ाइलों के सीमित जॉब के लिए [Batch Processing](https://docs.roboflow.com/deployment/hi/roboflow-cloud/batch-processing.md).
{% endhint %}

यह पुराना WebRTC उदाहरण वीडियो पर ऑब्जेक्ट डिटेक्शन मॉडल चलाता है और प्रोसेस किए गए फ़्रेम तथा भविष्यवाणियाँ लौटाता है।

SDK को इसकी WebRTC निर्भरताओं और `supervision`:

```bash
pip install "inference-sdk[webrtc]" supervision
```

```python
import cv2
import supervision as sv
from inference_sdk import InferenceHTTPClient
from inference_sdk.webrtc import VideoFileSource

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key="API_KEY",
)

session = client.webrtc.stream(
    source=VideoFileSource("video.mp4"),
    model_id="model-id/1",
)

box_annotator = sv.BoxAnnotator()
label_annotator = sv.LabelAnnotator()

@session.on_frame
def show(frame, data):
    if data is None:
        return

    detections = sv.Detections.from_inference(data)
    annotated = box_annotator.annotate(frame.copy(), detections)
    annotated = label_annotator.annotate(annotated, detections)
    cv2.imshow("Predictions", annotated)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        session.close()

session.run()
cv2.destroyAllWindows()
```

बदलें `API_KEY` और `model-id/1` को अपनी API key और model ID से बदलें। देखें [पुराना API संदर्भ और माइग्रेशन गाइड](https://docs.roboflow.com/deployment/hi/roboflow-cloud/serverless-api/serverless-video-streaming-api.md) पुराने कॉन्फ़िगरेशन के लिए, या [स्व-होस्टेड WebRTC](https://docs.roboflow.com/reference/inference/inference-sdk/webrtc) को अपने सर्वर पर चलाने के लिए।

## CLI

Roboflow पर प्रशिक्षित मॉडल या उपलब्ध ओपन सोर्स मॉडल चलाने के लिए आप Roboflow CLI का उपयोग कर सकते हैं [Roboflow Universe](https://universe.roboflow.com).

कमांड लाइन में `roboflow infer` चलाने पर, CLI इमेज को Roboflow API पर भेजता है और भविष्यवाणियाँ प्रिंट करता है।

### कमांड

```bash
roboflow infer <image-path> -m <project/version>
```

#### विकल्प

| फ़्लैग               | विवरण                                                                                                                                              |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-m`, `--model`      | इस प्रारूप में मॉडल ID: `project/version`  (आवश्यक)                                                                                                |
| `-c`, `--confidence` | कॉन्फिडेंस थ्रेशोल्ड, 0.0–1.0 (डिफ़ॉल्ट: 0.5)                                                                                                      |
| `-o`, `--overlap`    | ओवरलैप/NMS थ्रेशोल्ड, 0.0–1.0 (डिफ़ॉल्ट: 0.5)                                                                                                      |
| `-t`, `--type`       | मॉडल का प्रकार (ऑटो-डिटेक्शन छोड़ें): `object-detection`, `classification`, `instance-segmentation`, `semantic-segmentation`, `keypoint-detection` |

### उदाहरण

Roboflow Universe के किसी ओपन सोर्स मॉडल से इन्फ़रेंस चलाएँ—उदाहरण के लिए, [poker-cards](https://universe.roboflow.com/roboflow-100/poker-cards-cxcvz/model/1) डेटासेट:

```bash
roboflow infer ~/Downloads/ace.jpg -m poker-cards-cxcvz/1 -c 0.7
```

वर्कस्पेस डिफ़ॉल्ट रूप से आपके कॉन्फ़िगर किए गए वर्कस्पेस पर सेट होता है। किसी दूसरे वर्कस्पेस का मॉडल इस्तेमाल करने के लिए:

```bash
roboflow infer photo.jpg -m poker-cards-cxcvz/1 -w roboflow-100
```

ऑटो-डिटेक्शन API कॉल छोड़ने के लिए मॉडल का प्रकार निर्दिष्ट करें:

```bash
roboflow infer photo.jpg -m my-project/3 -t object-detection
```

### JSON आउटपुट

इस्तेमाल करें `--json` स्क्रिप्टिंग और ऑटोमेशन के लिए संरचित प्रेडिक्शन डेटा पाने हेतु:

```bash
roboflow infer photo.jpg -m my-project/3 --json
```

```json
{
  "predictions": [
    {
      "x": 1230.0,
      "y": 814.5,
      "width": 840.0,
      "height": 1273.0,
      "confidence": 0.882,
      "class": "Scissors",
      "class_id": 2
    }
  ]
}
```

सभी समर्थित पैरामीटर देखने के लिए चलाएँ `roboflow infer --help`.

## MCP Server

अपने AI एजेंट को [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>models_infer</code></td><td>प्रशिक्षित मॉडल का उपयोग करके किसी इमेज पर होस्टेड इन्फ़रेंस चलाएँ।</td></tr><tr><td><code>workflows_run</code></td><td>एक या अधिक इमेज पर सेव किए गए Workflow को चलाएँ।</td></tr><tr><td><code>project_deployment_run</code></td><td>प्रोजेक्ट के स्थिर लाइव एंडपॉइंट के ज़रिए इन्फ़रेंस चलाएँ।</td></tr></tbody></table>
