बहु-कोणीय विश्लेषण के लिए एजेंट्स का एक समूह: LLMs से विशेषज्ञों की एक टीम बनाना

गति के बारे में नहीं। यह कई एजेंटों को अलग-अलग दृष्टिकोणों से एक निर्णय पर बहस करने और उस निष्कर्ष पर पहुँचने के बारे में है जो उनमें से किसी एक से बेहतर हो। ऑर्केस्ट्रेटर, विशेषज्ञों और मर्ज के लिए पूरा कोड सहित।

जब आप एक मॉडल से किसी निर्णय का मूल्यांकन करने के लिए कहते हैं, तो वह एक दृष्टिकोण देता है, जो आमतौर पर औसत और सतर्क होता है। वह सहमत होने, चिकना करने, संतुलन खोजने की प्रवृत्ति रखता है। यही समस्या है: एक महत्वपूर्ण निर्णय का मूल्यांकन एक औसत दृष्टिकोण से नहीं किया जा सकता, इसे अलग-अलग पक्षों से हमला किया जाना चाहिए।

एजेंटों का एक झुंड (swarm) इस समस्या को संरचनात्मक रूप से हल करता है। आप कई विशेषज्ञ बनाते हैं, प्रत्येक की एक कठोर भूमिका और पूर्वाग्रह होता है: एक केवल पैसे के बारे में सोचता है, दूसरा केवल तकनीकी जोखिम के बारे में, तीसरा केवल उपयोगकर्ता के बारे में। वे एक निर्णय का स्वतंत्र रूप से विश्लेषण करते हैं, अलग-अलग निष्कर्षों पर पहुँचते हैं, और फिर आप उन निष्कर्षों के मेल-मिलाप (reconciliation) को मजबूर करते हैं। यहाँ मूल्य गति नहीं है, बल्कि यह है कि असहमति संरचना में निर्मित है। एक एकल एजेंट अपने आप से ग्रुपथिंक (groupthink) की ओर प्रवृत्त होता है, भूमिकाओं का एक झुंड ऐसा नहीं करता।

यह लेख दिखाता है कि कोड के साथ ऐसा झुंड कैसे बनाया जाता है। हम तीन भागों को कवर करते हैं: ऑर्केस्ट्रेटर जो भूमिकाएँ सौंपता है, विशेषज्ञ जो स्वतंत्र रूप से विश्लेषण करते हैं, और मर्ज जो उन्हें एक निष्कर्ष में मिलाता है।

आर्किटेक्चर: ऑर्केस्ट्रेटर, विशेषज्ञ, मर्ज

विश्लेषण के लिए एक झुंड तीन घटकों का होता है।

ऑर्केस्ट्रेटर कार्य लेता है और तय करता है कि किन विशेषज्ञ भूमिकाओं की आवश्यकता है। किसी उत्पाद लॉन्च के मूल्यांकन के लिए ये एक निवेशक, एक इंजीनियर, एक उत्पाद विशेषज्ञ, एक सुरक्षा व्यक्ति हो सकते हैं। ऑर्केस्ट्रेटर स्वयं विश्लेषण नहीं करता, वह भूमिकाएँ सौंपता है।

विशेषज्ञ समानांतर और स्वतंत्र रूप से काम करते हैं। प्रत्येक एक ही निर्णय को देखता है लेकिन अपने स्वयं के लेंस से। महत्वपूर्ण बात यह है कि वे एक-दूसरे के निष्कर्ष नहीं देखते, अन्यथा अनुरूपता (conformity) शुरू हो जाती है। स्वतंत्रता ही अलग-अलग दृष्टिकोण उत्पन्न करती है।

मर्ज विशेषज्ञों के निष्कर्षों को इकट्ठा करता है और उनमें मेल-मिलाप कराता है: वे कहाँ सहमत हैं, कहाँ विरोधाभासी हैं, सभी कोणों पर अंतिम फैसला क्या है। यह औसत निकालना नहीं है, बल्कि एक संश्लेषण (synthesis) है जो असहमति को एक संकेत के रूप में रखता है।

चरण 1: बेसिक क्लाइंट

मॉडल के लिए एक सरल क्लाइंट से शुरू करें। मैं OpenAI-संगत संदेश प्रारूप का उपयोग करता हूँ, यह अधिकांश प्रदाताओं और स्थानीय Ollama के साथ काम करता है।

