> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# प्रक्रियाएं

## ओवरव्यू

किसी प्रक्रिया में एक खास टास्क के लिए निर्देश होते हैं। हर प्रक्रिया का एक ट्रिगर होता है, जो बताता है कि वह कब लागू होती है, और कंटेंट होता है, जो बताता है कि क्या करना है। जब कोई बातचीत ट्रिगर से मेल खाती है, तो एजेंट प्रक्रिया को लोड कर लेता है।

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

![एजेंट डैशबोर्ड में प्रक्रियाएं
टैब](/docs/_fern-img/38b190b7a08cb9e628da309a86c5e4b315eabccf238a41d5d3a6c2646aba11af.webp)

## प्रक्रिया के प्रकार

प्रक्रियाएं दो तरह की होती हैं:

* **[फ्री-फ़ॉर्म प्रक्रियाएं](/docs/hi/eleven-agents/customization/procedures/free-form-procedures)** प्राकृतिक भाषा में लिखे निर्देश होते हैं, जिन्हें एजेंट समझता है और स्थिति के अनुसार अपनाता है।
* **[स्ट्रक्चर्ड प्रक्रियाएं](/docs/hi/eleven-agents/customization/procedures/structured-procedures)** टाइप किए गए चरणों की क्रमबद्ध सूची होती हैं, जिन्हें एजेंट हर बार एक ही तरह से चलाता है।

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

