> 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/models/hi/model-ids.md).

# मॉडल आईडी

प्रशिक्षित प्रत्येक मॉडल का एक मॉडल ID होता है, जो उसे तब पहचानता है जब आप उसे डिप्लॉय करते हैं, इन्फरेंस चलाते हैं, या Workflow मॉडल ब्लॉक में उसे चुनते हैं। यह पेज मॉडल IDs की वर्तमान संरचना के साथ-साथ यह भी बताता है कि कुछ परिस्थितियों में ID का पिछला (लेगसी) फ़ॉर्मैट अभी भी कैसे समर्थित है।

## मॉडल ID संरचना

एक मॉडल ID का स्वरूप होता है `{workspace}/{model-slug}`. पहला भाग आपका Workspace URL slug है। दूसरा भाग, मॉडल slug, workspace के भीतर मॉडल की पहचान करता है और हाइफ़न से जुड़े चार भागों से बना होता है:

```
{project}-{version}-{architecture}-t{n}
```

* `project`: उस प्रोजेक्ट का URL slug जिससे मॉडल संबंधित है। उदाहरण: `construction-safety-xpv3w`.
* `version`: उस dataset version की संख्या जिस पर मॉडल को प्रशिक्षित किया गया था। उदाहरण: `12`.
* `architecture`: प्रशिक्षण के लिए उपयोग की गई मॉडल आर्किटेक्चर। उदाहरण: `rfdetr-small`.
* `t{n}`: version के लिए एक training counter। किसी version पर शुरू हुआ पहला training t1 है, दूसरा t2, और इसी तरह आगे।

उदाहरण के लिए, किसी प्रोजेक्ट के version 3 पर दूसरा RF-DETR Small training, जिसके URL slug `construction-safety-xpv3w` workspace में `my-workspace` है, निम्न मॉडल ID उत्पन्न करता है `my-workspace/construction-safety-xpv3w-3-rfdetr-small-t2`.

मॉडल slug प्रशिक्षण शुरू होते ही असाइन कर दिया जाता है, इसलिए आप प्रशिक्षण के दौरान ही देख सकते हैं कि मॉडल का ID क्या होगा। Training counter suffixes कभी दोबारा उपयोग नहीं किए जाते: यदि कोई training विफल हो जाती है या रद्द कर दी जाती है, तो उसका नंबर छोड़ दिया जाता है और version पर अगला training अगला नंबर लेता है।

एक [न्यूरल आर्किटेक्चर सर्च](/models/hi/train/neural-architecture-search.md) training कई candidate models उत्पन्न करता है। NAS candidate model IDs अन्य model IDs जैसे दिखते हैं, लेकिन इनके अंत में एक डबल हाइफ़न और 6-अक्षरों वाला हैश जोड़ा जाता है (उदाहरण: `my-workspace/construction-safety-xpv3w-3-rfdetr-nas-t1--9589f2`)। v2 trainings endpoints में, एक NAS training अपना `modelType` रिपोर्ट करता है `rfdetr-nas-parent`के रूप में, जबकि इसके प्रत्येक candidate model रिपोर्ट करता है `rfdetr-nas`.

## एक मॉडल ID खोजें

आप web UI, REST API, या Roboflow MCP Server के माध्यम से किसी भी प्रशिक्षित मॉडल का ID देख सकते हैं।

{% tabs %}
{% tab title="वेब UI" %}
अपने project sidebar में "Models" पर क्लिक करके [Models पेज](/models/hi/evaluate/view-trained-models.md)खोलें। प्रत्येक मॉडल अपने ID को "ID:" लेबल के पास दिखाता है, और उसके पास एक "Copy Model ID" बटन होता है। वही ID और copy बटन मॉडल के detail view में और प्रत्येक version पेज पर models table में भी दिखाई देते हैं।
{% endtab %}

