एलएलएम के साथ स्वायत्त एआई वर्कफ़्लो का निर्माण

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

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

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

1. एजेंटिक शिफ्ट: चैटबॉट्स बनाम वर्कफ़्लोज़

एलएलएम अनुप्रयोगों के विकास को स्वायत्तता के चार अलग-अलग स्तरों में वर्गीकृत किया जा सकता है:

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

2. स्वायत्त कार्यप्रवाह के मुख्य स्तंभ

एक स्वायत्त वर्कफ़्लो बनाने के लिए, आपको चार मूलभूत घटकों को संयोजित करने की आवश्यकता है:

ए. तर्क और योजना

कार्यप्रवाह के केंद्र में नियोजन प्रतिमान है। एक अनुभवहीन एलएलएम कॉल तुरंत अंतिम उत्तर देने का प्रयास करती है, जिससे अक्सर तर्क विफल हो जाता है। स्वायत्त वर्कफ़्लो विशेष नियोजन लूप का उपयोग करते हैं:

• प्रतिक्रिया (कारण + अधिनियम): मॉडल पुनरावृत्त रूप से सोचता है, कार्य करता है (एक उपकरण को कॉल करता है), और परिणाम का निरीक्षण करता है, लक्ष्य प्राप्त होने तक इस लूप को दोहराता है।
• विचार की श्रृंखला (सीओटी): किसी निष्कर्ष पर पहुंचने से पहले *मॉडल को अपने चरण-दर-चरण तर्क को आउटपुट करने के लिए मजबूर करना।
• विचारों का वृक्ष (टीओटी): कई वैकल्पिक पथों का निर्माण और मूल्यांकन करना, विभिन्न शाखाओं पर नज़र रखना, और पथ विफल होने पर पीछे हटना।

बी. अल्पकालिक और दीर्घकालिक स्मृति

एक स्वायत्त प्रणाली को कई निष्पादन चक्रों में स्थिति बनाए रखनी चाहिए:

• अल्पकालिक मेमोरी: थ्रेड संदर्भ, स्थिति चर और निष्पादन लॉग जो वर्कफ़्लो वर्तमान में क्या कर रहा है उसका ट्रैक रखते हैं।
• दीर्घकालिक मेमोरी: वेक्टर डेटाबेस और सिमेंटिक पुनर्प्राप्ति प्रणालियाँ जो वर्कफ़्लो को ऐतिहासिक रन, उपयोगकर्ता प्राथमिकताएँ और एंटरप्राइज़ दस्तावेज़ीकरण को याद करने की अनुमति देती हैं।

सी. उपकरण एवं वेब एकीकरण

भौतिक या डिजिटल दुनिया पर कार्य करने के लिए, एलएलएम को बाहरी सेवाओं के साथ इंटरफेस करना होगा। मॉडल को डेटाबेस ड्राइवर, फ़ाइल सिस्टम, वेब ब्राउज़र और तृतीय-पक्ष एपीआई तक पहुंच की आवश्यकता है। आधुनिक वर्कफ़्लो तेजी से मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) को अपना रहे हैं, जो एलएलएम को प्रासंगिक डेटा स्रोतों और निष्पादन सैंडबॉक्स को खोजने और सुरक्षित रूप से कनेक्ट करने के तरीके को मानकीकृत कर रहा है।

3. प्रमुख वास्तुशिल्प डिजाइन पैटर्न

जटिल एजेंटिक सिस्टम का निर्माण करते समय, सॉफ्टवेयर इंजीनियर जटिलता को प्रबंधित करने और पूर्वानुमान बनाए रखने के लिए सिद्ध डिज़ाइन पैटर्न के एक सेट पर भरोसा करते हैं:

पैटर्न 1: राउटर पैटर्न

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

पैटर्न 2: ऑर्केस्ट्रेटर-श्रमिक

एक केंद्रीय ऑर्केस्ट्रेटर एलएलएम एक बड़े, जटिल कार्य को स्वतंत्र उप-कार्यों में विभाजित करता है। इसके बाद यह इन कार्यों को वर्कर नोड्स (जो विशिष्ट एलएलएम या मानक माइक्रोसर्विसेज हो सकते हैं) को सौंपता है और परिणामों को संश्लेषित करता है।