1import requests
2import json
3from concurrent.futures import ThreadPoolExecutor
4
5API = "http://localhost:11434/api/chat"   # Ollama, या कोई प्रदाता एंडपॉइंट
6MODEL = "qwen2.5:32b"
7
8def ask(system, user, temperature=0.7):
9    resp = requests.post(API, json={
10        "model": MODEL,
11        "messages": [
12            {"role": "system", "content": system},
13            {"role": "user", "content": user},
14        ],
15        "temperature": temperature,
16        "stream": False,
17    }, timeout=120)
18    resp.raise_for_status()
19    return resp.json()["message"]["content"]

चरण 2: ऑर्केस्ट्रेटर भूमिकाएँ सौंपता है

ऑर्केस्ट्रेटर कार्य प्राप्त करता है और तय करता है कि किन विशेषज्ञों की आवश्यकता है। भूमिकाओं को पहले से हार्डकोड न करें, मॉडल को विशिष्ट कार्य के लिए उन्हें चुनने दें, इससे झुंड सामान्य (general) बनता है। पार्स करने के लिए सख्त JSON माँगें।

1ORCHESTRATOR_SYSTEM = """आप एक विश्लेषणात्मक झुंड के ऑर्केस्ट्रेटर हैं।
2कार्य के लिए, 3-5 विशेषज्ञ भूमिकाएँ परिभाषित करें जो निर्णय पर
3अधिकतम अलग और परस्पर विरोधी दृष्टिकोण देंगी। भूमिकाएँ अपने
4हितों में टकराव वाली होनी चाहिए, एक-दूसरे की पूरक नहीं।
5
6प्रत्येक भूमिका के लिए दें: नाम, फोकस (वह किस पर अड़ा है), पूर्वाग्रह (वह
7किस ओर पक्षपाती है, वह किसे अधिक महत्व देता है)।
8
9केवल JSON ऐरे में उत्तर दें, कोई स्पष्टीकरण नहीं:
10[{"name": "...", "focus": "...", "bias": "..."}, ...]
11"""
12
13def plan_roles(task):
14    raw = ask(ORCHESTRATOR_SYSTEM, f"विश्लेषण करने का कार्य:\n{task}",
15              temperature=0.9)   # भूमिका विविधता के लिए उच्च तापमान
16    # JSON को काटें, यदि मॉडल ने उसके आसपास टेक्स्ट जोड़ा हो
17    start, end = raw.find("["), raw.rfind("]") + 1
18    return json.loads(raw[start:end])

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

चरण 3: विशेषज्ञ समानांतर और स्वतंत्र रूप से विश्लेषण करते हैं

प्रत्येक विशेषज्ञ को अपनी भूमिका और वही निर्णय मिलता है। गंभीर रूप से: वे समानांतर में चलते हैं और एक-दूसरे के निष्कर्ष नहीं देखते। यहाँ समानता केवल गति के लिए नहीं है, यह स्वतंत्रता की गारंटी देती है, एक विशेषज्ञ शारीरिक रूप से दूसरे की राय के अनुसार समायोजित नहीं हो सकता।

1EXPERT_SYSTEM = """आप भूमिका वाले एक विशेषज्ञ हैं: {name}।
2आपका फोकस: {focus}।
3आपका पूर्वाग्रह: {bias}। इससे लड़ें नहीं, यह विश्लेषण के लिए आपका मूल्य है।
4
5निर्णय का सख्ती से अपनी स्थिति से विश्लेषण करें। संतुलित न हों,
6अन्य दृष्टिकोणों को ध्यान में रखने की कोशिश न करें, अन्य विशेषज्ञ वह करेंगे।
7आपका काम अपने कोण को सीमा तक धकेलना है।
8
9दें:
10- अपनी स्थिति से एक फैसला (पक्ष में / विरुद्ध / सशर्त)
11- विशेष रूप से अपने कोण से 2-3 मुख्य तर्क
12- 1 जोखिम जो आपकी स्थिति से सबसे अधिक दिखाई देता है और दूसरे चूक जाएँगे
13संक्षिप्त और कठोर, कोई फालतू नहीं।"""
14
15def run_expert(role, task):
16    system = EXPERT_SYSTEM.format(**role)
17    opinion = ask(system, f"विश्लेषण करने का निर्णय:\n{task}", temperature=0.7)
18    return {"role": role["name"], "opinion": opinion}
19
20def run_swarm(roles, task):
21    # समानांतर लॉन्च: स्वतंत्रता और गति
22    with ThreadPoolExecutor(max_workers=len(roles)) as pool:
23        futures = [pool.submit(run_expert, role, task) for role in roles]
24        return [f.result() for f in futures]