> **Tip**
>
> प्रक्रियाएं एक-दूसरे को कॉल कर सकती हैं। फ्री-फ़ॉर्म प्रक्रिया किसी दूसरी प्रक्रिया को [इनलाइन रेफरेंस](/docs/hi/eleven-agents/customization/procedures/free-form-procedures#inline-references) से कॉल करती है,
> और स्ट्रक्चर्ड प्रक्रिया किसी दूसरी स्ट्रक्चर्ड प्रक्रिया को
> [सब-प्रक्रिया](/docs/hi/eleven-agents/customization/procedures/structured-procedures#sub-procedure)
> चरण से कॉल करती है। एक सामान्य पैटर्न यह है कि खुले तरीके से संभालने वाले काम को फ्री-फ़ॉर्म प्रक्रिया में रखें और
> उन हिस्सों को स्ट्रक्चर्ड प्रक्रिया को सौंप दें जिन्हें हर बार एक ही तरह से चलाना ज़रूरी है।

किसी एजेंट में प्रक्रियाएं, [वर्कफ़्लो](/docs/hi/eleven-agents/customization/agent-workflows), या दोनों हो सकते हैं। जब दोनों मौजूद हों, तो वर्कफ़्लो के हर पॉइंट से हर प्रक्रिया उपलब्ध होती है; किसी प्रक्रिया को खास वर्कफ़्लो नोड्स तक सीमित नहीं किया जा सकता। ज़्यादातर एजेंट इनमें से किसी एक तरीके पर बनाए जाते हैं, लेकिन दोनों को साथ इस्तेमाल किया जा सकता है।

## प्रक्रियाओं का इस्तेमाल कब करें

हर एजेंट में एक [सिस्टम प्रॉम्प्ट](/docs/hi/eleven-agents/best-practices/prompting-guide) होता है। प्रक्रियाएं और [वर्कफ़्लो](/docs/hi/eleven-agents/customization/agent-workflows) इसके ऊपर संरचना जोड़ने के दो तरीके हैं, और एजेंट दोनों का इस्तेमाल कर सकता है। बातचीत में कितनी विविधता हो सकती है, उसके आधार पर शुरुआती तरीका चुनें।

| ज़रूरत                                             | इस्तेमाल करें                                                                                  | क्यों                                                                                                                                                                             |
| -------------------------------------------------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| आसान प्रूफ़-ऑफ़-कॉन्सेप्ट एजेंट                    | सिर्फ़ सिस्टम प्रॉम्प्ट                                                                        | सेट अप और बदलाव के लिए सबसे तेज़, लेकिन एजेंट का दायरा बढ़ने पर एक ही प्रॉम्प्ट संभालना मुश्किल हो जाता है।                                                                       |
| ऐसा टास्क जिसमें एजेंट शब्दों और क्रम को अपना सके  | [फ्री-फ़ॉर्म प्रक्रिया](/docs/hi/eleven-agents/customization/procedures/free-form-procedures)  | पूरी बातचीत एक LLM के कॉन्टेक्स्ट में रहती है, इसलिए एजेंट शब्दों और क्रम को अपना सकता है और अप्रत्याशित मोड़ संभाल सकता है। इसमें कॉन्टेक्स्ट विंडो का ज़्यादा इस्तेमाल होता है। |
| ऐसा टास्क जिसके चरण हर बार एक ही तरह से चलने चाहिए | [स्ट्रक्चर्ड प्रक्रिया](/docs/hi/eleven-agents/customization/procedures/structured-procedures) | हर चरण आपके तय क्रम में हर बार एक ही तरह से चलता है, और आप इसे चरणों की छोटी सूची के रूप में लिखते हैं।                                                                           |
| जटिल ब्रांचिंग और एज केस पर पूरा नियंत्रण          | [वर्कफ़्लो](/docs/hi/eleven-agents/customization/agent-workflows)                              | यह आपके डिज़ाइन और कनेक्ट किए गए सबएजेंट्स के ग्राफ़ के रूप में चलता है, जिसमें ब्रांचिंग और हर चरण में इस्तेमाल होने वाले मॉडल पर पूरा नियंत्रण होता है।                         |

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

## प्रक्रियाएं मैनेज करें

प्रक्रियाएं लिखने के लिए डैशबोर्ड सुझाया गया तरीका है। प्रोग्रामेटिक तरीके से प्रक्रियाएं मैनेज करने या उन्हें डिप्लॉयमेंट टूलिंग में शामिल करने के लिए CLI या API का इस्तेमाल करें।

#### डैशबोर्ड से बनाएं

[डैशबोर्ड](https://elevenlabs.io/app/agents) में अपना एजेंट खोलें, फिर **प्रक्रियाएं** चुनें।
फ्री-फ़ॉर्म या स्ट्रक्चर्ड प्रक्रिया बनाने के लिए **+** का इस्तेमाल करें। इसी मेन्यू से प्रक्रियाओं को
फ़ोल्डर्स में ग्रुप किया जा सकता है। लेखन संबंधी मार्गदर्शन के लिए
[फ्री-फ़ॉर्म प्रक्रियाएं](/docs/hi/eleven-agents/customization/procedures/free-form-procedures)
और
[स्ट्रक्चर्ड प्रक्रियाएं](/docs/hi/eleven-agents/customization/procedures/structured-procedures)
देखें।

#### CLI से मैनेज करें

[ElevenLabs CLI](/docs/hi/eleven-agents/operate/cli),
`elevenlabs agents procedures` कमांड ग्रुप से प्रक्रियाएं मैनेज करता है। पहले अपने एनवायरनमेंट में
`ELEVENLABS_API_KEY` सेट करें।

```bash
# List the procedures on a branch
elevenlabs agents procedures list \
  --agent-id agent_7101k5zvyjhmfg983brhmhkd98n6 \
  --branch-id agtbranch_0901k4aafjxxfxt93gd841r7tv5t

# Create a procedure
elevenlabs agents procedures create \
  --agent-id agent_7101k5zvyjhmfg983brhmhkd98n6 \
  --branch-id agtbranch_0901k4aafjxxfxt93gd841r7tv5t \
  --json '{"name": "Refund request", "type": "free_form", "trigger": "When the user asks to refund an order", "content": "Ask for the order ID."}'

# Publish every changed procedure draft on the branch
elevenlabs agents update \
  --agent-id agent_7101k5zvyjhmfg983brhmhkd98n6 \
  --branch-id agtbranch_0901k4aafjxxfxt93gd841r7tv5t \
  --json '{"version_description": "Publish refund procedure"}'
```

ड्राफ़्ट को पढ़ने, अपडेट करने या हटाने के लिए `elevenlabs agents procedures drafts` और
हटाने को स्टेज करने के लिए `elevenlabs agents procedures remove` इस्तेमाल करें। किसी भी कमांड के
इनपुट और आउटपुट कॉन्ट्रैक्ट को देखने के लिए उसमें `--schema` जोड़ें।

#### API से मैनेज करें

प्रक्रिया ड्राफ़्ट [एजेंट वर्ज़निंग लाइफ़साइकल](/docs/hi/eleven-agents/operate/versioning#drafts) का पालन करते हैं। वे हर यूज़र और ब्रांच के लिए अलग होते हैं, इसलिए
हर टीम सदस्य के पास हर ब्रांच पर अलग ड्राफ़्ट होते हैं। पब्लिश करने पर उस ब्रांच पर नए
अपरिवर्तनीय एजेंट वर्ज़न में आपकी प्रक्रिया के बदलाव सेव हो जाते हैं। दूसरे यूज़र्स के ड्राफ़्ट प्रभावित नहीं होते।

एजेंट कॉन्फ़िगरेशन रिस्पॉन्स में ID, नाम, प्रकार और
ट्रिगर जैसे प्रक्रिया मेटाडेटा शामिल होते हैं, लेकिन प्रक्रिया का मुख्य भाग या ड्राफ़्ट नहीं होते। पूरा कंटेंट पढ़ने और एडिट करने के लिए
प्रक्रिया एंडपॉइंट्स का इस्तेमाल करें। सभी प्रक्रिया एंडपॉइंट्स
`/v1/convai/agents/{agent_id}/branches/{branch_id}` के अंतर्गत नेस्टेड होते हैं।

### ड्राफ़्ट बनाएं या अपडेट करें

`POST /procedures` से प्रक्रिया बनाएं। इसे
`PATCH /procedures/{procedure_id}/draft` से अपडेट करें और हर रिक्वेस्ट में `name`, `content`, `type` और `trigger`
शामिल करें। `type` प्रक्रिया के मौजूदा प्रकार से मेल खाना चाहिए।

अप्रकाशित बदलाव पढ़ने के लिए `GET /procedures/{procedure_id}/draft` इस्तेमाल करें। अगर आपका कोई ड्राफ़्ट नहीं है,
तो एंडपॉइंट प्रकाशित वर्ज़न लौटाता है।

### बदलाव पब्लिश करें

[एजेंट अपडेट करें](/docs/hi/api-reference/agents/update) से नया एजेंट वर्ज़न बनाकर
ड्राफ़्ट पब्लिश करें। एक रिक्वेस्ट ब्रांच पर बदले गए हर
प्रक्रिया ड्राफ़्ट को, दोनों प्रक्रिया प्रकारों के लिए, पब्लिश करती है। अगर ब्रांच में स्ट्रक्चर्ड
प्रक्रियाएं हैं, तो पब्लिश उन्हें वैलिडेट और कंपाइल करता है (उनके चरणों को उस रूप में बदलता है जिसे
एजेंट चलाता है) और कोई भी त्रुटि लौटाता है। अगर वैलिडेशन पास हो जाता है, तो एजेंट कॉन्फ़िगरेशन
पब्लिश हो जाता है। आपको खुद कुछ भी कंपाइल नहीं करना पड़ता।

प्रकार-विशिष्ट निर्देशों के लिए
[फ्री-फ़ॉर्म प्रक्रियाएं](/docs/hi/eleven-agents/customization/procedures/free-form-procedures#manage-a-free-form-procedure)
या
[स्ट्रक्चर्ड प्रक्रियाएं](/docs/hi/eleven-agents/customization/procedures/structured-procedures#manage-a-structured-procedure)
देखें।

### प्रक्रिया हटाएं या खारिज करें

`DELETE /procedures/{procedure_id}/draft` अप्रकाशित एडिट्स को खारिज करता है और
प्रकाशित वर्ज़न को बहाल करता है। अगर प्रक्रिया कभी पब्लिश नहीं हुई है, तो यह उसे हटा देता है।

`DELETE /procedures/{procedure_id}` किसी प्रकाशित प्रक्रिया को हटाने के लिए स्टेज करता है।
उसी फ़्लो से बदलाव पब्लिश करें।

पूरे एंडपॉइंट स्कीमा के लिए [प्रक्रियाएं API रेफरेंस](/docs/hi/api-reference/agents/procedures/) देखें।

## सीमाएं

* प्रक्रिया का कंटेंट अधिकतम 50,000 वर्णों का हो सकता है।
* एजेंट सबसे हाल में शुरू की गई पांच प्रक्रियाओं को कॉन्टेक्स्ट में रखता है। एक बातचीत में इससे ज़्यादा प्रक्रियाएं शुरू होने पर, सबसे पुरानी फ्री-फ़ॉर्म प्रक्रियाओं का कंटेंट, इनलाइन टूल्स और नॉलेज बेस दस्तावेज़ प्रॉम्प्ट से हट जाते हैं। प्रक्रियाओं को केंद्रित रखें और सब-प्रक्रियाओं का इस्तेमाल करें, ताकि एक समय में कम प्रक्रियाएं सक्रिय हों।
* प्रक्रिया बनाने के बाद उसका प्रकार नहीं बदला जा सकता। फ्री-फ़ॉर्म और स्ट्रक्चर्ड के बीच बदलने के लिए नई प्रक्रिया बनाएं और उसके सभी रेफरेंस अपडेट करें।
* प्रक्रियाएं एक एजेंट की होती हैं। उन्हें एजेंट्स के बीच शेयर नहीं किया जा सकता या वर्कस्पेस-स्तरीय रिसोर्स के रूप में स्टोर नहीं किया जा सकता।
* एजेंट की कॉपी बनाने पर उसकी प्रक्रियाएं शेयर होने के बजाय कॉपी होती हैं। कॉपियों को नई प्रक्रिया IDs मिलती हैं, इसलिए डुप्लिकेट किए गए एजेंट में रेफरेंस को उन नई IDs का इस्तेमाल करना होगा।
* प्रक्रियाओं को खास वर्कफ़्लो नोड्स तक सीमित नहीं किया जा सकता। जब एजेंट में दोनों हों, तो हर प्रक्रिया हर नोड से उपलब्ध होती है।
* स्ट्रक्चर्ड प्रक्रियाएं नॉलेज बेस दस्तावेज़ों को रेफरेंस नहीं कर सकतीं।