{% tab title="REST API" %}
the [List Project Models](https://docs.roboflow.com/platform/workspaces/list-workspaces-and-projects#list-project-models) endpoint प्रोजेक्ट में प्रशिक्षित हर मॉडल को लौटाता है। प्रत्येक entry के response में `url` फ़ील्ड मॉडल ID होता है:

```
GET https://api.roboflow.com/{workspace}/{project}/models?api_key=YOUR_API_KEY
```

```json
[
  {
    "url": "my-workspace/construction-safety-xpv3w-3-rfdetr-small-t2",
    "version": "3",
    "modelType": "rfdetr-small",
    "train": { "status": "finished" },
    ...
  },
  ...
]
```

किसी विशिष्ट version पर प्रशिक्षित models खोजने के लिए v2 trainings endpoints का उपयोग करें। किसी version की trainings की सूची बनाने पर प्रत्येक training के साथ उसके द्वारा बनाए गए models के IDs उसके `modelIds` फ़ील्ड में लौटते हैं। किसी legacy single-model version में, training `id` का पथ इस स्वरूप का होता है `{workspaceId}/{version}/training/0` (नीचे दिखाए गए hash के बजाय), और `modelIds` version की [legacy ID](#legacy-model-ids) को शामिल करता है:

```
GET https://api.roboflow.com/{workspace}/{project}/{version}/v2/trainings?api_key=YOUR_API_KEY
```

```json
{
  "trainings": [
    {
      "id": "0a1b2c3d4e5f67890abc",
      "versionId": "3",
      "status": "finished",
      "modelType": "rfdetr-small",
      "modelIds": ["my-workspace/construction-safety-xpv3w-3-rfdetr-small-t2"],
      ...
    },
    ...
  ]
}
```

एक single training प्राप्त करने पर प्रति-model विवरण लौटते हैं, जिसमें प्रत्येक model का ID उसके `modelId` फ़ील्ड में शामिल होता है `models` की सूची। आप `trainingId` को छोड़ सकते हैं जब version में केवल एक training हो, लेकिन यदि version में कई trainings हों तो ऐसा अनुरोध 409 error के साथ विफल हो जाता है।

```
GET https://api.roboflow.com/{workspace}/{project}/{version}/v2/trainings/get?api_key=YOUR_API_KEY&trainingId={trainingId}
```

```json
{
  "trainingId": "0a1b2c3d4e5f67890abc",
  "versionId": "3",
  "status": "finished",
  "modelType": "rfdetr-small",
  "modelCount": 1,
  "models": [
    {
      "modelId": "my-workspace/construction-safety-xpv3w-3-rfdetr-small-t2",
      "modelType": "rfdetr-small",
      "status": "finished",
      "metrics": { ... }
    }
  ],
  ...
}
```

{% endtab %}

{% tab title="MCP" %}
the [Roboflow MCP Server](https://docs.roboflow.com/agents/mcp-server) ऐसे टूल्स प्रदान करता है जो model IDs लौटाते हैं। `models_list` एक प्रोजेक्ट के trained models की सूची देता है (workspace connection के credentials से आता है, और project को `project_id`के रूप में पास किया जाता है) और प्रत्येक model का ID उसके `url` फ़ील्ड में लौटाता है, version या NAS run द्वारा वैकल्पिक फ़िल्टरिंग के साथ। `trainings_get` और `trainings_list` प्रत्येक training द्वारा बनाए गए models के IDs लौटाते हैं। Agents इन IDs को अन्य tools, जैसे `models_infer`.
{% endtab %}
{% endtabs %}

## लेगेसी मॉडल IDs

पहले, Roboflow dataset versions पर केवल एक training run हो सकती थी, इसलिए models को एक ऐसे ID द्वारा विशिष्ट रूप से पहचाना जाता था जिसका स्वरूप होता था `{project}/{version}`.

उदाहरण के लिए, `construction-site-safety/3` का उपयोग किया जाता था *उस* project के version 3 पर प्रशिक्षित model को संदर्भित करने के लिए। पहला भाग project URL slug है, workspace नहीं, और दूसरा भाग version number है। यही फ़ॉर्मैट पुराने SDKs, code snippets, और Inference installations उपयोग करते हैं (उदाहरण: `model_id="construction-site-safety/3"`).

चूँकि अब किसी dataset version पर [एक से अधिक training](/models/hi/versions-trainings-and-models.md) चलाना संभव है, इसलिए इस legacy-format IDs को अब प्राथमिकता नहीं दी जाती। यदि आप 30 जून, 2026 के बाद शुरू की गई नई trainings के लिए ऐसे IDs का उपयोग करने की कोशिश करते हैं, तो वे पीछे से नए style के ID में resolve हो जाएँगे।

## लेगेसी IDs कैसे resolve होती हैं

Legacy-format IDs aliases के माध्यम से काम करती रहती हैं। जब किसी version पर शुरू हुआ पहला training सफलतापूर्वक पूरा हो जाता है, तो Roboflow version की legacy `{project}/{version}` ID को नए model ID से लिंक कर देता है। Legacy ID का उपयोग करने वाले अनुरोध, जिनमें पुराने Inference installations से weights downloads भी शामिल हैं, अपने आप उस model तक resolve हो जाते हैं।

Alias केवल version पर *पहले* training द्वारा बनाया जाता है और बाद में नहीं बदलता:

* यदि पहला training सफलतापूर्वक पूरा हो जाता है, तो legacy ID स्थायी रूप से उसी model को संदर्भित करती है, भले ही आप उसी version पर बाद में और models train करें। बाद के models को उनके अपने model IDs से संदर्भित करें।
* यदि पहला training विफल हो जाता है या रद्द कर दिया जाता है, तो कोई alias नहीं बनाया जाता, और version पर बाद की trainings कोई alias नहीं बनातीं।

जिस version के पास alias नहीं है, उसे उसकी legacy ID से तब तक संदर्भित किया जा सकता है जब तक उसमें ठीक एक model हो। यदि उसमें कई models हों और कोई alias न हो, तो legacy ID का उपयोग करने वाले अनुरोध विफल हो जाते हैं क्योंकि संदर्भ अस्पष्ट है, और आपको model की अपनी ID का उपयोग करना होगा।

{% hint style="info" %}
Legacy IDs backward compatibility के लिए मौजूद हैं। नई integrations में full model IDs को प्राथमिकता दें: वे अस्पष्ट नहीं होते और version के हर model के लिए काम करते हैं।
{% endhint %}