विशेषज्ञ के प्रॉम्प्ट पर ध्यान दें: हम स्पष्ट रूप से इसे संतुलित होने से मना करते हैं। यह प्रति-सहज ज्ञान (counterintuitive) है, लेकिन यही पूरा बिंदु है। यदि प्रत्येक विशेषज्ञ सभी पक्षों को ध्यान में रखने की कोशिश करता है, तो आपको पाँच समान सतर्क राय मिलती हैं। प्रत्येक को अपने कोण को सीमा तक धकेलने के लिए मजबूर करके, आपको एक वास्तविक स्पेक्ट्रम मिलता है, जिसे मर्ज फिर मिलाता है।

चरण 4: मर्ज निष्कर्षों में मेल-मिलाप कराता है

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

1MERGE_SYSTEM = """आप एक विश्लेषणात्मक झुंड के संश्लेषक (synthesizer) हैं।
2आपको एक निर्णय पर अलग-अलग पूर्वाग्रहों वाले कई विशेषज्ञों की राय दी गई है।
3
4आपका काम उनका औसत निकालना नहीं है। आपका काम है:
51. सहमति: विशेषज्ञों ने अलग-अलग स्थितियों के बावजूद किस पर सहमति जताई।
6   यह सबसे विश्वसनीय संकेत है, इसे उजागर करें।
72. संघर्ष: जहाँ विशेषज्ञ सीधे विरोधाभासी हैं। इसे चिकना न करें,
8   संघर्ष को स्पष्ट रूप से नाम दें और बताएँ कि प्रत्येक पक्ष की क्या कीमत है।
93. अंधे धब्बे (blind spots): एक जोखिम जिसे केवल एक विशेषज्ञ ने नाम दिया, लेकिन वह मायने रखता है।
104. सब कुछ पर अंतिम फैसला: पक्ष में / विरुद्ध / सशर्त, और किन
11   शर्तों पर यह बदलता है।
12
13संक्षिप्त लिखें। असहमति को सूचना के रूप में रखें, इसे छिपाएँ नहीं।"""
14
15def merge_opinions(task, opinions):
16    block = "\n\n".join(
17        f"### विशेषज्ञ: {o['role']}\n{o['opinion']}" for o in opinions
18    )
19    user = f"निर्णय:\n{task}\n\nविशेषज्ञ राय:\n{block}"
20    return ask(MERGE_SYSTEM, user, temperature=0.4)   # संयत संश्लेषण के लिए कम तापमान

हम मर्ज पर तापमान कम करते हैं: यदि विशेषज्ञों को विविध होना चाहिए (उच्च T), तो संश्लेषक को संयत और सुसंगत होना चाहिए (कम T)। यहाँ मुख्य निर्देश है "औसत न निकालें, असहमति को सूचना के रूप में रखें।" एक सामान्य मर्ज सब कुछ गूदे में बदल देता है, "एक तरफ, दूसरी तरफ।" एक अच्छा मर्ज स्पष्ट रूप से कहता है: यहाँ हर कोई सहमत है, और यहाँ एक संघर्ष है और इसकी इतनी कीमत है।