पैटर्न 3: मूल्यांकनकर्ता-अनुकूलक लूप

ऑप्टिमाइज़र एक मसौदा प्रतिक्रिया उत्पन्न करता है या किसी कार्य को निष्पादित करता है, और मूल्यांकनकर्ता इसे औपचारिक मानदंडों (जैसे इकाई परीक्षण, सुरक्षा स्कैनर, या एक अलग मूल्यांकन संकेत) के विरुद्ध जांचता है। यदि जाँच विफल हो जाती है, तो प्रतिक्रिया को पुन: उत्पन्न करने के लिए फीडबैक ऑप्टिमाइज़र को वापस भेज दिया जाता है।

4. पायथन में एक राज्य-आधारित एजेंट का निर्माण

आइए एक साधारण राज्य मशीन का उपयोग करके एक स्वायत्त एजेंट के ठोस कार्यान्वयन को देखें। हम एक ऐसे एजेंट को परिभाषित करेंगे जो धनवापसी अनुरोधों को संसाधित करता है। एजेंट ग्राहक के खरीद इतिहास की जाँच करता है, नीतियों के विरुद्ध अनुरोध को मान्य करता है, एक ईमेल प्रतिक्रिया का मसौदा तैयार करता है, और यदि धनवापसी $100 से अधिक हो तो मानव अनुमोदन का अनुरोध करता है।

import json
from typing import Dict, Any

# Mock databases and tools
PURCHASE_DB = {
    "user_123": {"item": "Premium Subscription", "price": 149.00, "days_ago": 12},
    "user_456": {"item": "Basic License", "price": 49.00, "days_ago": 45}
}

class AutonomousRefundAgent:
    def __init__(self):
        self.state: Dict[str, Any] = {
            "step": "INIT",
            "user_id": None,
            "refund_amount": 0.0,
            "policy_passed": False,
            "requires_approval": False,
            "approved": False,
            "response_draft": "",
            "log": []
        }

    def run(self, user_id: str, request_text: str):
        self.state["user_id"] = user_id
        self.state["log"].append(f"Started workflow for user {user_id} with request: '{request_text}'")
        
        while self.state["step"] != "COMPLETE":
            current_step = self.state["step"]
            if current_step == "INIT":
                self._fetch_user_data()
            elif current_step == "VALIDATE_POLICY":
                self._validate_policy()
            elif current_step == "CHECK_APPROVAL":
                self._check_approval_requirements()
            elif current_step == "WAITING_FOR_HUMAN":
                # Pause execution and yield control back to the orchestrator
                self.state["log"].append("Execution paused: waiting for human operator approval.")
                break
            elif current_step == "EXECUTE_REFUND":
                self._execute_refund()
            elif current_step == "DRAFT_RESPONSE":
                self._draft_response()
                
        return self.state

    def _fetch_user_data(self):
        user_id = self.state["user_id"]
        purchase = PURCHASE_DB.get(user_id)
        if not purchase:
            self.state["response_draft"] = "No purchase history found for this user."
            self.state["step"] = "DRAFT_RESPONSE"
            self.state["log"].append("Fetch failed: User not found in database.")
            return

        self.state["refund_amount"] = purchase["price"]
        self.state["purchase_age_days"] = purchase["days_ago"]
        self.state["step"] = "VALIDATE_POLICY"
        self.state["log"].append(f"Fetched purchase data: {purchase}")

    def _validate_policy(self):
        # Business rule: Refunds only allowed within 30 days
        age = self.state["purchase_age_days"]
        if age <= 30:
            self.state["policy_passed"] = True
            self.state["step"] = "CHECK_APPROVAL"
            self.state["log"].append("Policy validation passed (within 30-day window).")
        else:
            self.state["policy_passed"] = False
            self.state["response_draft"] = "Sorry, our policy only allows refunds within 30 days of purchase."
            self.state["step"] = "DRAFT_RESPONSE"
            self.state["log"].append("Policy validation failed: Purchase older than 30 days.")

    def _check_approval_requirements(self):
        # Business rule: Refunds over $100 require human review
        amount = self.state["refund_amount"]
        if amount > 100.0:
            self.state["requires_approval"] = True
            self.state["step"] = "WAITING_FOR_HUMAN"
            self.state["log"].append(f"Refund of ${amount} exceeds limit. Moving to human approval state.")
        else:
            self.state["requires_approval"] = False
            self.state["step"] = "EXECUTE_REFUND"
            self.state["log"].append(f"Refund of ${amount} is within limits. Proceeding to execution.")

    def resume_with_human_decision(self, approved: bool):
        if self.state["step"] != "WAITING_FOR_HUMAN":
            raise ValueError("Agent is not currently waiting for approval.")
        
        self.state["approved"] = approved
        self.state["log"].append(f"Human manager decision received: Approved = {approved}")
        
        if approved:
            self.state["step"] = "EXECUTE_REFUND"
        else:
            self.state["response_draft"] = "Your refund request has been reviewed and declined by a customer service manager."
            self.state["step"] = "DRAFT_RESPONSE"
            
        # Resume the workflow loop
        return self.run(self.state["user_id"], "")

    def _execute_refund(self):
        amount = self.state["refund_amount"]
        # Trigger actual external API call/Stripe integration here
        self.state["log"].append(f"Successfully processed stripe refund for ${amount}.")
        self.state["response_draft"] = f"Your refund request for ${amount} has been successfully processed."
        self.state["step"] = "DRAFT_RESPONSE"

    def _draft_response(self):
        # Prompt LLM to draft a polite, personalized message incorporating response_draft
        self.state["final_message"] = f"Dear Customer,\n\n{self.state['response_draft']}\n\nBest regards,\nGhaznix Support Agent"
        self.state["step"] = "COMPLETE"
        self.state["log"].append("Customer email drafted successfully. Workflow complete.")