चरण 4.5: नकली सहमति के खिलाफ एक शैतान का वकील (Devil's Advocate)

एक शांत खतरा है: कभी-कभी विशेषज्ञ इसलिए सहमत नहीं होते क्योंकि निर्णय अच्छा है, बल्कि इसलिए कि हर कोई जड़ता से एक ही दिशा में देख रहा है। यह नकली सहमति है, और यह खुले संघर्ष से अधिक खतरनाक है, क्योंकि यह विश्वास जैसा दिखता है।

इसके खिलाफ हम एक विशेष एजेंट जोड़ते हैं, शैतान का वकील। इसका एकमात्र काम आम सहमति पर हमला करना है। यह सभी विशेषज्ञों की राय देखता है और यह पता लगाने के लिए बाध्य है कि वे सभी एक साथ गलत क्यों हो सकते हैं। यदि झुंड ने सर्वसम्मति से "पक्ष में" वोट दिया, तो वकील एक ऐसे परिदृश्य की तलाश करता है जहाँ यह एक आपदा है।

1DEVIL_SYSTEM = """आप एक विश्लेषणात्मक झुंड में शैतान के वकील हैं।
2आपको विशेषज्ञों की राय दी गई है। आपका एकमात्र काम: उनकी सहमति पर हमला करना।
3
4यदि विशेषज्ञ किसी चीज़ पर एकमत हो गए हैं, तो पता लगाएँ कि वे सभी
5एक साथ गलत क्यों हो सकते हैं। एक साझा अंधे धब्बे की तलाश करें:
6एक धारणा जिसे सभी ने बिना जाँचे स्वीकार कर लिया, एक परिदृश्य जिस पर
7किसी ने विचार नहीं किया क्योंकि यह असुविधाजनक है।
8
9विनम्र न हों। आपका मूल्य यह है कि आप वह कहते हैं जो समूह सुनना नहीं चाहता।
10दें:
11- विशेषज्ञों की कौन सी साझा धारणा सबसे खतरनाक है
12- एक परिदृश्य जिसमें झुंड की सर्वसम्मत राय घातक रूप से गलत साबित होती है
13- एक प्रश्न जिसे समूह ने सावधानी से टाला
14यदि कोई सहमति नहीं है और विशेषज्ञ वास्तव में असहमत हैं, तो स्पष्ट रूप से कहें
15और सबसे तीखे अनसुलझे संघर्ष की ओर इशारा करें।"""
16
17def run_devil(task, opinions):
18    block = "\n\n".join(
19        f"### {o['role']}\n{o['opinion']}" for o in opinions
20    )
21    user = f"निर्णय:\n{task}\n\nझुंड की राय:\n{block}"
22    return ask(DEVIL_SYSTEM, user, temperature=0.8)

वकील विशेषज्ञों के बाद लेकिन मर्ज से पहले चलता है, और इसका हमला राय के साथ संश्लेषण में जाता है। बात यह है कि एक सर्वसम्मत झुंड को भी कम से कम एक एजेंट मिलता है जो दरार की तलाश करने के लिए बाध्य है। यह सस्ता है (एक कॉल) और संरचनात्मक रूप से ग्रुपथिंक को तोड़ता है: आम सहमति को अब एक हमले से बचना होगा, न कि केवल होना।

चरण 4.6: संघर्ष को तेज करने के लिए एक बहस दौर (Debate Round)

पहला विशेषज्ञ पास स्वतंत्र है, और विविधता के लिए यह सही है। लेकिन राय एकत्र होने के बाद, आप एक बहस दौर दे सकते हैं: प्रत्येक विशेषज्ञ को दूसरों की राय का सारांश दिखाएँ और उसे आपत्ति करने दें। यह संघर्षों को तेज करता है, कमजोर तर्क गिर जाते हैं, मजबूत तर्क मजबूत हो जाते हैं।

1DEBATE_SYSTEM = """आप विश्लेषण के दूसरे दौर में विशेषज्ञ {name} हैं।
2आपकी मूल स्थिति:
3{own_opinion}
4
5अब आप अन्य विशेषज्ञों की राय देखते हैं। दबाव में न झुकें,
6लेकिन मजबूत तर्कों को भी नज़रअंदाज़ न करें। दें:
7- जहाँ दूसरे का तर्क वास्तव में आपकी स्थिति को प्रभावित करता है, ईमानदारी से स्वीकार करें
8- जहाँ आप अपनी रेखा पर कायम हैं और क्यों उनकी आपत्ति कमजोर है
9- क्या आपने बहस के बाद अपना फैसला बदला, और यदि हाँ, तो कैसे
10संक्षिप्त। यह पहली राय की पुनरावृत्ति नहीं है, बल्कि विरोधियों पर प्रतिक्रिया है।"""
11
12def debate_round(roles, task, opinions):
13    others_map = {}
14    for o in opinions:
15        others = "\n\n".join(
16            f"### {x['role']}\n{x['opinion']}" for x in opinions if x is not o
17        )
18        others_map[o["role"]] = others
19
20    def rebut(o):
21        system = DEBATE_SYSTEM.format(name=o["role"], own_opinion=o["opinion"])
22        user = (f"निर्णय:\n{task}\n\n"
23                f"विरोधियों की राय:\n{others_map[o['role']]}")
24        return {"role": o["role"], "opinion": ask(system, user, temperature=0.6)}
25
26    with ThreadPoolExecutor(max_workers=len(opinions)) as pool:
27        return list(pool.map(rebut, opinions))

बहस का दौर भी समानांतर है: प्रत्येक विशेषज्ञ एक साथ सभी अन्य पर प्रतिक्रिया करता है, फिर से कोई वास्तविक समय अनुरूपता नहीं। बहस के बाद राय आमतौर पर तेज होती हैं: आप देख सकते हैं कि कौन सी स्थितियाँ आग के नीचे टिकीं और कौन सी ढह गईं। ये कठोर राय हैं जो अंतिम मर्ज में जाती हैं।

चरण 5: सब कुछ एक साथ रखना

1def analyze(task, debate=True):
2    print("ऑर्केस्ट्रेटर भूमिकाएँ चुन रहा है...")
3    roles = plan_roles(task)
4    for r in roles:
5        print(f"  - {r['name']}: {r['focus']}")
6
7    print(f"\n{len(roles)} विशेषज्ञों को समानांतर में लॉन्च किया जा रहा है...")
8    opinions = run_swarm(roles, task)
9    for o in opinions:
10        print(f"\n[{o['role']}]\n{o['opinion']}")
11
12    # वैकल्पिक बहस दौर: विशेषज्ञ एक-दूसरे पर प्रतिक्रिया करते हैं
13    if debate:
14        print("\nबहस दौर, विशेषज्ञ एक-दूसरे का खंडन कर रहे हैं...")
15        opinions = debate_round(roles, task, opinions)
16
17    # शैतान का वकील झुंड की सहमति में दरार ढूँढता है
18    print("\nशैतान का वकील सहमति में दरार ढूँढ रहा है...")
19    devil = run_devil(task, opinions)
20    print(f"\n[शैतान का वकील]\n{devil}")
21
22    # मर्ज निष्कर्षों और वकील के हमले का मेल-मिलाप कराता है
23    print("\nमर्ज निष्कर्षों का मेल-मिलाप करा रहा है...")
24    opinions_plus = opinions + [{"role": "शैतान का वकील", "opinion": devil}]
25    verdict = merge_opinions(task, opinions_plus)
26    print(f"\n=== अंतिम फैसला ===\n{verdict}")
27    return verdict
28
29if __name__ == "__main__":
30    analyze(
31        "हम फ्री टियर को हटाकर उत्पाद को 14-दिन के ट्रायल के साथ "
32        "पूरी तरह से भुगतान वाला बनाना चाहते हैं। क्या हमें ऐसा करना चाहिए?"
33    )

इसे चलाने पर, आप पूरी पाइपलाइन देखेंगे: ऑर्केस्ट्रेटर भूमिकाएँ चुनता है, विशेषज्ञ अपने कोणों से सच्चाई काटते हैं, बहस दौर में एक-दूसरे से बहस करते हैं, वकील उनकी सहमति पर हमला करता है, और मर्ज हमले सहित सब कुछ पर एक फैसला देता है। इसी प्रश्न पर एक एकल एजेंट एक अस्पष्ट "यह आपके दर्शकों पर निर्भर करता है" देगा, झुंड एक संरचित विश्लेषण देता है जहाँ संघर्ष स्पष्ट हैं और आम सहमति का तनाव-परीक्षण किया जाता है।

इस झुंड को क्या काम करता है

तीन चीज़ें एक उपयोगी झुंड को एजेंटों से बने नाटक से अलग करती हैं।

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

विशेषज्ञों को एक-दूसरे को नहीं देखना चाहिए। जैसे ही एक विशेषज्ञ दूसरे की राय देखता है, अनुरूपता शुरू हो जाती है, वह समायोजित होता है। स्वतंत्रता एक कार्यान्वयन विवरण नहीं है, यह एक काम करने की शर्त है। समानांतर लॉन्च इसे मुफ्त देता है।

मर्ज औसत नहीं निकालता, यह संघर्ष को संरक्षित करता है। एक खराब संश्लेषण पाँच तीखी राय को एक दांतहीन सारांश में बदल देता है। एक अच्छा संश्लेषण संघर्ष को दृश्यमान छोड़ देता है, क्योंकि संघर्ष सबसे मूल्यवान जानकारी है: यह दिखाता है कि निर्णय वास्तव में कहाँ जोखिम भरा है, न कि जहाँ हर कोई सिर हिलाता है।

कहाँ विस्तार करें

यह ढाँचा स्पष्ट दिशाओं में विस्तारित होता है। आप एक बहस दौर जोड़ सकते हैं: पहले मर्ज के बाद, विशेषज्ञों को सारांश दिखाएँ और उन्हें आपत्ति करने दें, जो संघर्षों को तेज करता है। आप तर्कों को तौलने के लिए विशेषज्ञों पर एक मजबूत मॉडल का जज रख सकते हैं। आप एक आवर्ती प्रकार के निर्णय के लिए भूमिकाओं को स्थायी बना सकते हैं, ताकि आप उन्हें हर बार उत्पन्न न करें।

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