5. उत्पादन विश्वसनीयता और सुरक्षा रेलिंग

स्वायत्त प्रणालियों को तैनात करने के लिए परीक्षण और त्रुटि प्रबंधन के बारे में हमारी सोच में बदलाव की आवश्यकता है। यहां महत्वपूर्ण रेलिंग हैं जिन्हें आपको किसी भी उत्पादन प्रणाली में बनाना होगा:

ए. भगोड़ा निष्पादन लूप को रोकना

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

• समाधान: अधिकतम निष्पादन सीमा लागू करें। प्रत्येक वर्कफ़्लो उदाहरण के लिए अनुमत चरणों या कुल मॉडल टोकन की संख्या पर हमेशा एक कठोर सीमा निर्धारित करें (उदाहरण के लिए, अधिकतम 10 पुनरावृत्तियाँ)।

बी. संरचनात्मक स्कीमा सत्यापन

एलएलएम संभाव्य हैं और स्वाभाविक रूप से वैध JSON या मिलान स्कीमा जैसे संरचित आउटपुट की गारंटी नहीं देते हैं।

• समाधान: अनुमान स्तर पर संरचना को लागू करने के लिए पाइडेंटिक, इंस्ट्रक्टर, या आउटलाइन्स जैसे सत्यापन पुस्तकालयों का उपयोग करें। यदि कोई मॉडल अमान्य स्कीमा आउटपुट करता है, तो इसे जल्दी से अस्वीकार करें और पार्स त्रुटि वाले मॉडल को खुद को ठीक करने के लिए प्रेरित करें (मूल्यांकनकर्ता-ऑप्टिमाइज़र लूप का हिस्सा)।

सी. सैंडबॉक्स कोड का निष्पादन

यदि आपका एजेंट कोड लिखता है और चलाता है (जैसे डेटा विश्लेषण या डेटाबेस परिवर्तन), तो इसे सीधे आपके एप्लिकेशन सर्वर पर चलाना एक प्रमुख सुरक्षा भेद्यता है।

• समाधान: उपयोगकर्ता-जनरेटेड या एजेंट-जनरेटेड स्क्रिप्ट को सुरक्षित रूप से चलाने के लिए सुरक्षित, अल्पकालिक माइक्रो-वीएम वातावरण (जैसे डॉकर कंटेनर, जीवीज़र, या WASM रनटाइम) का उपयोग करें।

निष्कर्ष

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

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

ग़ज़निक्स ब्लॉग पर अधिक एआई इंजीनियरिंग लेख देखें →