Author: demensdeum

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

DemensDeum – सॉफ्टवेयर और गेम्स

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

https://t.me/demensdeum_channel

DemensDeum – सॉफ्ट और गेम्स

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

https://t.me/demensdeum_channel_en

वाइबकोडिंग चैट

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

https://t.me/justvibecode

क्या चुनें

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

लिंक

https://t.me/demensdeum_channel
https://t.me/demensdeum_channel_en
https://t.me/justvibecode
https://demensdeum.com/

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

ओपनकोड बॉक्स से बाहर एमसीपी का समर्थन करता है: दोनों स्थानीय सर्वर, जो एक चाइल्ड प्रोसेस द्वारा लॉन्च किए जाते हैं, और रिमोट वाले, HTTP के माध्यम से पहुंच योग्य होते हैं। एक महत्वपूर्ण बिंदु यह है कि संपूर्ण MCP परत OpenCode की ओर से ही क्रियान्वित की जाती है, न कि मॉडल प्रदाता की ओर से। इसलिए, डीपसीक को अनुरोध में सामान्य कार्यों के रूप में एमसीपी उपकरण प्राप्त होते हैं, और उसे प्रोटोकॉल के बारे में कुछ भी जानने की आवश्यकता नहीं होती है।

इस पोस्ट में, मैं देखूंगा कि स्थानीय और दूरस्थ सर्वर कैसे जोड़ें, अधिकृत कैसे हों, टोकन में कैसे न डूबें और डीपसीक मॉडल के साथ काम करते समय क्या विचार करें।

आपको क्या चाहिए

काम करने के लिए आपको तीन चीजों की आवश्यकता है:

• ओपनकोड स्थापित। यदि एजेंट अभी तक कॉन्फ़िगर नहीं किया गया है, तो मैंने एक अलग नोट में डीपसीक को स्थापित करने और कनेक्ट करने की प्रक्रिया पर चर्चा की।
• Node.js और npx। स्थानीय MCP सर्वर के लिए आवश्यक है, जिन्हें npm पैकेज के रूप में वितरित किया जाता है।
• एक्सेस कुंजियाँ। केवल उन दूरस्थ सर्वरों के लिए जिन्हें प्राधिकरण की आवश्यकता होती है। Context7 जैसे सार्वजनिक सर्वर बिना चाबी के, लेकिन कम सीमा के साथ काम करते हैं।

यह कैसे काम करता है

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

कनेक्ट करने के बाद, MCP टूल बिल्ट-इन टूल के साथ मॉडल के लिए उपलब्ध हो जाते हैं: फ़ाइलें पढ़ना, कोड संपादित करना और कमांड चलाना। डीपसीक के दृष्टिकोण से, ये सामान्य कार्य हैं जिन्हें एक एजेंट कॉल कर सकता है – यही कारण है कि बंडल मॉडल एपीआई पक्ष पर किसी भी एमसीपी समर्थन के बिना काम करता है।

स्थानीय सर्वर

तंत्र से परिचित होने का सबसे आसान तरीका परीक्षण सर्वर @modelcontextprotocol/server-everything है। आइए इसे प्रोजेक्ट रूट में opencode.json फ़ाइल में जोड़ें:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mcp_everything": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-everything"]
    }
  }
}

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

используй инструмент mcp_everything, чтобы сложить 3 и 4

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

दूरस्थ सर्वर

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

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp"
    }
  }
}

यदि आपके पास निःशुल्क Context7 खाता है, तो सीमाएँ बढ़ाना महत्वपूर्ण है। हेडर हेडर ब्लॉक के माध्यम से प्रेषित होते हैं, और कुंजी को पर्यावरण चर में रखना सुविधाजनक होता है:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}"
      }
    }
  }
}

{env:NAME} निर्माण कॉन्फ़िगरेशन लोड करते समय पर्यावरण चर के मान को प्रतिस्थापित करता है, इसलिए कुंजी रिपॉजिटरी में समाप्त नहीं होती है। एजेंट शुरू करने से पहले, वेरिएबल को टर्मिनल में निर्यात किया जाना चाहिए।

एक अन्य उपयोगी सार्वजनिक सर्वर ग्रेप बाय वर्सेल है, GitHub पर कोड उदाहरण खोजें:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gh_grep": {
      "type": "remote",
      "url": "https://mcp.grep.app"
    }
  }
}

OAuth के माध्यम से प्राधिकरण

कुछ दूरस्थ सर्वरों को OAuth की आवश्यकता होती है। ओपनकोड स्वयं इस परिदृश्य से गुजर सकता है: यह 401 प्रतिक्रिया को नोटिस करता है, प्राधिकरण को ट्रिगर करता है और टोकन बचाता है। संतरी के लिए, बस सर्वर निर्दिष्ट करें:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sentry": {
      "type": "remote",
      "url": "https://mcp.sentry.dev/mcp",
      "oauth": {}
    }
  }
}

इसके बाद, प्राधिकरण मैन्युअल रूप से शुरू किया जा सकता है – ब्राउज़र खुल जाएगा:

opencode mcp auth sentry

सर्विस कमांड रोजमर्रा के काम में भी उपयोगी होते हैं। ओपनकोड एमसीपी सूची सर्वर और प्राधिकरण स्थिति दिखाती है, ओपनकोड एमसीपी लॉगआउट संग्रहीत टोकन हटाता है, और ओपनकोड एमसीपी डिबग एक विशिष्ट सर्वर के लिए नेटवर्क कनेक्टिविटी और OAuth खोज की जांच करता है। टोकन स्थानीय रूप से फ़ाइल ~/.local/share/opencode/mcp-auth.json में संग्रहीत किए जाते हैं।

यदि सर्वर OAuth का उपयोग नहीं करता है, लेकिन एक नियमित API कुंजी का उपयोग करता है, तो स्वचालित प्राधिकरण अक्षम किया जाना चाहिए, अन्यथा OpenCode OAuth को पास करने का प्रयास करेगा जहां इसकी आवश्यकता नहीं है:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-api-key-server": {
      "type": "remote",
      "url": "https://mcp.example.com/mcp",
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {env:MY_API_KEY}"
      }
    }
  }
}

उपकरण प्रबंधन

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

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-mcp-foo": {
      "type": "local",
      "command": ["npx", "-y", "my-mcp-command-foo"]
    },
    "my-mcp-bar": {
      "type": "local",
      "command": ["npx", "-y", "my-mcp-command-bar"]
    }
  },
  "tools": {
    "my-mcp*": false
  }
}

my-mcp* टेम्प्लेट उन सभी टूल को अक्षम कर देता है जिनका नाम इस उपसर्ग से शुरू होता है। यदि कई सर्वर हैं, तो उन्हें विश्व स्तर पर अक्षम करना और किसी विशिष्ट एजेंट के लिए स्थानीय रूप से सक्षम करना अधिक समझ में आता है:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-mcp": {
      "type": "local",
      "command": ["npx", "-y", "my-mcp-command"],
      "enabled": true
    }
  },
  "tools": {
    "my-mcp*": false
  },
  "agent": {
    "my-agent": {
      "tools": {
        "my-mcp*": true
      }
    }
  }
}

डीपसीक विशेषताएं

डीपसीक के साथ कनेक्शन काम करता है क्योंकि मॉडल कॉलिंग फ़ंक्शन का समर्थन करते हैं, और उनके लिए एमसीपी उपकरण सामान्य फ़ंक्शन की तरह दिखते हैं। डीपसीक स्वयं एमसीपी सर्वर को कनेक्ट नहीं करता है और ऐसा नहीं करना चाहिए: कनेक्शन को ओपनकोड द्वारा नियंत्रित किया जाता है।

आपको किस बात पर ध्यान देना चाहिए:

• एक मॉडल का चयन करना। नियमित और छोटे संपादनों के लिए, डीपसीक-फ्लैश पर्याप्त है। उन कार्यों के लिए जहां आपको अपने दिमाग में बहुत सारे संदर्भ रखने और सावधानीपूर्वक एक टूल चुनने की आवश्यकता है, डीपसीक-v4-प्रो देना बेहतर है।
• संदर्भ आकार। GitHub MCP जैसे भारी सर्वर बहुत सारे टोकन जोड़ते हैं और, एक बड़े प्रोजेक्ट के साथ, आसानी से सीमा तक पहुंच जाते हैं। उन्हें केवल किसी विशिष्ट कार्य की अवधि के लिए चालू करें।
• लागत टूलींग स्कीमा प्रत्येक अनुरोध के साथ भेजे जाते हैं, इसलिए जितने अधिक सर्वर शामिल होंगे, प्रत्येक पुनरावृत्ति उतनी ही महंगी होगी। आप प्रदाता को सीधे भुगतान करते हैं, इसलिए अतिरिक्त सर्वर आपके बिल पर ध्यान देने योग्य हैं।
• एजेंट के लिए संकेत। मॉडल की सरलता पर भरोसा न करना, बल्कि सीधे अनुरोध में सर्वर का नाम देना या AGENTS.md में एक नियम लिखना सुरक्षित है।

AGENTS.md के लिए एक नियम का उदाहरण, ताकि एजेंट स्वयं आवश्यक स्रोत तक पहुंच सके:

Когда нужно посмотреть документацию библиотеки, используй инструменты context7.

व्यावहारिक नुस्खा

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

मेरी प्रक्रिया इस प्रकार है: मैं सर्वर को opencode.json में जोड़ता हूं, OpenCode को पुनरारंभ करता हूं, opencode mcp सूची के माध्यम से सूची की जांच करता हूं, फिर एक परीक्षण प्रश्न पूछता हूं जिसमें स्पष्ट रूप से सर्वर का उल्लेख होता है। यदि टूल को कॉल नहीं किया जाता है, तो मैं ओपनकोड एमसीपी डीबग और टाइमआउट की ओर देखता हूं – धीमे सर्वर के पास आवंटित 30 सेकंड में प्रतिक्रिया देने का समय नहीं हो सकता है।

किस बात पर ध्यान दें

कुछ व्यावहारिक बिंदु. एमसीपी सर्वर विश्वसनीय कोड हैं: स्थानीय सर्वर आपके अधिकारों के साथ आपकी मशीन पर चलता है, और आप दूरस्थ सर्वर पर अनुरोध डेटा भेजते हैं। इसलिए, इंटरनेट से यादृच्छिक सर्वर स्थापित करना किसी भी तृतीय-पक्ष सीएलआई के समान सावधानी के साथ किया जाना चाहिए।

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

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

लिंक

https://opencode.ai/docs/mcp-servers/
https://opencode.ai/docs/config/
https://modelcontextprotocol.io/
https://github.com/upstash/context7
https://mcp.sentry.dev
https://mcp.grep.app
https://github.com/anomalyco/opencode

स्रोत

https://opencode.ai/docs/mcp-servers/
https://modelcontextprotocol.io/
https://api-docs.deepseek.com/
https://api-docs.deepseek.com/quick_start/agent_integrations/opencode

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

डीपसीक हार्नेस का मुख्य विचार “सब कुछ एक प्लगइन है” के रूप में तैयार किया गया है – शाब्दिक रूप से “सब कुछ एक प्लगइन है”। संपूर्ण उत्पाद इस पर बनाया गया है: मॉडल एडेप्टर, एक टूल रजिस्ट्री, एक सत्र लॉग, एक इंटरफ़ेस और यहां तक ​​कि एजेंट चक्र भी। यह कॉर्डिस फ्रेमवर्क पर आधारित है, इसलिए एक डेवलपर न केवल एक नया कमांड जोड़ सकता है, बल्कि कर्नेल को फोर्क किए बिना एजेंट के संपूर्ण व्यवहार को बदल सकता है।

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

आपको क्या चाहिए

वेब इंटरफ़ेस और सीएलआई के लिए Node.js की आवश्यकता है। परियोजना की सख्त आवश्यकताएं हैं:

• Node.js 22.19.0 या बाद का संस्करण 22.x लाइन में।
• Node.js 24.0.0 या बाद का संस्करण 24.x लाइन में।
• Node.js 23.x किसी भी पैच में समर्थित नहीं है: यह लाइन LTS नहीं है और पहले ही बंद कर दी गई है।

Node.js के अलावा, आपको DeepSeek API कुंजी की आवश्यकता होगी। यह आपके व्यक्तिगत खाते मेंplatform.depseek.com पर बनाया गया है। डेस्कटॉप एप्लिकेशन को Node.js की आवश्यकता नहीं है – पर्यावरण वहां पहले से ही पैक किया गया है।

आप कमांड से संस्करण की जांच कर सकते हैं:

node -v

एनपीएक्स के माध्यम से स्थापना

प्रोजेक्ट को जानने का सबसे तेज़ तरीका वैश्विक स्तर पर कुछ भी इंस्टॉल नहीं करना है। सिर्फ दौड़ें:

npx @deepseek-ai/dsh web

कमांड npm से @depseek-ai/dsh पैकेज डाउनलोड करेगा, एक स्थानीय वेब सर्वर सेट करेगा और ब्राउज़र में इंटरफ़ेस खोलेगा। डिफ़ॉल्ट रूप से यह पते को सुनता है:

https://127.0.0.1:3080

यदि आपको ब्राउज़र खोलने की आवश्यकता नहीं है, उदाहरण के लिए रिमोट मशीन पर, तो –no-open ध्वज जोड़ें:

npx @deepseek-ai/dsh web --no-open

एसएसएच के माध्यम से लॉन्च होने पर, डीएसएच पता प्रिंट करता है लेकिन ब्राउज़र खोलने का प्रयास नहीं करता है: स्थानीय पता एसएसएच क्लाइंट या संपादक के स्वामित्व में होता है।

वैश्विक स्थापना

यदि आपको लगातार किसी टूल की आवश्यकता होती है, तो इसे विश्व स्तर पर स्थापित करना अधिक सुविधाजनक है। पैकेज dsh बाइनरी प्रदान करता है:

npm install -g @deepseek-ai/dsh
dsh web

इसके बाद dsh कमांड किसी भी डायरेक्टरी से उपलब्ध होता है। अद्यतन सामान्य तरीके से किया जाता है:

npm install -g @deepseek-ai/dsh@latest

डेस्कटॉप एप्लिकेशन

उन लोगों के लिए जो टर्मिनल और Node.js को होल्ड नहीं करना चाहते, डीपसीक डेस्कटॉप बिल्ड जारी करता है। वे आधिकारिक डाउनलोड पृष्ठ पर उपलब्ध हैं:

• macOS – Apple सिलिकॉन, macOS 13 या बाद का संस्करण, DMG प्रारूप।
• विंडोज़ – 64-बिट असेंबली, EXE प्रारूप।

एप्लिकेशन उन्हीं स्थानीय फ़ाइलों के साथ काम करता है, पृष्ठभूमि में कार्य कर सकता है और वेब संस्करण की तरह ही सत्रों को संग्रहीत करता है। यह रोजमर्रा के काम के लिए एक सुविधाजनक विकल्प है, जब आप हर बार सर्वर को मैन्युअल रूप से बढ़ाना नहीं चाहते हैं।

स्रोतों से निर्माण

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

corepack enable
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web

pnpm run build कमांड पैकेज और फ्रंटएंड आर्टिफैक्ट तैयार करता है, और pnpm dsh वेब पुनर्निर्माण के बिना पहले से निर्मित संस्करण चलाता है। विकास के लिए, एक मोड pnpm run dev:web है: यह सर्वर बनाता है, शुरू करता है और स्रोत बदलने पर क्लाइंट बंडलों का पुनर्निर्माण करता है।

पहला लॉन्च

वेब इंटरफ़ेस प्रारंभ करने के बाद प्रक्रिया इस प्रकार है.

सबसे पहले, सेटिंग्स → मॉडल खोलें और डीपसीक एपीआई कुंजी दर्ज करें। कुंजी फ़ाइल $DSH_HOME/.credentials.yaml में सहेजी गई है, और इसका केवल एक लिंक सेटिंग्स में रहता है। सेटिंग्स पृष्ठ को रहस्य का पहले से ही छिपा हुआ विवरण प्राप्त होता है, इसलिए इंटरफ़ेस से कुंजी को वापस पढ़ना असंभव है। मॉडल परिवर्तन अगले अनुरोध से लागू होते हैं; सर्वर को पुनरारंभ करने की कोई आवश्यकता नहीं है.

फिर कार्यस्थान चुनें के माध्यम से अपना कार्य फ़ोल्डर चुनें। जबकि कार्यक्षेत्र चयनित नहीं है, कार्य इनपुट फ़ील्ड धूसर बनी रहती है। यह जानबूझकर किया जाता है: एजेंट को उन सीमाओं को समझना चाहिए जिनके भीतर उसे फ़ाइलों को पढ़ने और बदलने की अनुमति है।

इसके बाद आप पहला टास्क सबमिट कर सकते हैं. उदाहरण के लिए:

Summarize this repository and identify its main packages.

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

मॉडल और प्रदाता

डीपसीक एक चरण में कनेक्ट होता है: सेटिंग्स में प्रदाता कार्ड में एपीआई कुंजी के लिए केवल एक फ़ील्ड होता है। इसके अतिरिक्त, आप तृतीय-पक्ष सेवाएँ जोड़ सकते हैं। अंतर्निहित निर्देशिका किमी के लिए एंथ्रोपिक, openai, moonshotai और GLM के लिए zai जैसे पहचानकर्ताओं को जानती है।

आपके अपने गेटवे, कॉर्पोरेट प्रॉक्सी या स्थानीय सर्वर के लिए, एक कस्टम मॉडल एपीआई मोड है। यह पूछता है:

• स्थायी प्रदाता पहचानकर्ता;
• प्रदर्शन नाम;
• एपीआई आधार पता;
• प्रोटोकॉल: OpenAI चैट पूर्णताएं, OpenAI प्रतिक्रियाएं या मानवीय संदेश;
• कुंजी और मॉडलों की सूची।

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

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

प्लगइन्स और क्रिएटर मोड

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

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

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

dsh plugin --profile web add some-dsh-plugin

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

dsh --profile web --dump-config

कमांड सर्वर शुरू किए बिना असेंबल किए गए प्लगइन ट्री को प्रिंट करता है। यदि कोई नई परत नहीं है, तो बंडल ने संभवतः dsh.bundle मेनिफ़ेस्ट घोषित नहीं किया और एक सम्मिलित प्लगइन के बजाय एक नियमित लाइब्रेरी के रूप में स्थापित किया।

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

प्रक्षेपवक्र और लेखापरीक्षा

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

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

सत्र JSONL लॉग के रूप में ~/.dsh/sessions में स्थित हैं। आप उन्हें पढ़ सकते हैं, खोज सकते हैं और अपना स्वयं का विश्लेषण बना सकते हैं। इससे उन खर्चों और कैश हिट्स की सटीक गणना करना भी संभव हो जाता है जो नियमित एपीआई बिल में दिखाई नहीं देते हैं।

पृष्ठभूमि कार्य और शेड्यूल

डीपसीक हार्नेस न केवल “पूछें और उत्तर प्राप्त करें” मोड में काम कर सकता है। कार्यों को पृष्ठभूमि में लॉन्च और शेड्यूल किया जा सकता है। उदाहरण के लिए, एजेंट से प्रत्येक शुक्रवार को 17:00 बजे प्रोजेक्ट नोट्स से साप्ताहिक रिपोर्ट एकत्र करने के लिए कहें। इंटरफ़ेस में, ऐसे कार्य अलग से दिखाई देते हैं: आप स्थिति की जांच कर सकते हैं, इतिहास देख सकते हैं और निष्पादन विवरण खोल सकते हैं।

स्वचालन के लिए एक हेडलेस प्रोफ़ाइल है। यह एक सत्र शुरू करता है, अंतिम प्रतिक्रिया प्रिंट करता है, और बाहर निकलता है:

dsh --profile headless "run the tests"

यह मोड सीआई, क्रॉन और स्क्रिप्ट के लिए सुविधाजनक है जहां वेब इंटरफ़ेस की आवश्यकता नहीं है। हेडलेस के अलावा, sdk और acp प्रोफाइल उपलब्ध हैं: पहला JSON-RPC के माध्यम से SDK क्लाइंट को सेवा प्रदान करता है, दूसरा ACP stdio के माध्यम से ऑटोमेशन क्लाइंट को सेवा प्रदान करता है।

सबएजेंट, एमसीपी और कौशल

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

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

प्रोफ़ाइल, बंडल और पैच

Dsh कॉन्फ़िगरेशन को तीन परतों से इकट्ठा किया गया है। बंडल कॉन्फ़िगरेशन लाइनों और प्लगइन कोड का एक सेट है, यानी, कार्यक्षमता का एक तैयार टुकड़ा। प्रोफ़ाइल बंडलों की एक नामित संरचना है, जो $DSH_HOME/profiles/ में संग्रहीत है। पैच एक YAML फ़ाइल है जो पहचानकर्ता द्वारा पहले से लोड की गई लाइनों को बदलती है, उन्हें अक्षम करती है, या नई जोड़ती है।

आवेदन का क्रम इस प्रकार है: पहले प्रोफ़ाइल क्रम में बंडल, फिर प्रोफ़ाइल पैच, फिर सामान्य पैच $DSH_HOME/cordis.patch.yml और अंत में ओवरले –patch के माध्यम से प्रसारित होते हैं। इसका मतलब यह है कि बंडल स्रोतों को छुए बिना लगभग किसी भी सेटिंग को ओवरराइड किया जा सकता है। आप परिणामी पेड़ को कमांड से देख सकते हैं:

dsh --profile web --dump-config

एक मानक वेब प्रोफ़ाइल को वेब कहा जाता है, सर्वर रहित प्रोफ़ाइल को हेडलेस कहा जाता है। उनकी सेटिंग फ़ाइलें $DSH_HOME/profiles/web/cordis.patch.yml और $DSH_HOME/profiles/headless/cordis.patch.yml में रहती हैं। यह वह जगह है जहां डीएसएच सेटिंग्स इंटरफ़ेस के माध्यम से किए गए परिवर्तनों को लिखता है।

पायथन एसडीके

पायथन परियोजनाओं के लिए एक आधिकारिक एसडीके है। यह एक आभासी वातावरण में स्थापित है और अपने साथ एक मूल रनटाइम लाता है, इसलिए सामान्य कार्य के लिए सिस्टम Node.js की आवश्यकता नहीं है:

python -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install deepseek-harness-sdk

एक न्यूनतम स्टार्टअप उदाहरण इस तरह दिखता है:

from pathlib import Path

from deepseek_harness import DeepSeekHarness

workspace = Path("C:/work/disposable-workspace").resolve()
dsh_home = Path("C:/work/example-dsh-home").resolve()

with DeepSeekHarness(
    provider="deepseek-official",
    model="deepseek-v4-flash",
    max_tokens=49_152,
    cwd=str(workspace),
    dsh_home=str(dsh_home),
    profile="sdk-minimal",
) as harness:
    result = harness.run(
        "Inspect the repository and fix the failing tests.",
        session_id="example-001",
    )

print(result.final_response)

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

किस बात पर ध्यान दें

डीपसीक हार्नेस एक डेवलपर पूर्वावलोकन संस्करण 0.1.0-rc.x है। README स्पष्ट रूप से चेतावनी देता है कि अनुकूलता टूट जाएगी। प्रयोगों, व्यक्तिगत परियोजनाओं और स्वचालन के लिए, यह ठीक है, लेकिन ऐसी प्रक्रिया के लिए जो अभी पैसा कमाती है, जोखिम को तौलना और बैकअप योजना रखना उचित है।

दूसरा बिंदु Node.js है। यदि आपके पास 22.18 या 23.x है, तो इंस्टॉलेशन क्रैश हो जाएगा या अप्रत्याशित रूप से व्यवहार करेगा। संस्करण को पहले से जांचें: प्रोजेक्ट नोड: एसक्लाइट और टाइपस्क्रिप्ट के अंतर्निहित प्रकारों का उपयोग करता है जिन्हें एक नई शाखा की आवश्यकता होती है।

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

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

क्या यह प्रयास करने लायक है

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

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

लिंक

https://www.deepseek.com/harness/
https://www.deepseek.com/download/
https://github.com/deepseek-ai/deepseek-harness
https://deepseek-harness.github.io/deepseek-harness/en/guide/quickstart
https://deepseek-harness.github.io/deepseek-harness/en/guide/providers
https://deepseek-harness.github.io/deepseek-harness/en/guide/python-sdk
https://platform.deepseek.com/

स्रोत

https://github.com/deepseek-ai/deepseek-harness/blob/master/README.md
https://github.com/deepseek-ai/deepseek-harness/blob/master/apps/cli/README.md
https://deepseek-harness.github.io/deepseek-harness/en/guide/quickstart
https://deepseek-harness.github.io/deepseek-harness/en/guide/providers
https://deepseek-harness.github.io/deepseek-harness/en/guide/python-sdk
https://deepseek-harness.github.io/deepseek-harness/en/guide/plugin-market
https://dshdocs.com/getting-started/installation/
https://dshdocs.com/concepts/profiles-bundles-patches/
https://dshdocs.com/guides/dsh-vs-claude-code/

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

इस पोस्ट में, मैं देखूंगा कि निर्णय मॉडल क्या हैं, वे HTTP स्तर पर कैसे काम करते हैं, कौन से मॉडल पहले से ही उपलब्ध हैं, और उन्हें मौजूदा कोड में कैसे बनाया जाए ताकि नियमित जेनरेटर मॉडल काम करना जारी रखें।

निर्णय मॉडल नियमित मॉडल से किस प्रकार भिन्न हैं

एक नियमित एलएलएम एक संकेत प्राप्त करता है और टोकन द्वारा टेक्स्ट टोकन उत्पन्न करता है। यहां तक ​​कि अगर आप उससे एक शब्द में उत्तर देने के लिए कहते हैं, तब भी पीढ़ी अंदर होती है, और उत्तर के प्रारूप को एक आरेख, निर्देशों और उसके बाद के सत्यापन द्वारा नियंत्रित किया जाना चाहिए। निर्णय मॉडल अलग तरीके से काम करता है: आप प्रकार के साथ स्थिति और प्रश्नों को पास करते हैं, और मॉडल संभावनाओं और चयनित विकल्पों को लौटाता है। कोई निःशुल्क पाठ नहीं, प्रतिक्रिया से कोई JSON पार्सिंग नहीं।

नए समापन बिंदु को /v1/systemone कहा जाता है। एक अनुरोध में, आप एक साथ कई प्रश्न पूछ सकते हैं, और मॉडल उन सभी का उत्तर देगा। यह उन कार्यों के लिए सुविधाजनक है जहां आपको कई संबंधित निर्णय लेने की आवश्यकता होती है: उदाहरण के लिए, टीम का निर्धारण, वापसी की आवश्यकता और टिकट की तात्कालिकता।

कौन से मॉडल उपलब्ध हैं

अब आप ओलामा के माध्यम से तीन निर्णय मॉडल चला सकते हैं:

• फुर्तीला बेस्पोक लैब्स के 9 अरब मापदंडों वाला एक खुला मॉडल है। यह उपलब्ध सबसे बड़ा और सबसे सटीक है।
• tev1 एक प्रायोगिक मॉडल है जिसमें टुगेदर एआई से 4 बिलियन पैरामीटर हैं।
• tev1:0.8b टुगेदर AI के 0.8 बिलियन पैरामीटर वाला एक प्रायोगिक मॉडल है। सबसे तेज़ और आसान.

वे सभी स्थानीय रूप से काम करते हैं, भुगतान की आवश्यकता नहीं होती है और किसी बाहरी सेवा को डेटा नहीं भेजते हैं। ओलामा 0.35 और बाद के संस्करण समर्थित हैं।

स्थापना

पहले ओलामा संस्करण की जाँच करें:

ollama --version

फिर वांछित मॉडल डाउनलोड करें. सबसे आसान के लिए:

ollama pull tev1:0.8b

Tev1 के पूर्ण संस्करण के लिए:

ollama pull tev1

फुर्तीला के लिए:

ollama pull nimble

फुर्तीला मॉडल लगभग 9.5 जीबी डिस्क स्थान लेता है, इसलिए डाउनलोड करने से पहले कुछ स्थान खाली करना एक अच्छा विचार है। Tev1:0.8b एक गीगाबाइट से भी कम समय लेता है।

कर्ल के माध्यम से पहला अनुरोध

सबसे सरल उदाहरण यह निर्धारित करना है कि कोई टेक्स्ट नौकरी का विज्ञापन है या नहीं:

curl http://localhost:11434/v1/systemone -d '{
  "model": "tev1:0.8b",
  "state": {
    "message": "Senior Swift developer, Berlin, remote friendly"
  },
  "questions": {
    "isJob": {
      "type": "noul",
      "instructions": "Does the message advertise a job posting that someone can apply to?"
    }
  }
}'

उत्तर इस प्रकार दिखता है:

{
  "model": "tev1:0.8b",
  "answers": {
    "isJob": {
      "type": "noul",
      "noul": 0.921
    }
  },
  "usage": {
    "input_tokens": 42,
    "output_tokens": 0
  }
}

नॉल फ़ील्ड 0 से 1 तक की संभावना है। निर्णय आमतौर पर 0.5 की सीमा के साथ तुलना करके किया जाता है। जेनरेटिव मॉडल के विपरीत, JSON प्रारूप में प्रतिक्रिया मांगने और फिर जांचने की आवश्यकता नहीं है कि मॉडल ने इसे तोड़ा नहीं है।

प्रश्नों के प्रकार

निर्णय मॉडल तीन प्रकार के प्रश्नों का समर्थन करते हैं।

noul एक द्विआधारी प्रश्न है। किसी कथन के सत्य होने की प्रायिकता लौटाता है:

{
  "questions": {
    "refund": {
      "type": "noul",
      "instructions": "Does the customer explicitly ask for a refund?"
    }
  }
}

विकल्प – दिए गए सेट में से एक विकल्प का चयन करना। चयनित विकल्प, सभी विकल्पों की संभावनाएँ और विश्वास लौटाता है:

{
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this ticket?",
      "criteria": {
        "billing": "Payments and refunds",
        "technical": "Bugs and integrations",
        "other": "None of the above"
      }
    }
  }
}

स्कोर – पैमाने पर रेटिंग। प्रत्येक स्केल बिंदु के लिए संख्या, किंवदंती और संभावनाएं लौटाता है:

{
  "questions": {
    "urgency": {
      "type": "score",
      "instructions": "How urgent is this ticket?",
      "criteria": ["Routine", "Soon", "Urgent"]
    }
  }
}

एक अनुरोध में एक साथ विभिन्न प्रकार के कई प्रश्न हो सकते हैं। यही वह है जो निर्णय मॉडल को ट्राइएज के लिए सुविधाजनक बनाता है: एक ऑपरेशन, एक राज्य, कई स्वतंत्र निर्णय।

अतिरिक्त पुस्तकालयों के बिना पायथन

अनुरोधों के लिए, मानक urllib पर्याप्त है; एक अलग SDK की आवश्यकता नहीं है:

import json
from urllib.request import Request, urlopen

OLLAMA_DECISION_URL = "http://localhost:11434/v1/systemone"

def ask_decision(state, questions, model="tev1:0.8b"):
    payload = {
        "model": model,
        "state": state,
        "questions": questions,
    }
    request = Request(
        OLLAMA_DECISION_URL,
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    with urlopen(request, timeout=3600) as response:
        return json.loads(response.read().decode())["answers"]

उपयोग:

answers = ask_decision(
    {"message": "Senior Swift developer, Berlin, remote friendly"},
    {
        "isJob": {
            "type": "noul",
            "instructions": "Does the message advertise a job posting that someone can apply to?"
        }
    },
)

probability = answers["isJob"]["noul"]
is_job = probability >= 0.5

यदि आपको आधिकारिक पायथन एसडीके की आवश्यकता है, तो इसे टाइपसेफ़-एसडीके कहा जाता है। लोकलहोस्ट के लिए, इसे पर्यावरण चर TYPESAFE_BASE_URL, TYPESAFE_API_KEY और TYPESAFE_DEFAULT_MODEL के साथ ओलामा को निर्देशित किया जा सकता है। लेकिन सरल कार्यों के लिए, सीधा HTTP अनुरोध पर्याप्त है।

कैसे समझें कि एक मॉडल निर्णय का समर्थन करता है

निर्णय मॉडल /api/generate या /api/chat के माध्यम से प्रतिक्रिया नहीं दे सकते। यदि आप ऐसा अनुरोध भेजते हैं, तो ओलामा इस पाठ के साथ 400 त्रुटि लौटाएगा:

"tev1:0.8b" does not support generate

यह महत्वपूर्ण है यदि आपके पास पहले से ही कोड है जो /api/generate के माध्यम से नियमित मॉडल के साथ काम करता है: यदि आप मॉडल को निर्णय मॉडल में बदलते हैं, तो यह काम करना बंद कर देगा। /api/show के माध्यम से मॉडल की क्षमताओं का पहले से पता लगाना और उचित कॉलिंग विधि चुनना बेहतर है:

import json
from urllib.request import Request, urlopen

OLLAMA_SHOW_URL = "http://localhost:11434/api/show"

def supports_decision(model):
    request = Request(
        OLLAMA_SHOW_URL,
        data=json.dumps({"model": model}).encode(),
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    try:
        with urlopen(request, timeout=30) as response:
            capabilities = json.loads(response.read().decode()).get("capabilities", [])
    except (OSError, TypeError, ValueError):
        return False
    return "decision" in capabilities

निर्णय मॉडल में उनकी क्षमताओं में केवल निर्णय होगा। नियमित मॉडल में पूर्णता, उपकरण या अन्य सुविधाएं होंगी। यदि ओलामा उपलब्ध नहीं है, तो मॉडल को सामान्य मानना ​​और जेनरेटिव पथ का उपयोग करना उचित है।

मौजूदा कोड में कैसे एम्बेड करें

सबसे आसान तरीका क्लासिफायरियर को फिर से लिखना नहीं है, बल्कि इसे दो रणनीतियों में विभाजित करना है। जेनरेटिव रणनीति पहले की तरह काम करती है: यह प्रॉम्प्ट एकत्र करती है, इसे /api/generate पर भेजती है और JSON को पार्स करती है। निर्णय रणनीति राज्य और टाइप किए गए प्रश्न को /v1/systemone पर भेजती है और संभावना की तुलना सीमा से करती है।

क्लासिफायरियर बनाते समय रणनीति का चुनाव एक ही स्थान पर होता है:

def create_classifier(model):
    if supports_decision(model):
        return DecisionClassifier(model)
    return GenerativeClassifier(model)

इस दृष्टिकोण के कई फायदे हैं. जनरेटिव मॉडल अपरिवर्तित चलते रहते हैं। निर्णय मॉडल को एक पर्यावरण चर को बदलकर सक्षम किया जा सकता है। और दोनों विधियों के बीच का पूरा अंतर दो छोटे वर्गों में केंद्रित है, और पूरे एप्लिकेशन में फैला हुआ नहीं है।

द्विआधारी वर्गीकरण के लिए, निर्णय रणनीति कुछ इस तरह दिखती है:

async def classify(text):
    answers = await ask_decision(
        {"message": text},
        {
            "isJob": {
                "type": "noul",
                "instructions": instructions,
            }
        },
        model,
    )
    probability = answers["isJob"]["noul"]
    return probability >= 0.5, probability

कृपया ध्यान दें कि निर्णय मॉडल कोई स्पष्टीकरण नहीं लौटाता है। यदि आपके परिणाम प्रारूप में कोई कारण फ़ील्ड है, तो आप इसे संभाव्यता से बना सकते हैं: उदाहरण के लिए, संभाव्यता को स्वयं या “मॉडल ने रिक्ति के रूप में संदेश को 0.935 पर रेट किया है” जैसी स्ट्रिंग को संग्रहीत करें। यह उस कारण का आविष्कार करने से अधिक ईमानदार है जो मॉडल ने नहीं दिया।

निर्देश एक प्रश्न होना चाहिए

यह सबसे महत्वपूर्ण व्यावहारिक निष्कर्ष है. निर्णय मॉडल “आप संदेशों को वर्गीकृत करते हैं, सही उत्तर देते हैं…, अन्यथा गलत” की शैली में लंबे संकेतों को नहीं समझते हैं। वे एक छोटा, सीधा प्रश्न चाहते हैं।

रिक्ति के बारे में उसी संदेश पर, मुझे निम्नलिखित संभावनाएँ प्राप्त हुईं:

• सीधा प्रश्न “क्या यह संदेश नौकरी पोस्टिंग है?” — 0.921.
• रिक्त किसे माना जाता है, इसकी व्याख्या करने वाले लंबे निर्देश – 0.026।
• अंत में एक प्रश्न के साथ लंबे निर्देश – 0.391.

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

एक अलग पर्यावरण चर बनाना सुविधाजनक है:

OLLAMA_JOB_CLASSIFIER_DECISION_INSTRUCTIONS=Does the message advertise a job posting that someone can apply to?

और केवल जेनरेटिव पथ के लिए नियमित प्रॉम्प्ट का उपयोग करें।

सीमा और संभावनाएं

0.5 की सीमा डिफ़ॉल्ट मान के रूप में उपयुक्त है, लेकिन इसे कॉन्फ़िगरेशन में शामिल करना उपयोगी है। विभिन्न कार्यों के लिए, झूठी सकारात्मक और झूठी नकारात्मक प्रतिक्रिया की लागत अलग-अलग होती है। संयम के लिए, सीमा बढ़ाना अधिक सुरक्षित है; रिक्तियों की खोज के लिए, इसे कम करना अधिक सुरक्षित है, ताकि उपयोगी संदेश न छूटें।

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

प्रदर्शन और स्मृति

गति काफी हद तक मॉडल और हार्डवेयर के आकार पर निर्भर करती है। मेरे परीक्षणों में सीपीयू पर मुझे निम्नलिखित नंबर मिले:

• tev1:0.8b – हल करने के लिए सेकंड विभाजित करें, आसानी से मेमोरी में फिट हो जाता है।
• tev1 – 4बी, काफ़ी धीमा, लेकिन फिर भी इंटरैक्टिव कार्यों के लिए उपयुक्त।
• फुर्तीला – Q8_0 में 9बी, लगभग 10 जीबी मेमोरी। मॉडल को लोड करने सहित पहले अनुरोध में लगभग 137 सेकंड का समय लगा, बाद के समाधानों में सीपीयू पर 12 से 32 सेकंड का समय लगा।

निंबले को बहुत अधिक रैम की आवश्यकता होती है। 16 जीबी वाली मशीन और लगभग 8 जीबी की सीमा वाली डॉकर/डब्लूएसएल पर, मॉडल फिट नहीं बैठता: सिस्टम स्वैप करना शुरू कर देता है और कंटेनर प्रतिक्रिया देना बंद कर देते हैं। .wslconfig फ़ाइल के माध्यम से WSL सीमा को 12 जीबी तक बढ़ाने से मदद मिली:

[wsl2]
memory=12GB
swap=8GB

परिवर्तन के बाद, आपको wsl –shutdown और डॉकर डेस्कटॉप को पुनरारंभ करना होगा। लेकिन 12 जीबी के साथ भी, रिज़र्व छोटा रहता है: मॉडल लगभग 10 जीबी लेता है, और सिस्टम के लिए बहुत कुछ नहीं बचा है।

डिफ़ॉल्ट रूप से, ओलामा पांच मिनट की निष्क्रियता के बाद मेमोरी खाली करते हुए मॉडल को अनलोड कर देता है। यह सुविधाजनक है: फुर्तीला हर समय 10 जीबी व्यस्त नहीं रखता है, लेकिन प्रत्येक नए लॉन्च के बाद एक ठहराव के बाद मॉडल फिर से लोड होना शुरू हो जाता है।

निर्णय मॉडल का उपयोग कब करें

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

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

वे उन कार्यों के लिए उपयुक्त नहीं हैं जहां विस्तृत पाठ की आवश्यकता होती है: स्पष्टीकरण, फ़ील्ड निष्कर्षण, सारांश, उत्तर सृजन। इस प्रयोजन के लिए, सामान्य जनरेटिव मॉडल बने रहते हैं। संयुक्त होने पर सबसे अच्छा परिणाम प्राप्त होता है: एक निर्णय मॉडल एक निर्णय लेता है, और एक जेनरेटिव मॉडल इसे समझाता है या डेटा निकालता है।

कुल

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

सूत्रों का कहना है
https://ollama.com/blog/ollama-now-supports-jev-style-decision-models
https://ollama.com/library/nimble
https://ollama.com/library/tev1
https://typesafe.ai

ओपनकोड एक खुला प्रोग्रामिंग एजेंट है जो टर्मिनल में काम करता है: प्रोजेक्ट फाइलें पढ़ता है, कोड संपादित करता है, कमांड चलाता है और परीक्षण करता है, रिपॉजिटरी खोजता है और गिट के साथ काम करता है। यह किसी एक मॉडल प्रदाता से बंधा नहीं है, इसलिए लगभग किसी भी OpenAI-संगत सेवा को इससे जोड़ा जा सकता है।

FreeLLMAPI एक खुला स्व-होस्टेड राउटर है जो एक OpenAI-संगत /v1 पते के तहत दर्जनों AI प्रदाताओं से मुफ्त योजनाएं एकत्र करता है। तीस कुंजियों, तीस सीमाओं और तीस स्थानों के बजाय जहां अनुरोध विफल हो सकता है, आपके पास एक स्थानीय गेटवे और एक एकीकृत कुंजी है। राउटर स्वयं एक उपलब्ध मॉडल का चयन करता है, त्रुटि 429 या 5xx होने पर अगले मॉडल पर स्विच करता है, और यह सुनिश्चित करता है कि अनुरोध मुफ्त टैरिफ के कोटा से अधिक न हों।

इस पोस्ट में मैं फ्रीएलएलएमएपीआई स्थापित करने, प्रदाताओं को जोड़ने और गेटवे को ओपनकोड से जोड़ने का वर्णन करूंगा।

आपको क्या चाहिए

काम करने के लिए आपको चार चीजों की आवश्यकता है:

• OpenCode इंस्टॉल हो गया है। यदि एजेंट अभी तक इंस्टॉल नहीं हुआ है, तो मैंने OpenCode और DeepSeek के बारे में एक अलग नोट में इंस्टॉलेशन प्रक्रिया पर चर्चा की है।
• FreeLLMAPI चल रहा है। सबसे आसान तरीका डेस्कटॉप एप्लिकेशन या डॉकर कंटेनर इंस्टॉल करना है।
• Node.js 20.18 या बाद का। यह CLI जनरेटर के लिए आवश्यक है जो OpenCode को कॉन्फ़िगर करता है। ओपनकोड स्वयं नोड के बिना स्थापित किया जा सकता है।
• कम से कम एक प्रदाता की कुंजी। कैटलॉग से Google AI स्टूडियो, ग्रोक, सेरेब्रस, मिस्ट्रल, ओपनराउटर, NVIDIA, हगिंगफेस और अन्य सेवाओं की मुफ्त योजनाएं उपयुक्त हैं।

FreeLLMAPI इंस्टॉल कर रहा है

प्रोजेक्ट में कई इंस्टॉलेशन पथ हैं। वह चुनें जो आपके सिस्टम के लिए अधिक सुविधाजनक हो।

डेस्कटॉप एप्लिकेशन

विंडोज़ और मैकओएस के लिए सबसे आसान विकल्प रिलीज़ पेज से तैयार इंस्टॉलर है। विंडोज़ पर यह .exe है, MacOS पर यह Apple सिलिकॉन या Intel के लिए .dmg है। एप्लिकेशन ट्रे में रहता है और नियंत्रण कक्ष के साथ-साथ राउटर को स्थानीय स्तर पर उठाता है।

डेस्कटॉप संस्करण के लिए पासवर्ड की आवश्यकता नहीं है: पैनल एक छिपे हुए स्थानीय खाते के माध्यम से स्वयं लॉग इन करता है। आपको जिस एकमात्र क्रेडेंशियल की आवश्यकता होगी वह ट्रे पॉप-अप विंडो से या कुंजी पेज हेडर से एकीकृत कुंजी है।

एप्लिकेशन डेटा एक निर्देशिका में स्थित है:

• Windows — %APPDATA%\FreeLLMAPI\
• macOS — ~/Library/Application Support/FreeLLMAPI/
• Linux — ~/.config/FreeLLMAPI/

Docker

यदि डॉकर पहले से ही स्थापित है, तो सर्वर को एक कमांड के साथ ऊपर उठाया जाता है। स्क्रिप्ट ~/freellmapi निर्देशिका बनाती है, एक एन्क्रिप्शन कुंजी उत्पन्न करती है, छवि डाउनलोड करती है और कंटेनर शुरू करती है:

curl -fsSL https://freellmapi.co/install.sh | bash

स्क्रिप्ट को दोबारा चलाना सुरक्षित है: .env फ़ाइल और एन्क्रिप्शन कुंजी सहेजी जाती है, और कंटेनर को नवीनतम संस्करण में अपडेट किया जाता है। विंडोज़ पर, यह विधि WSL या किसी बैश वातावरण में काम करती है।

लॉन्च के बाद, पैनल यहां खुलता है:

http://localhost:3001

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

docker compose logs -f freellmapi

Docker Compose

यदि आप कॉन्फ़िगरेशन को गिट में रखना चाहते हैं और लॉन्च को मैन्युअल रूप से प्रबंधित करना चाहते हैं, तो नियमित कंपोज़ करेगा। MacOS और Linux पर:

git clone https://github.com/tashfeenahmed/freellmapi.git
cd freellmapi
ENCRYPTION_KEY="$(openssl rand -hex 32)"
printf "ENCRYPTION_KEY=%s\nPORT=3001\n" "$ENCRYPTION_KEY" > .env
docker compose up -d

विंडोज़ पॉवरशेल में:

git clone https://github.com/tashfeenahmed/freellmapi.git
cd freellmapi
$Bytes = New-Object Byte[] 32
[Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($Bytes)
$ENCRYPTION_KEY = -join ($Bytes | ForEach-Object { "{0:x2}" -f $_ })
"ENCRYPTION_KEY=$ENCRYPTION_KEY`nPORT=3001" | Out-File -Encoding utf8 .env
docker compose up -d

ENCRYPTION_KEY कुंजी आवश्यक है: इसका उपयोग SQLite डेटाबेस में प्रदाता कुंजियों को एन्क्रिप्ट करने के लिए किया जाता है। आप इसे तुरंत नहीं बदल सकते – पुराने रहस्य अब डिक्रिप्ट नहीं किए जाएंगे। रोटेशन के लिए, प्रोजेक्ट में एक अलग कमांड रोटेट-एन्क्रिप्शन-की है।

स्रोत से चल रहा है

विकास या डिबगिंग के लिए, आप प्रोजेक्ट को Node.js के माध्यम से चला सकते हैं:

git clone https://github.com/tashfeenahmed/freellmapi.git
cd freellmapi
npm install
ENCRYPTION_KEY="$(node -e 'console.log(require("crypto").randomBytes(32).toString("hex"))')"
printf "ENCRYPTION_KEY=%s\nPORT=3001\n" "$ENCRYPTION_KEY" > .env
npm run dev

इस मोड में, एपीआई और पैनल को पोर्ट 3001 पर उठाया जाता है, और वाइट इंटरफ़ेस को 5173 पर उठाया जाता है।

प्रथम लॉन्च और प्रदाता कुंजी

पैनल खोलें, कुंजियाँ पृष्ठ पर जाएँ और हमारे द्वारा उपयोग की जाने वाली सेवाओं की कुंजियाँ जोड़ें। प्रत्येक प्रदाता के लिए, इंटरफ़ेस में पंजीकरण के लिए एक लिंक और कुंजी कहाँ से प्राप्त करें, इसका संकेत होता है। एक या दो से शुरुआत करना पर्याप्त है: उदाहरण के लिए, Google AI स्टूडियो और ग्रोक।

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

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

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

एकीकृत कुंजी वहां, कुंजी पृष्ठ पर, या डेस्कटॉप एप्लिकेशन की ट्रे में ली जाती है। यह उपसर्ग के साथ एक स्ट्रिंग जैसा दिखता है:

freellmapi-...

यह कुंजी है, न कि व्यक्तिगत प्रदाताओं की कुंजी, जिसे ओपनकोड में दर्शाया गया है।

OpenCode से कनेक्ट करें

FreeLLMAPI में एक कॉन्फ़िगरेशन जनरेटर है जो स्वयं चल रहे गेटवे से मॉडल निर्देशिका को पढ़ता है, मौजूदा कॉन्फ़िगरेशन की बैकअप प्रतिलिपि बनाता है और प्रदाता को सावधानीपूर्वक इसमें जोड़ता है।

सबसे पहले, आइए एकीकृत कुंजी को पर्यावरण चर पर सेट करें। जनरेटर इसे एक अलग ध्वज के बजाय पढ़ता है, इसलिए रहस्य कमांड इतिहास में समाप्त नहीं होगा।

MacOS और Linux पर:

export FREELLMAPI_API_KEY=freellmapi-YOUR_KEY

विंडोज़ पॉवरशेल में:

$env:FREELLMAPI_API_KEY="freellmapi-YOUR_KEY"

अब आइए देखें कि वास्तव में क्या दर्ज किया जाएगा:

npx freellmapi setup-opencode --url http://localhost:3001 --dry-run

यदि अंतर संतोषजनक है, तो ध्वज के बिना आदेश दोहराएं:

npx freellmapi setup-opencode --url http://localhost:3001

जनरेटर वैश्विक ओपनकोड कॉन्फ़िगरेशन लिखता है:

~/.config/opencode/opencode.json

फ्रीलमैपी प्रदाता इसमें @ai-sdk/openai-compatible पैकेज, आधार पता http://localhost:3001/v1 और लाइव कैटलॉग से मॉडलों का एक नक्शा के साथ दिखाई देता है। डिफ़ॉल्ट मॉडल फ्रीलमैपी/ऑटो बन जाता है।

कुंजी स्वयं फ़ाइल में समाप्त नहीं होती है: कॉन्फ़िगरेशन में प्रतिस्थापन {env:FREELLMAPI_API_KEY} होता है। इसलिए, एजेंट शुरू होने पर वेरिएबल सेट रहना चाहिए:

opencode

यह विधि सुविधाजनक भी है क्योंकि रहस्य कॉन्फ़िगरेशन में समाप्त नहीं होता है और गिट में समाप्त नहीं होगा। सीआई और वन-टाइम रन के लिए, यह कुंजी को फ़ाइल में संग्रहीत करने से अधिक सही है।

मैन्युअल सेटिंग

यदि आप जनरेटर नहीं चलाना चाहते हैं, तो आप प्रदाता का मैन्युअल रूप से opencode.json में वर्णन कर सकते हैं। न्यूनतम विकल्प इस प्रकार दिखता है:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "freellmapi/auto",
  "provider": {
    "freellmapi": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "FreeLLMAPI",
      "options": {
        "baseURL": "http://localhost:3001/v1",
        "apiKey": "{env:FREELLMAPI_API_KEY}"
      },
      "models": {
        "auto": {
          "name": "FreeLLMAPI Auto Router",
          "limit": { "context": 1048576, "output": 65536 }
        }
      }
    }
  }
}

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

curl http://localhost:3001/v1/models

यदि आपको मैन्युअल रूप से उन पर स्विच करने की आवश्यकता है तो आप मॉडल सूची में विशिष्ट पहचानकर्ता जोड़ सकते हैं। लेकिन रोजमर्रा के काम के लिए, ऑटो पर्याप्त है: राउटर स्वयं एक लाइव मॉडल का चयन करेगा और सीमा समाप्त होने पर स्विच करेगा।

इसका उपयोग कैसे करें

ओपनकोड लॉन्च करने के बाद, मॉडलों की सूची एक परिचित कमांड के साथ खुलती है:

/models

इसमें एक FreeLLMAPI प्रदाता और एक ऑटो मॉडल होगा। फिर कार्य सामान्य रूप से आगे बढ़ता है: हम कार्य का वर्णन करते हैं, @ के माध्यम से फ़ाइलें निर्दिष्ट करते हैं, टैब कुंजी के साथ योजना मोड को स्विच करते हैं, /पूर्ववत करें कमांड के साथ संपादन वापस रोल करते हैं। किसी नए प्रोजेक्ट के लिए, एजेंट द्वारा AGENTS.md बनाने के लिए /init चलाना उपयोगी होता है।

कुछ व्यावहारिक सुझाव:

• रूटिंग। रूटीन के लिए, इसे ऑटो पर छोड़ दें। यदि आपको गति की आवश्यकता है, तो ऑटो: फास्ट आज़माएं, यदि गुणवत्ता ऑटो: स्मार्ट है या कैटलॉग से एक विशिष्ट मजबूत मॉडल है।
• डायग्नोस्टिक्स प्रत्येक गेटवे प्रतिक्रिया में प्रदाता और मॉडल के नाम के साथ एक एक्स-रूटेड-वाया हेडर होता है जो वास्तव में अनुरोध को पूरा करता है। यह दिखाता है कि राउटर ने कार्य कहां भेजा है।
• एनालिटिक्स। एनालिटिक्स पेज पर, पैनल अनुरोधों की मात्रा, सफलता, p50/p95 देरी और प्रदाता द्वारा टोकन खपत दिखाता है।
• संवाद की निरंतरता। बातचीत के बीच में मॉडल स्विच करते समय, गेटवे संदर्भ के हस्तांतरण के बारे में एक संक्षिप्त नोट जोड़ सकता है। वेरिएबल FREELLMAPI_CONTEXT_HANDOFF=on_model_switch द्वारा सक्षम।

यदि OpenCode एक कंटेनर में चल रहा है और FreeLLMAPI एक होस्ट पर चल रहा है, तो लोकलहोस्ट कंटेनर को ही इंगित करेगा। इस मामले में, आपको Host.docker.internal या बेसयूआरएल में कंटेनर से पहुंच योग्य किसी अन्य पते का उपयोग करने की आवश्यकता है।

किस बात पर ध्यान दें

FreeLLMAPI सशुल्क मॉडल का प्रतिस्थापन नहीं है और न ही SLA वाली सेवा है। यह मुफ़्त योजनाओं को एक साफ-सुथरे गेटवे में बंडल करने का एक तरीका है। इसलिए कई प्रतिबंध हैं:

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

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

लिंक

https://github.com/tashfeenahmed/freellmapi
https://freellmapi.co/
https://freellmapi.co/models
https://github.com/tashfeenahmed/freellmapi/releases/latest
https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/install/01-install.md
https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/clients/01-agent-clients.md
https://github.com/tashfeenahmed/freellmapi/blob/main/cli/README.md
https://opencode.ai/
https://opencode.ai/docs/
https://opencode.ai/docs/providers/

स्रोत

https://github.com/tashfeenahmed/freellmapi
https://github.com/tashfeenahmed/freellmapi/blob/main/README.ru.md
https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/install/01-install.md
https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/clients/01-agent-clients.md
https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/clients/02-supported-agents.md
https://github.com/tashfeenahmed/freellmapi/blob/main/cli/README.md
https://opencode.ai/docs/providers/

ओपनकोड एक खुला प्रोग्रामिंग एजेंट है जो सीधे टर्मिनल में काम करता है: प्रोजेक्ट फ़ाइलों को पढ़ता है, कोड संपादित करता है, कमांड चलाता है और परीक्षण करता है, रिपॉजिटरी खोजता है और गिट के साथ काम करता है। इसकी ताकत यह है कि यह एक मॉडल प्रदाता से बंधा नहीं है और दर्जनों प्रदाताओं को जोड़ सकता है।

गीगाचैट Sber का एक बड़ा भाषा मॉडल है। यह ओपनकोड प्रदाताओं की तैयार सूची में नहीं है, लेकिन यह कोई समस्या नहीं है: ओपनकोड वर्सेल एआई एसडीके पैकेज के माध्यम से मनमाने प्रदाताओं को जोड़ता है। गीगाचैट के लिए एक पैकेज gigachat-ai-sdk-provider है, जो OAuth प्राधिकरण और एक्सेस टोकन को अपडेट करने का ख्याल रखता है। एक अलग बारीकियां डिजिटल विकास मंत्रालय के प्रमाणपत्र हैं: उनके बिना, नोड गीगाचैट सर्वर पर भरोसा नहीं करता है, और प्रमाणपत्र सत्यापन त्रुटि के साथ अनुरोध विफल हो जाते हैं।

इस पोस्ट में मैं बताऊंगा कि कुंजी कैसे प्राप्त करें, प्रमाणपत्र कैसे स्थापित करें और गीगाचैट को ओपनकोड से कैसे कनेक्ट करें।

आपको क्या चाहिए

काम करने के लिए आपको तीन चीजों की आवश्यकता है:

• OpenCode इंस्टॉल हो गया है। यदि एजेंट अभी तक इंस्टॉल नहीं हुआ है, तो मैंने OpenCode और DeepSeek के बारे में एक अलग नोट में इंस्टॉलेशन प्रक्रिया पर चर्चा की है।
• GigaChat खाता। GigaChat स्टूडियो में पंजीकरण और प्राधिकरण कुंजी – लॉग इन करने के लिए आपको Sber ID की आवश्यकता होगी।
• आधुनिक टर्मिनल। वेज़टर्म, अलाक्रिट्टी, घोस्टी, किट्टी या कोई अन्य करेगा।

गीगाचैट प्राधिकरण कुंजी

कुंजी आपके गीगाचैट स्टूडियो व्यक्तिगत खाते में बनाई गई है। Developers.sber.ru/studio पर जाएं, लॉग इन करें और GigaChat API अनुभाग में एक प्रोजेक्ट बनाएं। प्रोजेक्ट सेटिंग्स में प्राधिकरण डेटा के साथ एक ब्लॉक है: वहां से कॉपी की गई लाइन बेस 64 में एक तैयार प्राधिकरण कुंजी है। इसे पर्यावरण चर में प्रतिस्थापित किया जाता है, न कि क्लाइंट-सीक्रेट जोड़ी को अलग से।

कुंजी के साथ, दायरा निर्दिष्ट किया गया है – पहुंच क्षेत्र:

• GIGACHAT_API_PERS – व्यक्तियों के लिए।
• GIGACHAT_API_B2B – व्यक्तिगत उद्यमियों और कानूनी संस्थाओं के लिए।
• GIGACHAT_API_CORP – कॉर्पोरेट पहुंच।

प्रदर्शित कुंजी मान को तुरंत सहेजा जाना चाहिए: इसे बाद में दोबारा नहीं दिखाया जाएगा, और यदि आवश्यक हो, तो एक नया जारी करना होगा।

ये लाइन क्या है ये समझना जरूरी है. प्राधिकरण कुंजी एक अलग रहस्य नहीं है, बल्कि client_id:client_secret की एक जोड़ी पहले से ही बेस64 में एन्कोडेड है। गीगाचैट-जेएस लाइब्रेरी इस हेडर को OAuth अनुरोध में प्रतिस्थापित करती है:

Authorization: Basic ваш_ключ_авторизации

जवाब में, एक JWE एक्सेस टोकन लगभग आधे घंटे के जीवनकाल के साथ आता है, और फिर लाइब्रेरी इसे स्वचालित रूप से अपडेट करती है। पैकेज स्वयं जाँचता है कि मान बेस64 के समान है और चेतावनी देता है कि क्या चर में गलती से “कच्चा” क्लाइंट रहस्य शामिल है। इसलिए, तैयार बेस 64 स्ट्रिंग को खाते से कॉन्फ़िगरेशन और पर्यावरण चर में स्थानांतरित करना आवश्यक है, न कि क्लाइंट_आईडी और क्लाइंट_सीक्रेट जोड़ी को अलग से।

डिजिटल विकास मंत्रालय के प्रमाण पत्र

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

self-signed certificate in certificate chain

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

curl -s https://gu-st.ru/content/lending/russian_trusted_root_ca_pem.crt -o russian_trusted_root_ca_pem.crt
curl -s https://gu-st.ru/content/lending/russian_trusted_sub_ca_pem.crt -o russian_trusted_sub_ca_pem.crt
cat russian_trusted_root_ca_pem.crt russian_trusted_sub_ca_pem.crt > russian_trusted_ca_bundle.pem

फ़ाइल को सुविधाजनक स्थान पर रखा जा सकता है और एजेंट शुरू करते समय इसका पूरा पथ निर्दिष्ट किया जा सकता है।

यहाँ एक पकड़ है. डाउनलोड की गई फ़ाइलें सीआरएलएफ लाइन ब्रेक का उपयोग करती हैं, और रूट प्रमाणपत्र में पिछली लाइन फ़ीड नहीं होती है। इसलिए, एक नियमित बिल्ली पहले प्रमाणपत्र के अंत और दूसरे की शुरुआत को एक पंक्ति में जोड़ती है:

-----END CERTIFICATE----------BEGIN CERTIFICATE-----

लिब्रेएसएसएल – और सिस्टम मैकओएस पर ओपनएसएल, मैं आपको याद दिला दूं, बिल्कुल लिब्रेएसएसएल है – ऐसी फ़ाइल को स्वीकार नहीं करता है और एक त्रुटि के साथ प्रतिक्रिया करता है:

PEM routines:CRYPTO_internal:bad end line

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

openssl x509 -in russian_trusted_root_ca_pem.crt -out russian_trusted_root_ca.pem
openssl x509 -in russian_trusted_sub_ca_pem.crt -out russian_trusted_sub_ca.pem
cat russian_trusted_root_ca.pem russian_trusted_sub_ca.pem > russian_trusted_ca_bundle.pem

आप जाँच सकते हैं कि फ़ाइल इस प्रकार पढ़ी जा रही है:

openssl x509 -in russian_trusted_ca_bundle.pem -noout -subject

यदि प्रमाणपत्र किसी अन्य स्रोत से लिए गए हैं और डीईआर या पीकेसीएस#7 प्रारूप में आते हैं, तो उन्हें पीईएम में भी रिकोड किया जा सकता है:

openssl x509 -in cert.crt -inform DER -outform PEM -out cert.pem
openssl pkcs7 -print_certs -in bundle.p7b -out cert.pem

OpenCode से कनेक्ट करें

प्रदाता का वर्णन opencode.jsonc कॉन्फ़िगरेशन फ़ाइल में किया गया है। ओपनकोड स्वयं npm फ़ील्ड में निर्दिष्ट npm पैकेज को डाउनलोड और कनेक्ट करेगा, इसमें createGigaChat फ़ैक्टरी ढूंढेगा और उसमें विकल्प पास करेगा। एपीआई से मॉडलों को उनके पहचानकर्ताओं द्वारा सूचीबद्ध करना पर्याप्त है।

फ़ाइल को दो स्थानों पर रखा जा सकता है:

• वैश्विक – ~/.config/opencode/opencode.jsonc. सेटिंग सभी उपयोगकर्ता प्रोजेक्ट पर लागू होती हैं।
• प्रोजेक्ट में – प्रोजेक्ट रूट में opencode.jsonc। इस कॉन्फिगरेशन की प्राथमिकता अधिक है और गिट के लिए प्रतिबद्ध होना सुरक्षित है।

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

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gigachat": {
      "npm": "gigachat-ai-sdk-provider",
      "name": "GigaChat",
      "models": {
        "GigaChat-2-Max": { "name": "GigaChat 2 Max" },
        "GigaChat-2-Pro": { "name": "GigaChat 2 Pro" },
        "GigaChat-2": { "name": "GigaChat 2 Lite" },
        "GigaChat": { "name": "GigaChat" }
      }
    }
  }
}

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

यह अधिक सुविधाजनक है कि कुंजी को फ़ाइल में ही संग्रहीत न किया जाए, बल्कि इसे एक पर्यावरण चर में पास किया जाए: गीगाचैट-जेएस पैकेज इसे स्वचालित रूप से पढ़ता है। स्कोप मान को एक वेरिएबल पर भी सेट किया जा सकता है। जो कुछ बचा है वह प्रमाणपत्रों के लिए पथ निर्धारित करना और एजेंट को लॉन्च करना है:

export GIGACHAT_CREDENTIALS=ваш_ключ_авторизации
export GIGACHAT_SCOPE=GIGACHAT_API_PERS
export NODE_EXTRA_CA_CERTS=/путь/к/russian_trusted_ca_bundle.pem
opencode

यह विकल्प इसलिए भी अच्छा है क्योंकि रहस्य स्थानीय auth.json संग्रहण में समाप्त नहीं होता है: यह केवल प्रक्रिया के वातावरण में रहता है। यह सीआई और एक बार लॉन्च के लिए अधिक सुविधाजनक है।

मॉडल

उपलब्ध मॉडलों का सेट स्कोप कुंजी पर निर्भर करता है। व्यक्तिगत कुंजी (GIGACHAT_API_PERS) GigaChat और GigaChat 2 परिवार के लिए उपलब्ध है:

• गीगाचैट – मूल मॉडल।
• GigaChat-2 – रोजमर्रा के कार्यों के लिए एक तेज़ और हल्का मॉडल, इंटरफ़ेस में लाइट के रूप में प्रदर्शित होता है।
• GigaChat-2-Pro – संसाधन-गहन कार्यों के लिए एक बेहतर मॉडल।
• GigaChat-2-Max व्यक्तिगत कुंजी का उपयोग करके उपलब्ध सबसे शक्तिशाली है।

GigaChat 3 परिवार (GigaChat-3-Ultra, GigaChat-3-Pro, GigaChat3.5-432B-A28B-रीज़निंग जैसे खुले मॉडल) कंसोल कैटलॉग में दिखाई देता है, लेकिन यह व्यक्तिगत कुंजी के लिए उपलब्ध नहीं है: इसके लिए एक व्यक्तिगत उद्यमी परियोजना या GIGACHAT_API_B2B या GIGACHAT_API_CORP और एक उपयुक्त टैरिफ के साथ एक कानूनी इकाई की आवश्यकता होती है। व्यक्तिगत कुंजी पर, ऐसा मॉडल एक त्रुटि के साथ प्रतिक्रिया करता है:

{"status":404,"message":"No such model"}

आप मॉडलों की सूची पूछकर जांच सकते हैं कि आपकी कुंजी वास्तव में क्या आउटपुट देती है:

curl -H "Authorization: Bearer <токен_доступа>" https://gigachat.devices.sberbank.ru/api/v1/models

दो और अंक. एपीआई में मॉडल आईडी प्रदर्शित नामों से मेल नहीं खाते – लाइट मॉडल को GigaChat-2 कहा जाता है, GigaChat-2-Lite नहीं। और कंसोल में कैटलॉग वही चीज़ नहीं दिखाता है जो आपकी कुंजी के लिए उपलब्ध है, इसलिए आपको मॉडल विधि की प्रतिक्रिया पर ध्यान केंद्रित करना चाहिए, न कि कीमतों वाली सूची पर।

इंटरफ़ेस में, मॉडलों की सूची कमांड के साथ खोली जाती है:

/models

रिपॉजिटरी में नियमित काम के लिए – फ़ाइलों के माध्यम से नेविगेट करना, छोटे संपादन, परीक्षण चलाना – GigaChat-2 काफी है। जटिल कार्यों और डिज़ाइन के लिए, प्रो या मैक्स पर स्विच करना समझ में आता है।

प्रोजेक्ट में पहला लॉन्च

प्रोजेक्ट निर्देशिका पर जाएँ और एजेंट लॉन्च करें:

cd ваш_проект
opencode

पहला कदम एजेंट को आरंभ करना है:

/init

ओपनकोड परियोजना संरचना का विश्लेषण करेगा और एक फ़ाइल AGENTS.md बनाएगा – एजेंट के लिए निर्देश। यह फ़ाइल गिट के लिए प्रतिबद्ध है: यह एजेंट को प्रोजेक्ट में अपनाई गई परंपराओं और पैटर्न को समझने में मदद करती है।

वैकल्पिक: स्थानीय प्रॉक्सी

यदि किसी कारण से आप एनपीएम प्रदाता का उपयोग नहीं करना चाहते हैं, तो स्थानीय प्रॉक्सी वही परिणाम देता है। गीगाचैट टीम के पास एक आधिकारिक gpt2giga – फास्टएपीआई सेवा है जो ओपनएआई, एंथ्रोपिक और जेमिनी प्रारूप में अनुरोधों को गीगाचैट एपीआई में अनुवादित करती है और एक्सेस टोकन को स्वयं अपडेट करती है। इसे स्थानीय रूप से पोर्ट 8090 पर उठाया जाता है, जिसके बाद एक नियमित ओपनएआई-संगत प्रदाता को आधार पते http://localhost:8090/v1 के साथ @ai-sdk/openai-compatible पैकेज के माध्यम से ओपनकोड में कॉन्फ़िगर किया जाता है। इस पथ का नकारात्मक पक्ष यह है कि आपको ओपनकोड के बगल में एक चालू पायथन सेवा भी रखनी होगी।

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gigachat": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "GigaChat (proxy)",
      "options": {
        "baseURL": "http://localhost:8090/v1"
      },
      "models": {
        "GigaChat-2-Max": { "name": "GigaChat 2 Max" }
      }
    }
  }
}

DeepSeek और Cloud.ru के माध्यम से अन्य मॉडल

गीगाचैट एपीआई में स्वयं डीपसीक मॉडल नहीं हैं: एम्बेडिंग के लिए केवल गीगाचैट परिवार और मॉडल हैं। यदि आपको ओपनकोड में डीपसीक की आवश्यकता है, लेकिन रूसी क्लाउड गेटवे के माध्यम से, Cloud.ru की फाउंडेशन मॉडल सेवा उपयुक्त है। यह OpenAI-संगत प्रोटोकॉल का उपयोग करके मॉडल वितरित करता है, इसलिए यह मानक @ai-sdk/openai-compatible पैकेज का उपयोग करके जुड़ा हुआ है।

उदाहरण के लिए, Cloud.ru फाउंडेशन मॉडल कैटलॉग में निम्नलिखित मॉडल हैं:

deepseek-ai/DeepSeek-V4.1-Flash
deepseek-ai/DeepSeek-V4-Flash
deepseek-ai/DeepSeek-V4-Pro

कुंजी Cloud.ru कंसोल में जारी की गई है: अनुभाग उपयोगकर्ता, टैब सेवा खाते। हम एक प्रोजेक्ट-स्तरीय सेवा खाता बनाते हैं, फिर उसके क्रेडेंशियल्स में हम फाउंडेशन मॉडल सेवा के साथ एक एपीआई कुंजी बनाते हैं। मुख्य रहस्य एक बार दिखाया जाता है और हम उसे सहेज लेते हैं।

opencode.json में प्रदाता कॉन्फ़िगरेशन इस तरह दिखता है:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cloudru": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Cloud.ru Foundation Models",
      "options": {
        "baseURL": "https://foundation-models.api.cloud.ru/v1",
        "apiKey": "{env:CLOUDRU_API_KEY}"
      },
      "models": {
        "deepseek-ai/DeepSeek-V4.1-Flash": { "name": "DeepSeek V4.1 Flash", "limit": { "context": 1048576, "output": 1048576 } },
        "deepseek-ai/DeepSeek-V4-Flash": { "name": "DeepSeek V4 Flash", "limit": { "context": 1048576, "output": 1048576 } },
        "deepseek-ai/DeepSeek-V4-Pro": { "name": "DeepSeek V4 Pro", "limit": { "context": 1048576, "output": 1048576 } }
      }
    }
  }
}

हम पर्यावरण चर की कुंजी पास करते हैं:

export CLOUDRU_API_KEY=ваш_ключ_cloudru
opencode

यहां डिजिटल विकास मंत्रालय के प्रमाणपत्रों की आवश्यकता नहीं है: GigaChat के विपरीत, api.cloud.ru डोमेन में नियमित TLS है। लेकिन यह परियोजना के संतुलन की निगरानी के लायक है। यदि खाता शून्य है, तो प्राधिकरण पास हो जाता है, और बिलिंग प्रतिक्रिया के साथ अनुरोध हटा दिए जाते हैं:

{"message":"Not enough money"}

यह कोई कॉन्फ़िगरेशन त्रुटि नहीं है, बल्कि एक संकेत है कि आपको Cloud.ru कंसोल में प्रोजेक्ट को अपडेट करने की आवश्यकता है।

किस बात पर ध्यान दें

कुछ व्यावहारिक बिंदु जो पहली बार सेटअप करते समय अक्सर आड़े आते हैं:

• प्रमाणपत्र सत्यापन त्रुटि। श्रृंखला में स्व-हस्ताक्षरित प्रमाणपत्र के बारे में संदेश का अर्थ है कि NODE_EXTRA_CA_CERTS वैरिएबल नहीं उठाया गया था। फ़ाइल के पथ की जाँच करें, कि एजेंट एक ही वातावरण में चल रहा है, और फ़ाइल स्वयं: यदि, बिल्ली का उपयोग करके दो प्रमाणपत्रों को विलय करते समय, उनके सिरे एक ही पंक्ति पर समाप्त होते हैं, तो लिब्रेएसएसएल एक खराब अंत रेखा लौटाएगा, और बंडल को ओपनएसएल के माध्यम से फिर से बनाने की आवश्यकता है, जैसा कि प्रमाणपत्रों के बारे में अनुभाग में है।
• त्रुटि 401। एक नियम के रूप में, यह एक गलत प्राधिकरण कुंजी या एक बेमेल दायरा है – एक व्यक्ति के लिए आपको GIGACHAT_API_PERS की आवश्यकता है।
• ऐसा कोई मॉडल नहीं पाठ के साथ त्रुटि 404। यह कनेक्शन विफलता नहीं है, बल्कि एक विशिष्ट मॉडल तक पहुंच की कमी है। इसे कॉन्फिग से हटा दें या किसी उपलब्ध कॉन्फिगरेशन से बदल दें। GigaChat 404: अज्ञात त्रुटि जैसे संदेश में, उसी GigaChat प्रतिक्रिया को दोष दिया जाता है – प्रदाता केवल त्रुटि निकाय को पार्स नहीं कर सका।
• लागत। ओपनकोड को सदस्यता की आवश्यकता नहीं है: जब आप टोकन खर्च करते हैं तो आप सीधे गीगाचैट का भुगतान करते हैं, इसलिए लंबे सत्र की कीमत का अनुमान लगाया जा सकता है।
• मॉडल गुणवत्ता। जटिल वास्तुशिल्प कार्यों के लिए, विभिन्न वर्गों के मॉडल अलग-अलग होते हैं, इसलिए डिज़ाइन के लिए एक मजबूत मॉडल लेना और दिनचर्या को तेज़ बनाना समझ में आता है।

लिंक

https://opencode.ai/
https://opencode.ai/docs/providers/
https://developers.sber.ru/studio/
https://developers.sber.ru/docs/ru/gigachat/guides/main
https://github.com/nyddle/gigachat-ai-sdk-provider
https://github.com/ai-forever/gpt2giga
https://cloud.ru/docs/foundation-models/ug/topics/quickstart

स्रोत

https://opencode.ai/docs/providers/#custom-provider
https://developers.sber.ru/docs/ru/gigachat/certificates
https://developers.sber.ru/docs/ru/gigachat/models/main
https://developers.sber.ru/docs/ru/gigachat/guides/selecting-a-model
https://github.com/nyddle/gigachat-ai-sdk-provider
https://github.com/ai-forever/gpt2giga
https://cloud.ru/docs/foundation-models/ug/topics/quickstart
https://cloud.ru/docs/foundation-models/ug/topics/overview__available__models

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

एयरएलएलएम क्या है

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

इससे यह पता चलता है कि आवश्यक वीडियो मेमोरी की मात्रा मॉडल के समग्र आकार पर निर्भर नहीं करती है, बल्कि इसकी परतों में से एक के आकार पर निर्भर करती है। इसीलिए 70बी मॉडल 4 जीबी में फिट बैठता है, 671बी पर डीपसीक-वी3 लगभग 12 जीबी में फिट बैठता है, और क्यूवेन3-235बी लगभग 3 जीबी में फिट बैठता है। लेकिन मॉडल का आकार मुख्य रूप से डिस्क स्थान द्वारा सीमित है, न कि वीडियो कार्ड की क्षमताओं द्वारा।

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

स्थापना

लाइब्रेरी को सामान्य कमांड का उपयोग करके PyPI से स्थापित किया गया है:

pip install airllm

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

मूल उदाहरण

आप एयरएलएलएम के साथ लगभग उसी तरह काम कर सकते हैं जैसे ट्रांसफार्मर के एक नियमित मॉडल के साथ। हगिंग फेस पर एक बार मॉडल आईडी दर्ज करना पर्याप्त है, और फिर सब कुछ परिचित हो जाएगा:

from airllm import AutoModel

MAX_LENGTH = 128
model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

input_text = ['What is the capital of United States?']

input_tokens = model.tokenizer(
    input_text,
    return_tensors="pt",
    return_attention_mask=False,
    truncation=True,
    max_length=MAX_LENGTH,
    padding=False)

generation_output = model.generate(
    input_tokens['input_ids'].cuda(),
    max_new_tokens=20,
    use_cache=True,
    return_dict_in_generate=True)

print(model.tokenizer.decode(generation_output.sequences[0]))

ऑटोमॉडल वर्ग स्वयं मॉडल प्रकार निर्धारित करता है, इसलिए उसी लाइन का उपयोग लामा, क्वेन और डीपसीक के लिए किया जा सकता है। और यदि आप 671बी मापदंडों के साथ डीपसीक-वी3 जैसा मॉडल लेते हैं, तो यह लगभग 12 जीबी वीडियो मेमोरी में भी फिट होगा – यही काफी हद तक परियोजना को आकर्षक बनाता है।

macOS पर लॉन्च करें

AirLLM न केवल CUDA पर, बल्कि Apple सिलिकॉन पर भी चलता है। MacOS पर यह MLX बैकएंड का उपयोग करता है, इसलिए mlx और टॉर्च स्थापित करने की आवश्यकता होगी, और केवल Apple चिप्स का समर्थन करता है। एक छोटी सी सीमा भी है: एमएलएक्स कार्यान्वयन केवल लामा-जैसे आर्किटेक्चर का समर्थन करता है, इसलिए क्वेन और इसी तरह के मॉडल को मैकबुक पर इस तरह से लॉन्च नहीं किया जा सकता है।

उदाहरण का प्रयोग करें

AirLLM-प्रयोग स्थानीय स्तर पर बड़े भाषा मॉडल चलाने के लिए दो छोटी इंटरैक्टिव कंसोल उपयोगिताएँ हैं। वे मॉडल को लोड करने और चैट को व्यवस्थित करने के लिए हर बार एक ही कोड लिखने की आवश्यकता को समाप्त कर देते हैं।

पहला टूल, Airllm-lib-usage.py, AirLLM लाइब्रेरी को सीधे वर्तमान पायथन प्रक्रिया में चलाता है। यह सामान्य कैटलॉग से मॉडलों की एक क्रमांकित सूची दिखाता है, यदि आवश्यक हो, तो यह लापता निर्भरताएँ स्थापित करता है और एक चैट सत्र खोलता है। MLX रनटाइम का उपयोग macOS पर किया जाता है, टॉर्च का उपयोग अन्य प्लेटफ़ॉर्म पर किया जाता है।

दूसरा टूल, Airllm-openai-server-client.py, आपको Airllm-openai-server सर्वर के साथ काम करने में मदद करता है, जो डॉकर में चलता है और एक OpenAI-संगत एपीआई प्रदान करता है। जब आप इसे पहली बार लॉन्च करते हैं, तो उपयोगिता सेटिंग्स मांगती है, छवि एकत्र करती है, कंटेनर उठाती है और चल रहे सर्वर पर एक स्ट्रीमिंग चैट खोलती है। जब बार-बार लॉन्च किया जाता है, तो यह एक मौजूदा कंटेनर ढूंढता है और बस इसका पुन: उपयोग करता है, और मॉडल कैश को एक अलग डॉकर वॉल्यूम में संग्रहीत करता है ताकि मॉडल को दोबारा डाउनलोड न करना पड़े।

उपलब्ध मॉडलों की सूची सामान्य मॉड्यूल model_catalog.py में शामिल है, इसलिए दोनों उपकरण एक ही सेट के साथ काम करते हैं। चैट कमांड भी आम हैं: /help, /clear, /exit। स्रोत कोड और निर्देश भंडार में हैं:

https://github.com/zefir1990/AirLLM-experiments

किस बात पर ध्यान दें

पहली प्रतिक्रिया को तैयार होने में कई मिनट लग सकते हैं: सबसे पहले, AirLLM मॉडल को डाउनलोड करता है और उसे परतों में काटता है, और उसके बाद ही उत्पादन शुरू करता है। इसके अलावा, गति भी कम रहती है – यह स्मृति को बचाने के लिए एक जानबूझकर किया गया समझौता है। मेटा-लामा जैसे गेटेड मॉडल के लिए, आपको हगिंग फेस पर शर्तों को स्वीकार करना होगा और एक एक्सेस टोकन पास करना होगा। डाउनलोड किए गए मॉडलों और शार्डों के कैश को न हटाना सबसे अच्छा है, अन्यथा सब कुछ फिर से डाउनलोड करना होगा।

लिंक

https://github.com/lyogavin/airllm
https://github.com/mkamranr/airllm-openai-server
https://github.com/zefir1990/AirLLM-experiments
https://pypi.org/project/airllm/
https://huggingface.co/

स्रोत

https://github.com/lyogavin/airllm
https://github.com/zefir1990/AirLLM-experiments

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

आपको क्या चाहिए

काम करने के लिए आपको केवल दो चीजों की आवश्यकता है:

• आधुनिक टर्मिनल। वेज़टर्म, अलाक्रिट्टी, घोस्टी, किट्टी या कोई अन्य करेगा।
• प्रदाता की एपीआई कुंजी। हमारे मामले में, डीपसीक।

यदि आप एजेंट को मानक इंस्टॉलेशन स्क्रिप्ट के साथ इंस्टॉल करते हैं तो Node.js की आवश्यकता नहीं है – बाइनरी तैयार हो जाती है।

स्थापना

सबसे आसान तरीका आधिकारिक इंस्टॉलेशन स्क्रिप्ट है:

curl -fsSL https://opencode.ai/install | bash

यह स्वयं प्लेटफ़ॉर्म का पता लगाएगा और निष्पादन योग्य फ़ाइल को PATH में डाल देगा। इंस्टालेशन के बाद, आपको जांचना चाहिए कि सब कुछ ठीक जगह पर है:

opencode --version

यदि आदेश संस्करण प्रदर्शित करता है, तो इंस्टॉलेशन सफल रहा।

अन्य तरीकों का उपयोग करके स्थापना

यदि आप पैकेज प्रबंधकों को प्राथमिकता देते हैं, तो कई विकल्प हैं। Node.js के माध्यम से:

npm install -g opencode-ai

बन, पीएनपीएम और यार्न भी यही कर सकते हैं:

bun install -g opencode-ai
pnpm install -g opencode-ai
yarn global add opencode-ai

macOS और Linux में Homebrew है। कृपया ध्यान दें: यह डेवलपर्स की ओर से अनुशंसित है, न कि आधिकारिक फॉर्मूला – इसे कम बार अपडेट किया जाता है:

brew install anomalyco/tap/opencode

आर्क लिनक्स पर:

sudo pacman -S opencode
paru -S opencode-bin

पहला कमांड रिपॉजिटरी से स्थिर संस्करण स्थापित करता है, दूसरा – AUR से नवीनतम संस्करण स्थापित करता है।

विंडोज़ पर इंस्टालेशन

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

choco install opencode
scoop install opencode
npm install -g opencode-ai

Mise के साथ-साथ डॉकर कंटेनर के माध्यम से भी एक विकल्प है:

mise use -g github:anomalyco/opencode
docker run -it --rm ghcr.io/anomalyco/opencode

अंत में, तैयार बाइनरी को हमेशा GitHub पर रिलीज़ पेज से लिया जा सकता है।

डीपसीक कुंजी

कुंजी आपके डीपसीक व्यक्तिगत खाते में बनाई गई है। प्लेटफ़ॉर्म.डीपसीक.कॉम पर जाएं, एपीआई कुंजियों वाला अनुभाग खोलें और एक नई कुंजी बनाएं पर क्लिक करें। परिणामी स्ट्रिंग को तुरंत सहेजना बेहतर है: यह केवल एक बार दिखाई जाएगी।

डीपसीक कनेक्शन

फिर सब कुछ एजेंट के अंदर ही होता है. टर्मिनल में ओपनकोड लॉन्च करें:

opencode

इंटरफ़ेस में हम कनेक्शन कमांड निष्पादित करते हैं:

/connect

खुलने वाली प्रदाताओं की सूची में, डीपसीक देखें, इसे चुनें और एपीआई कुंजी डालें। इस प्रकार जोड़ी गई कुंजियाँ एक फ़ाइल में सहेजी जाती हैं:

~/.local/share/opencode/auth.json

कनेक्ट करने के बाद, जो कुछ बचा है वह कमांड के साथ मॉडल का चयन करना है:

/models

डीपसीक मॉडल सूची में उपलब्ध होंगे, जिनमें डीपसीक-v4-प्रो, डीपसीक-फ्लैश और डीपसीक-v4-फ्लैश शामिल हैं। रिपॉजिटरी में नियमित कार्य के लिए, फ़्लैश विकल्प पर्याप्त है; जटिल कार्यों के लिए, प्रो पर स्विच करना समझ में आता है।

कॉन्फ़िगरेशन के माध्यम से कॉन्फ़िगरेशन

यदि आप किसी मास्टर के माध्यम से कुंजी संग्रहीत नहीं करना चाहते हैं या अपना स्वयं का एपीआई पता सेट करने की आवश्यकता है, तो प्रदाता को सीधे opencode.json कॉन्फ़िगरेशन फ़ाइल में वर्णित किया गया है:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "deepseek": {
      "options": {
        "baseURL": "https://api.deepseek.com"
      }
    }
  }
}

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

export DEEPSEEK_API_KEY=ваш_ключ_deepseek
opencode

यह विकल्प सीआई और एक बार लॉन्च के लिए अच्छा है: कुंजी भंडारण में समाप्त नहीं होती है, बल्कि प्रक्रिया के वातावरण में ही रहती है।

प्रोजेक्ट में पहला लॉन्च

प्रोजेक्ट निर्देशिका पर जाएँ और एजेंट लॉन्च करें:

cd ваш_проект
opencode

पहला कदम इसे आरंभ करना है:

/init

ओपनकोड परियोजना संरचना का विश्लेषण करेगा और एक फ़ाइल AGENTS.md बनाएगा – जो एजेंट के लिए निर्देशों का एक एनालॉग है। यह फ़ाइल गिट के लिए प्रतिबद्ध होने लायक है: यह एजेंट को प्रोजेक्ट में अपनाई गई परंपराओं और पैटर्न को समझने में मदद करती है।

इसका उपयोग कैसे करें

कार्य को अन्य एजेंटों की तरह ही संरचित किया गया है। कुछ तरकीबें जो आपको तुरंत जाननी चाहिए:

• योजना मोड। टैब कुंजी एजेंट को योजना और असेंबली मोड के बीच स्विच करती है। पहले में, वह केवल सुझाव देता है कि समस्या को कैसे हल किया जाए और कुछ भी नहीं बदलता – परिवर्तन करने से पहले विचार की जांच करना सुविधाजनक है।
• फ़ाइलों से लिंक। @ कुंजी संदर्भ में एजेंट को एक विशिष्ट फ़ाइल स्थानांतरित करने के लिए प्रोजेक्ट फ़ाइलों के माध्यम से एक अस्पष्ट खोज खोलती है।
• परिवर्तनों को वापस लाना। /undo कमांड अंतिम संपादन को पूर्ववत करता है और मूल अनुरोध लौटाता है, /redo उन्हें वापस लौटाता है। आप लगातार कई कदम पीछे जा सकते हैं।
• बातचीत साझा करना। /share कमांड वर्तमान बातचीत के लिए एक लिंक बनाता है और इसे क्लिपबोर्ड पर कॉपी करता है। डिफ़ॉल्ट रूप से, वार्तालाप कहीं भी प्रकाशित नहीं होते हैं।

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

किस बात पर ध्यान दें

कुछ व्यावहारिक बिंदु. ओपनकोड को सदस्यता की आवश्यकता नहीं है: जब आप टोकन खर्च करते हैं तो आप प्रदाता को सीधे भुगतान करते हैं, इसलिए डीपसीक के साथ लंबे सत्र शीर्ष मॉडल की तुलना में अनुमानित रूप से सस्ते होते हैं। कुंजी को स्थानीय रूप से auth.json में संग्रहीत किया जाता है – यह एक साझा मशीन पर विचार करने योग्य है, लेकिन अन्य लोगों के वातावरण के लिए एक पर्यावरण चर अधिक विश्वसनीय है।

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

लिंक

https://opencode.ai/
https://opencode.ai/docs/
https://opencode.ai/docs/providers/
https://github.com/anomalyco/opencode
https://platform.deepseek.com/api_keys
https://api-docs.deepseek.com

स्रोत

https://opencode.ai/docs/
https://opencode.ai/docs/providers/#deepseek
https://github.com/anomalyco/opencode/releases
https://models.dev/

Apple सिलिकॉन प्रोसेसर वाले Mac पर, आप सामान्य तरीके से Linux इंस्टॉल नहीं कर सकते: यहां फ्लैश ड्राइव से बूट करना असंभव है, और बूटलोडर पर Apple द्वारा हस्ताक्षरित है। असाही लिनक्स प्रोजेक्ट ने इससे निजात पाने का बीड़ा उठाया – इसके प्रतिभागियों ने एम1 और एम2 हार्डवेयर को नियमित लिनक्स के तहत काम करने के लिए रिवर्स इंजीनियरिंग का उपयोग किया। अब परियोजना का प्रमुख वितरण फेडोरा असाही रीमिक्स है, और यह एम2 पर काफी विश्वसनीय रूप से काम करता है। इस पोस्ट में मैं चरण दर चरण इंस्टॉलेशन का वर्णन करूंगा।

असाही लिनक्स क्या है

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

व्यवहार में, यह इस तरह दिखता है: आप इंस्टॉलर को macOS से चलाते हैं, यह डिस्क को विभाजित करता है, बूट श्रृंखला और सिस्टम को स्थापित करता है। macOS यथावत रहता है, आपको डुअल बूट मिलता है और जब आप इसे चालू करते हैं तो अपना सिस्टम चुनें।

आवश्यकताएँ

• M2 चिप पर मैक – मैकबुक एयर, मैकबुक प्रो 13″, साथ ही एम2 प्रो और एम2 मैक्स के साथ 14″ और 16″। M1 कारें भी समर्थित हैं।
• वर्तमान macOS। इंस्टॉलर को सिस्टम के नवीनतम संस्करण की आवश्यकता है, इसलिए शुरू करने से पहले अपडेट करें।
• खाली जगह। न्यूनतम लगभग 30 जीबी, आरामदायक – 100 जीबी या अधिक। जगह APFS कंटेनर से कट गई है और अपने आप वापस नहीं आएगी।
• macOS व्यवस्थापक पासवर्ड। विभाजन के दौरान और पहली बार पुनर्प्राप्ति मोड में बूट करते समय आपको इसकी आवश्यकता होगी।
• बैकअप। डिस्क विभाजन एक ऐसा ऑपरेशन है जिसे नए बैकअप के साथ शुरू करना सबसे अच्छा है।

चरण 1. बैकअप और अद्यतन

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

चरण 2. इंस्टॉलर लॉन्च करें

MacOS पर टर्मिनल खोलें और एक कमांड चलाएँ:

curl https://alx.sh | sh

यह प्रोजेक्ट का आधिकारिक इंस्टॉलर है. यह स्वयं डाउनलोड हो जाएगा, आपके मैक मॉडल की जांच करेगा और वितरण चुनने की पेशकश करेगा। फेडोरा के लिए सीधे एक विकल्प भी है:

curl https://fedora-asahi-remix.org/install | sh

पहला विकल्प बेहतर है: यह दिखाता है कि वर्तमान में कौन से सिस्टम उपलब्ध हैं, और यह डेस्कटॉप का विकल्प भी प्रदान करता है।

चरण 3. डिस्क विभाजन

इंस्टॉलर व्यवस्थापक पासवर्ड मांगेगा और वर्तमान लेआउट दिखाएगा। तब संवाद इस प्रकार दिखता है:

• MacOS विभाजन का आकार बदलने के लिए r दबाएँ।
• नए लिनक्स विभाजन का आकार दर्ज करें। यह गीगाबाइट में हो सकता है, यह डिस्क के प्रतिशत के रूप में हो सकता है, या आप मिनट लिख सकते हैं – फिर सबसे छोटा संभव टुकड़ा काट दिया जाएगा।
• अक्षर y से अंकन की पुष्टि करें। यह चरण सबसे लंबा है: सिस्टम भौतिक रूप से डेटा को APFS कंटेनर में ले जाता है; बड़ी डिस्क पर इसमें कई मिनट लगते हैं।
• इंस्टॉलर को नव निर्मित मुक्त विभाजन की ओर इंगित करने के लिए f दबाएं।

यह समझना महत्वपूर्ण है कि क्या हो रहा है: लिनक्स एपीएफएस के अंदर स्थापित नहीं है, बल्कि इसके बगल में एक अलग विभाजन पर स्थापित है। यही कारण है कि macOS अछूता रहता है, और इस अनुभाग को हटाने के लिए रोलबैक कम हो जाता है।

चरण 4. वितरण और डेस्कटॉप का चयन

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

चरण 5. सबसे पहले पुनर्प्राप्ति मोड में बूट करें

विभाजन के बाद, इंस्टॉलर आपको जारी रखने के लिए संकेत देगा, और मैक बंद हो जाएगा। यहाँ सबसे असामान्य भाग आता है:

• कम से कम 25 सेकंड प्रतीक्षा करें – पुनर्प्राप्ति मोड में प्रवेश करने के लिए यह Apple की आवश्यकता है।
• बूट विकल्प दिखाई देने तक पावर बटन को दबाकर रखें।
• इंस्टॉलेशन वॉल्यूम चुनें और अपना macOS पासवर्ड दर्ज करें।

इस चरण में, बूट श्रृंखला सेवा विभाजन में स्थापित होती है: m1n1, U-बूट और UEFI वातावरण। फिर मशीन फिर से रीबूट होगी – पावर बटन को फिर से दबाए रखें और सिस्टम में आने के लिए इस बार एक नया वॉल्यूम चुनें। ऐसे कई रीबूट होंगे, जिनमें से प्रत्येक को मैन्युअल चयन की आवश्यकता होगी: डिफ़ॉल्ट रूप से, मैक macOS को लोड करना जारी रखता है।

चरण 6. सिस्टम स्थापित करना

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

जब इंस्टॉलेशन पूरा हो जाए, तो रीबूट करें और बूट मेनू से लिनक्स चुनें। जब आप पहली बार लॉग इन करते हैं, तो सिस्टम आपको सेटअप पूरा करने और अपडेट करने के लिए संकेत देगा।

क्या काम करता है और क्या नहीं

स्थापना से पहले, आपको गंभीरता से आकलन करना चाहिए कि आप क्या खो देंगे। M2 लैपटॉप पर स्थिति इस प्रकार है:

कार्य:

• वाई-फाई और ब्लूटूथ – बिना किसी प्रतिबंध के।
• एकीकृत स्क्रीन और ग्राफिक्स – ओपनजीएल और वल्कन सहित हार्डवेयर त्वरित।
• मैकबुक एयर और मैकबुक प्रो पर वेबकैम, माइक्रोफोन और स्पीकर।
• स्लीप मोड – सामान्य रूप से काम करता है।
• हार्डवेयर वीडियो डिकोडिंग – प्लेयर्स प्रोसेसर लोड नहीं करते हैं।
• यूएसबी पोर्ट, जिसमें थंडरबोल्ट कनेक्टर के माध्यम से यूएसबी 2 और यूएसबी 3 शामिल हैं।

काम नहीं करता या आंशिक रूप से काम करता है:

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

सीधे शब्दों में कहें तो, यह कोड, टर्मिनल, ब्राउज़र और स्थानीय मॉडल के साथ काम करने के लिए एक बेहतरीन प्रणाली है, लेकिन बाहरी मॉनिटर डॉक के लिए नहीं।

फेयरीडस्ट कोर के माध्यम से बाहरी मॉनिटर

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

git clone https://github.com/bharambetejas/asahi-fairydust-display
cd asahi-fairydust-display
chmod +x asahi-fairydust-build.sh
./asahi-fairydust-build.sh

स्क्रिप्ट फेयरीडस्ट शाखा को क्लोन करती है, कर्नेल को कॉन्फ़िगर और असेंबल करती है, इसे मानक के बगल में रखती है और GRUB को संपादित करती है। आपको असेंबल करने के लिए 15 जीबी खाली जगह, एक यूएसबी-सी → एचडीएमआई या डिस्प्लेपोर्ट एडाप्टर और 60-90 मिनट की आवश्यकता है। रीबूट के बाद, GRUB में -fairydust लेबल वाले कर्नेल का चयन करें और एडॉप्टर को सबसे सामने वाले USB-C पोर्ट में डालें।

डाउनलोड करने के बाद जांचें:

uname -r
glxinfo | grep "OpenGL renderer"
xrandr

पहले कमांड को प्रत्यय -फेयरीडस्ट के साथ संस्करण दिखाना चाहिए, दूसरे को Apple M2 दिखाना चाहिए, llvmpipe नहीं, तीसरे को कनेक्टेड DP-1 आउटपुट दिखाना चाहिए।

आरक्षण. शाखा प्रायोगिक है और आधिकारिक तौर पर समर्थित नहीं है। आउटपुट केवल एक यूएसबी-सी पोर्ट के माध्यम से काम करता है और हमेशा हॉट प्लगिंग से नहीं बचता है – पहले से डाले गए एडॉप्टर के साथ रीबूट करना अधिक सुरक्षित है। स्क्रिप्ट स्वचालित रूप से डिस्प्ले को कॉन्फ़िगर नहीं करती है: इसमें संबंधित चरण अक्षम है क्योंकि इससे वेलैंड पर लॉगिन लूप उत्पन्न हुआ है। डीएनएफ के माध्यम से स्टॉक कर्नेल को अपडेट करने से /boot/dtb सिम्लिंक को पुनर्व्यवस्थित किया जाता है, जिसके कारण आउटपुट चुपचाप काम करना बंद कर सकता है – फिर बिल्ड को दोहराया जाना चाहिए।

मानक कर्नेल को छुआ नहीं गया है: वापस लौटने के लिए, बस इसे GRUB मेनू में चुनें।

अपग्रेड के बजाय बाहरी ड्राइव

यहाँ अच्छा पक्ष है. मैकबुक को अपग्रेड नहीं किया जा सकता है: मेमोरी और स्टोरेज को बोर्ड पर टांका लगाया जाता है, और उनकी क्षमता खरीद पर एक बार चुनी जाती है। MacOS में, बाहरी ड्राइव बाहरी ही रहती है – सिस्टम और एप्लिकेशन को वास्तव में इसमें स्थानांतरित नहीं किया जा सकता है।

लिनक्स में, यह सीमा हटा दी गई है: USB के माध्यम से एक बाहरी SSD एक नियमित ब्लॉक डिवाइस है, और किसी भी माउंट पॉइंट को /etc/fstab के माध्यम से इसमें स्थानांतरित किया जा सकता है। यदि आप अपनी होम डायरेक्टरी, स्टीम लाइब्रेरी, वर्चुअल मशीन इमेज या स्थानीय मॉडल स्थानांतरित करना चाहते हैं, तो कृपया ऐसा करें। यह बिल्कुल वही अपग्रेड है जो इस कार में नहीं है।

यह इस तरह दिख रहा है। सबसे पहले, वांछित विभाजन के यूयूआईडी को देखें:

lsblk -f
sudo blkid

फिर /etc/fstab में लाइन जोड़ें:

UUID=ваш-uuid  /home  ext4  defaults,nofail  0  2

स्थानांतरण स्वयं कॉपी करके किया जाता है: डेटा को बाहरी ड्राइव पर ले जाया जाता है, जिसके बाद इसे वांछित बिंदु पर माउंट किया जाता है। अक्सर, पूरे /घर को इस तरह से नहीं, बल्कि अलग-अलग भारी निर्देशिकाओं को ले जाया जाता है – इस तरह से जोखिम कम होता है।

कुछ चेतावनियाँ। nofail पैरामीटर विकल्पों में सेट करने लायक है: इसके बिना, यदि डिस्क कनेक्ट नहीं है तो सिस्टम बूट नहीं होगा। USB ड्राइव की गति अभी भी अंतर्निहित NVMe से कम है, इसलिए बार-बार I/O संचालन के लिए आंतरिक डिस्क पर जगह छोड़ना बेहतर है। और वहां स्थापित निर्देशिकाओं के साथ चलते समय डिस्क को बाहर निकालने की कोई आवश्यकता नहीं है – पहले इसे अनमाउंट करें।

सिस्टम के बीच कैसे स्विच करें

जब आप इसे चालू करते हैं, तो पावर बटन दबाए रखें – बूट मेनू दिखाई देगा, इसमें macOS और Linux होंगे। आप macOS में डिफ़ॉल्ट सिस्टम का चयन कर सकते हैं: “सिस्टम प्राथमिकताएँ” → “सामान्य” → “सिस्टम डिस्क”। लिनक्स में भी संबंधित सेटिंग्स हैं, जिससे आप टर्मिनल के बिना दोनों दिशाओं में स्विच कर सकते हैं।

लिंक

https://asahilinux.org/fedora/
https://asahilinux.org/docs/
https://asahilinux.org/docs/platform/feature-support/m2/
https://fedoraproject.org/asahi-remix
https://github.com/bharambetejas/asahi-fairydust-display
https://github.com/AsahiLinux/linux/tree/fairydust

स्रोत

https://asahilinux.org/docs/platform/feature-support/m2/
https://discussion.fedoraproject.org/t/fedora-asahi-remix-installation-guide/
https://github.com/AsahiLinux/docs
https://github.com/bharambetejas/asahi-fairydust-display/blob/main/README.md
https://github.com/bharambetejas/asahi-fairydust-display/blob/main/asahi-fairydust-build.sh

ARM64 प्रोसेसर वाले मैक पर वर्चुअलबॉक्स में उबंटू सर्वर स्थापित करने और गेस्ट एडिशन कनेक्ट करने के निर्देश।

वर्चुअलबॉक्स इंस्टॉल करना

वर्चुअलबॉक्स का ARM64 बिल्ड डाउनलोड करें, छवि को माउंट करें और वर्चुअलबॉक्स.एप को एप्लिकेशन में स्थानांतरित करें।

वर्चुअल मशीन को कॉन्फ़िगर करना

हम एक नई मशीन बनाते हैं, लिनक्स प्रकार और उबंटू संस्करण (64-बिट एआरएम) निर्दिष्ट करते हैं। सेटिंग्स में हम सेट करते हैं:

• टीपीएम – अक्षम करें
• UEFI – अक्षम करें
• रैम – 4096 एमबी।
• ग्राफिक्स नियंत्रक – VMSVGA (VBoxLinuxAdditions के लिए)।
• प्रोसेसर – 4 कोर.

उबंटू सर्वर स्थापित करना

ARM64 के लिए Ubuntu सर्वर ISO छवि को CD-ROM ड्राइव में माउंट करें। डाउनलोड अनुभाग में, ऑप्टिकल ड्राइव को सूची में पहले रखें। हम मशीन शुरू करते हैं और उबंटू सर्वर की स्थापना से गुजरते हैं।

जुबंटू-डेस्कटॉप इंस्टॉल कर रहा है

XFCE ग्राफिकल वातावरण स्थापित करें:

sudo apt update
sudo apt install -y xubuntu-desktop

लॉगिन प्रबंधक चयन संवाद में, लाइटडीएम चुनें।

अतिथि प्रणाली को रिबूट करें:

sudo reboot

अतिथि परिवर्धन

पहले बूट के बाद, कर्नेल मॉड्यूल के निर्माण के लिए पैकेज स्थापित करें:

sudo apt update
sudo apt install -y build-essential linux-headers-$(uname -r)

हम वर्चुअलबॉक्स मेनू के माध्यम से अतिथि परिवर्धन के साथ डिस्क को माउंट करते हैं: डिवाइस → माउंट अतिथि परिवर्धन डिस्क छवि। डिस्क अतिथि के अंदर /media/$USER निर्देशिका में दिखाई देगी।

Xubuntu में एक टर्मिनल खोलें, माउंटेड डिस्क की निर्देशिका पर जाएं और इंस्टॉलर चलाएं:

cd /media/$USER/*
sudo ./VBoxLinuxAdditions-arm64.run

अतिथि प्रणाली को रिबूट करें:

sudo reboot

इंस्टॉलेशन के बाद क्या काम करना चाहिए

हम जाँचते हैं कि कर्नेल मॉड्यूल लोड हैं:

lsmod | grep vbox

आउटपुट में vboxguest और vboxsf शामिल होना चाहिए।

मशीन गुणों में एक साझा फ़ोल्डर जोड़ें और इसे अतिथि के अंदर माउंट करें:

sudo mkdir -p /media/sf_shared
sudo mount -t vboxsf shared /media/sf_shared

कामकाजी विशेषताएं:

• साझा फ़ोल्डर – होस्ट निर्देशिका vboxsf के माध्यम से अतिथि के अंदर दिखाई देती है।
• साझा क्लिपबोर्ड – होस्ट और अतिथि के बीच टेक्स्ट कॉपी करें।
• माउस एकीकरण – कर्सर मशीन विंडो के बाहर स्वतंत्र रूप से फैला हुआ है।
• स्वचालित रिज़ॉल्यूशन परिवर्तन – अतिथि स्क्रीन विंडो आकार के अनुसार समायोजित हो जाती है।
• समय सिंक्रनाइज़ेशन – अतिथि का समय मेज़बान के समय के अनुसार समायोजित किया जाता है।

स्रोत

https://www.virtualbox.org/manual/topics/guestadditions.html
https://forums.virtualbox.org/viewtopic.php?t=112886

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

एक समाधान है. डीपसीक एंथ्रोपिक एपीआई के साथ संगत एक समापन बिंदु प्रदान करता है। यह आधार पते और टोकन को बदलने के लिए पर्याप्त है, और क्लाउड कोड किसी भी पुनर्स्थापना या पैच की आवश्यकता के बिना, डीपसीक मॉडल पर काम करना शुरू कर देगा। इस पोस्ट में मैं बताऊंगा कि इसे macOS, Linux और Windows पर कैसे सेट किया जाए।

इसकी आवश्यकता क्यों है

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

आपको क्या चाहिए

आपको क्लाउड कोड स्थापित और डीपसीक एपीआई कुंजी की आवश्यकता है। यदि क्लाउड कोड पहले से स्थापित नहीं है, तो आदेश इस प्रकार है:
1. Node.js 18 या बाद का संस्करण स्थापित करें। विंडोज़ पर, आपको विंडोज़ के लिए Git की अतिरिक्त आवश्यकता होगी।
2. नीचे दिए गए आदेश का उपयोग करके स्वयं क्लाउड कोड स्थापित करें।
3. स्थापना की जाँच करें.

npm install -g @anthropic-ai/claude-code
claude --version

यदि संस्करण प्रदर्शित होता है, तो इंस्टॉलेशन सफल रहा। एपीआई कुंजी आपके डीपसीक व्यक्तिगत खाते में कुंजी पृष्ठ पर बनाई गई है।

पर्यावरण चर के माध्यम से कॉन्फ़िगरेशन

सारा एकीकरण पर्यावरण चर पर निर्भर करता है। MacOS और Linux के लिए यह इस तरह दिखता है:

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=ваш_ключ_deepseek

export ANTHROPIC_MODEL=deepseek-flash[1m]
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-flash[1m]
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-flash[1m]
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-flash

export CLAUDE_CODE_EFFORT_LEVEL=max
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=786432

PowerShell में विंडोज़ के लिए सिंटैक्स अलग है, लेकिन वेरिएबल नाम समान हैं:

$env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN="ваш_ключ_deepseek"
$env:ANTHROPIC_MODEL="deepseek-flash[1m]"

आइए जानें कि यहां क्या है। `ANTHROPIC_BASE_URL` वैरिएबल अनुरोधों को एंथ्रोपिक सर्वर से डीपसीक पर रीडायरेक्ट करता है। `ANTHROPIC_AUTH_TOKEN` आपकी कुंजी को प्रतिस्थापित करता है। शेष चर यह निर्धारित करते हैं कि कौन सा मॉडल किस भूमिका में उपयोग किया जाता है। `[1m]` प्रत्यय वाले मॉडल हैं – यह लगभग दस लाख टोकन की संदर्भ विंडो वाला एक विकल्प है, जो एजेंट को एक समय में काफी अधिक प्रोजेक्ट फ़ाइलें रखने की अनुमति देता है। तदनुसार, `CLAUDE_CODE_AUTO_COMPACT_WINDOW` को इस विंडो के आकार पर सेट किया गया है ताकि स्वचालित इतिहास संपीड़न बहुत जल्दी काम न करे।

हर बार वेरिएबल को मैन्युअल रूप से निर्यात नहीं करना, बल्कि उन्हें क्लाउड कोड कॉन्फ़िगरेशन में पंजीकृत करना सुविधाजनक है। फिर स्टार्टअप पर सेटिंग्स स्वचालित रूप से उठाई जाएंगी।

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "ваш_ключ_deepseek",
    "ANTHROPIC_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek-flash",
    "CLAUDE_CODE_SUBAGENT_MODEL": "deepseek-flash"
  }
}

उसके बाद, प्रोजेक्ट निर्देशिका पर जाएँ और एजेंट चलाएँ:

cd ваш_проект
claude

वीएस कोड में क्लाउड कोड

क्लाउड कोड न केवल टर्मिनल में उपलब्ध है, बल्कि वीएस कोड के एक्सटेंशन के रूप में भी उपलब्ध है। इसे सामान्य तरीके से इंस्टॉल किया जाता है: Cmd+Shift+X का उपयोग करके एक्सटेंशन पैनल खोलें, “क्लाउड कोड” ढूंढें और इंस्टॉल पर क्लिक करें। विस्तार एन्थ्रोपिक द्वारा ही निर्मित होता है।

एक्सटेंशन में सीएलआई की अपनी प्रति होती है, और यह टर्मिनल संस्करण के समान ~/.claude/settings.json फ़ाइल को पढ़ता है। पिछले अनुभाग की सेटिंग्स यहां भी लागू होती हैं – लेकिन एक चेतावनी के साथ, जो अक्सर भ्रम का कारण बनती है।

इनपुट सत्यापन लॉन्च से पहले होता है

शुरू करने से पहले, एक्सटेंशन अपने स्वयं के `claudeCode.environmentVariables` सेटिंग से क्रेडेंशियल्स की जांच करता है, न कि सेटिंग्स.जेसन से। सेटिंग्स.जेसन से मान चल रही प्रक्रिया तक पहुंचते हैं – यानी, एपीआई पता और चयनित मॉडल सही ढंग से उठाए जाते हैं – लेकिन वे एक्सटेंशन की स्वयं की लॉगिन जांच पास नहीं करते हैं। यदि आपको लॉगिन स्क्रीन दिखाई देती है, भले ही टर्मिनल में सब कुछ पहले से ही काम कर रहा हो, तो यही कारण है।

इसे वीएस कोड सेटिंग्स में कुछ पंक्तियों के साथ ठीक किया जा सकता है: `claudeCode.environmentVariables` में वेरिएबल्स को डुप्लिकेट करें और लॉगिन अनुरोध को अक्षम करें।

{
  "claudeCode.environmentVariables": [
    { "name": "ANTHROPIC_BASE_URL", "value": "https://api.deepseek.com/anthropic" },
    { "name": "ANTHROPIC_AUTH_TOKEN", "value": "ваш_ключ_deepseek" },
    { "name": "ANTHROPIC_MODEL", "value": "deepseek-flash[1m]" }
  ],
  "claudeCode.disableLoginPrompt": true
}

macOS बारीकियां

यदि आप डॉक या फाइंडर से वीएस कोड लॉन्च करते हैं, तो यह ~/.zshrc से पर्यावरण चर प्राप्त नहीं करता है। यह मानक macOS व्यवहार है और क्लाउड कोड दस्तावेज़ में विशेष रूप से चर्चा की गई है। यानी, एक्सटेंशन के लिए आपके शेल में `export ANTHROPIC_BASE_URL=…` बस काम नहीं करेगा – यह वेरिएबल इसके वातावरण में नहीं होगा।

इससे दो निष्कर्ष निकलते हैं. सबसे पहले, `claudeCode.environmentVariables` में सेटिंग्स शेल वेरिएबल्स की तुलना में अधिक विश्वसनीय हैं। दूसरे, यदि आप अभी भी एक शेल पसंद करते हैं, तो संपादक को टर्मिनल से लॉन्च करें, जहां चर पहले से ही निर्यात किए गए हैं:

code .

क्या काम नहीं करेगा

तृतीय-पक्ष प्रदाता पर, कुछ एक्सटेंशन सुविधाएँ उपलब्ध नहीं हैं क्योंकि उन्हें claude.ai खाते की आवश्यकता होती है:
– क्लाउड सत्रों के लिए कोई योजना उपयोग बार, वॉयस इनपुट और वेब टैब नहीं होगा;
– लॉगआउट आदेश मेनू में नहीं दिखाए जाते हैं;
– `/उपयोग` योजना सीमा के बजाय वर्तमान सत्र की खपत और टोकन की संख्या दिखाएगा;
– यदि आधार पता एंथ्रोपिक नहीं है तो रिमोट कंट्रोल काम नहीं करता है।

यह अपेक्षित व्यवहार है और यह संकेत नहीं है कि सेटअप विफल हो गया है।

अलग से, मैं यह जोड़ना चाहूंगा कि JetBrains का अपना प्लगइन है, लेकिन इसे अलग तरह से डिज़ाइन किया गया है: इसमें अंतर्निहित CLI नहीं है, लेकिन एकीकृत टर्मिनल में पहले से स्थापित एक को लॉन्च करता है। पर्यावरण चर के लिए कोई सेटिंग नहीं है, इसलिए आपको पहले से निर्यात किए गए चर के साथ टर्मिनल से आईडीई लॉन्च करना चाहिए।

डीपसीक क्लाउड मॉडल नामों को कैसे समझता है

क्लाउड कोड आंतरिक रूप से मॉडलों को क्लाउड-ओपस, क्लाउड-सॉनेट और क्लाउड-हाइकू जैसे नामों से संदर्भित करता है। डीपसीक इन नामों को पकड़ता है और उन्हें अपने नाम से बदल देता है:
– जो कुछ भी क्लाउड-ओपस से शुरू होता है वह depseek-v4-pro पर जाता है;
– जो कुछ भी क्लाउड-सॉनेट या क्लाउड-हाइकू से शुरू होता है वह डीपसीक-फ्लैश पर जाता है;
– अज्ञात मॉडल का नाम भी घटाकर डीपसीक-फ़्लैश कर दिया गया है।

इसका मतलब यह है कि मॉडलों को स्पष्ट रूप से निर्दिष्ट किए बिना भी, एकीकरण काम करेगा – लेकिन यह स्पष्ट रूप से नियंत्रित करना बेहतर है कि कौन से मॉडल और किस टैरिफ पर अनुरोध पूरा होगा। इसीलिए उपरोक्त सेटिंग्स में सभी भूमिकाएँ मैन्युअल रूप से लिखी जाती हैं।

किस बात पर ध्यान दें

अनुकूलता अधूरी है, और आपको यह पहले से पता होना चाहिए। डीपसीक केवल एंथ्रोपिक एपीआई की कुछ क्षमताओं को नजरअंदाज करता है:

– कैशिंग संकेत। `cache_control` फ़ील्ड समर्थित नहीं है। क्लाउड कोड सक्रिय रूप से कैश का उपयोग करता है ताकि एक ही संदर्भ को बार-बार भेजने के लिए अधिक भुगतान न करना पड़े। यहां ऐसा नहीं होगा, इसलिए लंबे सत्र आपकी प्रति टोकन कीमत की अपेक्षा से अधिक महंगे हैं। पुराने संवाद को लगातार जारी रखने के बजाय समय-समय पर एक नया संवाद शुरू करें।
– सोच बजट। `सोच` पैरामीटर समर्थित है, लेकिन इसके अंदर `बजट_टोकन` को नजरअंदाज कर दिया गया है।
– विविध। `top_k`, `service_tier`, `container` फ़ील्ड और API से MCP सर्वर के कनेक्शन को भी अनदेखा किया जाता है।
– एमसीपी। डीपसीक पक्ष पर अंतर्निहित एमसीपी सर्वर तंत्र काम नहीं करता है, हालांकि एजेंट के सामान्य उपकरण – फाइलें पढ़ना, संपादन, कमांड चलाना, खोज करना – सामान्य रूप से कार्य करते हैं।

अलग से, यह प्रॉक्सी का उल्लेख करने योग्य है। समुदाय में `डीएस-सीसी-प्रॉक्सी` जैसी परियोजनाएं हैं, जो क्लाउड कोड और डीपसीक के बीच रखी गई हैं और छोटी असंगतताओं को दूर करने के साथ-साथ मुख्य सत्र और उप-एजेंटों को अलग-अलग मॉडलों में अलग करने का काम करती हैं। यदि मानक सेटअप अस्थिर व्यवहार करता है, तो ऐसी मध्यवर्ती परत मदद कर सकती है।

क्लाउड कोड राउटर

ऊपर वर्णित विधि सभी कार्यों पर एक मॉडल रखती है। लेकिन एजेंट बहुत अलग चीजें करता है: वह परियोजना की संरचना को समझता है, छोटी-छोटी चीजों को ठीक करता है, और कभी-कभी वास्तव में जटिल समस्या को हल करता है। यह तर्कसंगत है कि विभिन्न प्रकार के कार्यों के लिए विभिन्न मॉडलों का उपयोग किया जाना चाहिए। यह बिल्कुल वही है जो क्लाउड-कोड-राउटर (सीसीआर) कर सकता है – एक स्थानीय गेटवे जो क्लाउड कोड और मॉडल प्रदाताओं के बीच खड़ा होता है।

यह क्या देता है

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

सबसे पहले संस्करणों के बारे में – यह महत्वपूर्ण है

यहां यह चेतावनी देने लायक है क्योंकि इससे आपका समय बचेगा। सीसीआर को इसके इतिहास में बड़े पैमाने पर नया रूप दिया गया है, और खोज में आपको मिलने वाले लगभग सभी लेख पुराने संस्करण का वर्णन करते हैं।

पुराने संस्करणों में, कॉन्फ़िगरेशन प्रदाता और राउटर ब्लॉक के साथ फ़ाइल ~/.claude-code-router/config.json में था, और सब कुछ `ccr कोड` कमांड के साथ लॉन्च किया गया था। अब यह उस तरह से काम नहीं करता. वर्तमान संस्करण (3.x) SQLite डेटाबेस में सेटिंग्स संग्रहीत करता है और एक वेब इंटरफ़ेस के माध्यम से प्रबंधित किया जाता है। यदि अभी तक कोई डेटाबेस नहीं है तो पुराने config.json को माइग्रेशन के स्रोत के रूप में बिल्कुल एक बार पढ़ा जाता है – उसके बाद, इसमें किए गए संपादन कुछ भी प्रभावित नहीं करते हैं।

यानी, अगर आपको इंटरनेट पर config.json और `ccr कोड` कमांड को संपादित करने के निर्देश मिले और आपके लिए कुछ भी काम नहीं आया, तो आप एक ऐसी फ़ाइल को संपादित कर रहे हैं जिसे अब कोई नहीं पढ़ता है। ये तुम्हारी भूल नही है।

स्थापना

आपको Node.js 22 या बाद के संस्करण की आवश्यकता होगी।

npm install -g @musistudio/claude-code-router
ccr ui

`ccr ui` कमांड पृष्ठभूमि में सेवा लाता है और ब्राउज़र में प्रबंधन इंटरफ़ेस खोलता है। अन्य आदेशों को जानना उपयोगी है: `ccr प्रारंभ` एक सेवा शुरू करता है, `ccr stop` इसे रोकता है, `ccrserv` अग्रभूमि में काम करता है और जब आपको लॉग देखने की आवश्यकता होती है तो यह सुविधाजनक होता है।

डिफ़ॉल्ट रूप से, प्रबंधन इंटरफ़ेस पोर्ट 3458 पर रहता है, और मॉडलों के लिए गेटवे स्वयं पोर्ट 3456 पर रहता है।

सेटिंग्स

फ़ाइलों को मैन्युअल रूप से संपादित किए बिना, सब कुछ वेब इंटरफ़ेस में किया जाता है:
1. प्रदाता अनुभाग में, डीपसीक प्रदाता जोड़ें और इसकी कुंजी निर्दिष्ट करें। कृपया ध्यान दें: यहां केवल डोमेन ही नहीं बल्कि चैट/पूर्णता बिंदु तक का पूरा पता आवश्यक है।
2. मॉडल अनुभाग में, वर्णन करें कि यह मॉडल क्या है – विवरण रूटिंग में मदद करता है।
3. एजेंट कॉन्फ़िगरेशन अनुभाग में, डिफ़ॉल्ट मॉडल सेट करें।
4. रूटिंग अनुभाग में, नियमों को कॉन्फ़िगर करें: कौन सा मॉडल किस अनुरोध का जवाब देता है।
5. एपीआई कुंजी पृष्ठ पर, एक सीसीआर क्लाइंट कुंजी बनाएं – क्लाउड कोड इसका उपयोग करेगा, डीपसीक कुंजी का नहीं।

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

एक अच्छी बात: रूटिंग नियम न केवल फ़ील्ड के साथ, बल्कि जावास्क्रिप्ट स्क्रिप्ट के साथ भी लिखे जा सकते हैं, यदि तर्क एक फ़ील्ड की तुलना करने से अधिक जटिल है।

क्या इसका उपयोग करना उचित है

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

सीमाएँ भी स्पष्ट हैं: कोई त्वरित कैश नहीं है, एपीआई फ़ील्ड के संबंध में अपूर्ण संगतता, और जटिल वास्तुशिल्प कार्यों के लिए मॉडल की गुणवत्ता भिन्न हो सकती है। रिपॉजिटरी में नियमित काम के लिए – नेविगेशन, रिफैक्टरिंग, रनिंग टेस्ट – यह पर्याप्त से अधिक है।

उदाहरण: ओनी-एक्सटेंडेड

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

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

लिंक

https://platform.deepseek.com/api_keys
https://api-docs.deepseek.com
https://docs.anthropic.com/en/docs/claude-code
https://github.com/anthropics/claude-code
https://github.com/musistudio/claude-code-router
https://ccrdesk.top/en/guides/cli/
https://github.com/zefir1990/Oni-Extended

स्रोत

https://api-docs.deepseek.com/guides/anthropic_api
https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code
https://ccrdesk.top/en/routing/
https://code.claude.com/docs/en/vs-code

डोंकी हिल्स पिछले एक साल से अधिक समय से स्टीम पर है!

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

गेमप्ले पर काम जारी है, और अब प्रोजेक्ट धीरे-धीरे अपना असली चेहरा हासिल कर रहा है। डोंकी हिल्स वही बनना शुरू हो गया है जो इसका इरादा था – कॉमेडी फर्स्ट पर्सन रॉगुलाइक पैरोडी सर्वाइवल हॉरर।

एक अजीब साहसिक कार्य जहां डरावनी हास्य, अन्वेषण और अप्रत्याशित स्थितियों से मिलती है। आपको शहर जाना होगा, वस्तुओं की तलाश करनी होगी, पहेलियों को सुलझाना होगा और धीरे-धीरे उस रहस्य को उजागर करना होगा जो आपको मारिया तक ले जाएगा।

प्रोटोटाइप के अगले प्लेटेस्ट के ताज़ा स्क्रीनशॉट नीचे दिए गए हैं। यह अभी खेल का अंतिम रूप नहीं है, लेकिन आप पहले से ही शहर के माहौल और परियोजना किस दिशा में आगे बढ़ रही है, महसूस कर सकते हैं।

आपकी प्रतिक्रिया सुनने में बहुत दिलचस्पी है! 👀
आपको नई दिशा कैसी लगी? खेल के माहौल और विचारों के बारे में आपकी क्या राय है?

उन सभी को धन्यवाद जिन्होंने डोंकी हिल्स को अपनी इच्छा सूची में जोड़ा, विकास का अनुसरण किया और परियोजना का समर्थन किया ❤️

आगे अभी भी कई प्रयोग, नई यांत्रिकी और अजीब रोमांच बाकी हैं।

https://store.steampowered.com/app/3476390/Donki_Hills/

आधुनिक गेमिंग लैपटॉप के निर्माता अक्सर सिस्टम को कॉन्फ़िगर करते हैं ताकि प्रोसेसर 90 डिग्री तक गर्म हो और यहां तक ​​कि लोड के तहत 100 डिग्री सेल्सियस तक पहुंच जाए। यह समस्या विशेष रूप से गर्मियों में तीव्र होती है जब कठिन खेल या भारी काम वाले कार्य चल रहे होते हैं।

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

विधि बिजली आपूर्ति सेटिंग्स के माध्यम से अधिकतम प्रोसेसर स्थिति को सीमित करने के लिए है:

1. विंडोज़ सर्च या कंट्रोल पैनल के माध्यम से पावर विकल्प खोलें।
2. सक्रिय विद्युत योजना में, अतिरिक्त पैरामीटर बदलने के लिए अनुभाग पर जाएँ।
3. प्रोसेसर पावर प्रबंधन शाखा ढूंढें।
4. अधिकतम प्रोसेसर स्थिति विकल्प का विस्तार करें।
5. प्लग इन के लिए, मान को 100% से 80% या उससे कम में बदलें।

इन सेटिंग्स को लागू करने के बाद, प्रोसेसर स्वचालित रूप से अत्यधिक आवृत्तियों पर ओवरक्लॉक नहीं करेगा जो अतिरिक्त गर्मी उत्पन्न करते हैं। हालाँकि अधिकतम शिखर प्रदर्शन में लगभग 20% की कमी आएगी, प्रोसेसर अब ज़्यादा गरम नहीं होगा। थ्रॉटलिंग के बिना कम आवृत्ति पर स्थिर संचालन 100 डिग्री से कम तापमान पर ओवरहीटिंग के कारण प्रदर्शन में लगातार तेज उछाल की तुलना में सिस्टम के लिए बहुत बेहतर और अधिक आरामदायक है।

प्रत्येक लैपटॉप अद्वितीय है, इसलिए मेरा सुझाव है कि उपयोगकर्ता प्रयोग करें और इष्टतम संतुलन (प्रतिशत) ढूंढें जो ओवरहीटिंग के बिना वांछित प्रदर्शन प्रदान करेगा।

इस पोस्ट में मैं बताऊंगा कि कैसे मैंने Surreal इंजन गेम इंजन को WebAssembly में पोर्ट किया।
https://demensdeum.com/demos/SurrealEngine/”
अवास्तविक इंजन – एक गेम इंजन जो अवास्तविक इंजन 1 की अधिकांश कार्यक्षमता को लागू करता है, इस इंजन पर प्रसिद्ध गेम – अवास्तविक टूर्नामेंट 99, अवास्तविक, ड्यूस एक्स, अनडाइंग। यह क्लासिक इंजनों को संदर्भित करता है जो मुख्य रूप से एकल-थ्रेडेड निष्पादन वातावरण में काम करते हैं।
मूल रूप से मेरे मन में एक ऐसे प्रोजेक्ट को लेने का विचार था जिसे मैं किसी भी उचित समय सीमा में पूरा नहीं कर सका, इस प्रकार मैंने अपने ट्विच अनुयायियों को दिखाया कि ऐसे प्रोजेक्ट भी हैं जिन्हें मैं भी नहीं कर सकता। अपनी पहली स्ट्रीम के दौरान, मुझे अचानक एहसास हुआ कि Emscripten का उपयोग करके Surreal इंजन C++ को WebAssembly में पोर्ट करने का कार्य संभव था।

एक महीने बाद, मैं WebAssembly पर अपना फ़ोर्क और इंजन असेंबली प्रदर्शित कर सकता हूँ:
https://demensdeum.com/demos/SurrealEngine/
नियंत्रण, मूल की तरह, कीबोर्ड तीरों का उपयोग करके किया जाता है। इसके बाद, मैं इसे मोबाइल नियंत्रण (टैची) के लिए अनुकूलित करने की योजना बना रहा हूं, जिसमें सही प्रकाश व्यवस्था और अवास्तविक टूर्नामेंट 99 रेंडर की अन्य ग्राफिक विशेषताएं शामिल हैं।

कहां से शुरू करें?

पहली बात जो मैं कहना चाहता हूं वह यह है कि किसी भी प्रोजेक्ट को Emscripten का उपयोग करके C++ से WebAssembly में पोर्ट किया जा सकता है, एकमात्र सवाल यह है कि कार्यक्षमता कितनी पूर्ण होगी। ऐसा प्रोजेक्ट चुनें जिसके लाइब्रेरी पोर्ट एम्सस्क्रिप्टेन के लिए पहले से ही उपलब्ध हों; Surreal इंजन के मामले में, आप बहुत भाग्यशाली हैं, क्योंकि इंजन SDL 2, OpenAL – का उपयोग करता है। पुस्तकालय. वे दोनों एम्सस्क्रिप्टेन में पोर्ट किए गए हैं। हालाँकि, वल्कन का उपयोग ग्राफिक्स एपीआई के रूप में किया जाता है, जो वर्तमान में HTML5 के लिए उपलब्ध नहीं है, WebGPU को लागू करने के लिए काम चल रहा है, लेकिन यह ड्राफ्ट चरण में भी है, और यह भी अज्ञात है कि पूरी तरह से मानकीकृत होने के बाद Vulkan से WebGPU तक का पोर्ट कितना सरल होगा। इसलिए, मुझे Surreal इंजन के लिए अपना स्वयं का मूल OpenGL-ES/WebGL रेंडरर लिखना पड़ा।

परियोजना का निर्माण

Surreal इंजन में सिस्टम बनाएँ – सीएमके, जो पोर्टिंग को भी सरल बनाता है, क्योंकि एम्सस्क्रिप्टन अपने मूल बिल्डरों को प्रदान करता है – एममेक, एममेक।
Surreal इंजन पोर्ट WebGL/OpenGL ES और C++ में डेथ-मास्क नामक मेरे नवीनतम गेम के कोड पर आधारित था, इस वजह से विकास बहुत सरल था, मेरे पास सभी आवश्यक बिल्ड फ़्लैग और कोड उदाहरण थे।
CMakeLists.txt में सबसे महत्वपूर्ण बिंदुओं में से एक Emscripten के लिए बिल्ड फ़्लैग है, नीचे प्रोजेक्ट फ़ाइल से एक उदाहरण दिया गया है:

set(CMAKE_CXX_FLAGS "-s MIN_WEBGL_VERSION=2 
-s MAX_WEBGL_VERSION=2 
-s EXCEPTION_DEBUG 
-fexceptions 
--preload-file UnrealTournament/ 
--preload-file SurrealEngine.pk3 
--bind 
--use-preload-plugins 
-Wall 
-Wextra 
-Werror=return-type 
-s USE_SDL=2 
-s ASSERTIONS=1 
-w 
-g4 
-s DISABLE_EXCEPTION_CATCHING=0 
-O3 
--no-heap-copy 
-s ALLOW_MEMORY_GROWTH=1 
-s EXIT_RUNTIME=1")

बिल्ड स्क्रिप्ट स्वयं:

clear
emmake make -j 16
cp SurrealEngine.data /srv/http/SurrealEngine/SurrealEngine.data
cp SurrealEngine.js /srv/http/SurrealEngine/SurrealEngine.js
cp SurrealEngine.wasm /srv/http/SurrealEngine/SurrealEngine.wasm
cp ../buildScripts/Emscripten/index.html /srv/http/SurrealEngine/index.html

इसके बाद, आइए index.html तैयार करें, जिसमें प्रोजेक्ट फ़ाइल सिस्टम प्रीलोडर शामिल है। वेब पर अपलोड करने के लिए, मैंने अवास्तविक टूर्नामेंट डेमो संस्करण 338 का उपयोग किया। जैसा कि आप सीएमके फ़ाइल से देख सकते हैं, अनपैक्ड गेम फ़ोल्डर को बिल्ड निर्देशिका में जोड़ा गया था और एम्सस्क्रिप्टेन के लिए प्रीलोड-फ़ाइल के रूप में लिंक किया गया था।

मुख्य कोड परिवर्तन

फिर हमें गेम के गेम लूप को बदलना पड़ा, आप एक अंतहीन लूप नहीं चला सकते, इससे ब्राउज़र फ़्रीज़ हो जाता है, इसके बजाय आपको emscripten_set_main_loop का उपयोग करने की आवश्यकता है, मैंने इस सुविधा के बारे में अपने 2017 नोट में लिखा था ” target=’_blank’>SDL C++ गेम्स को HTML5 (Emscripten) में पोर्ट करना”
हम while लूप से बाहर निकलने के लिए कोड को if में बदलते हैं, फिर हम गेम इंजन के मुख्य वर्ग को प्रदर्शित करते हैं, जिसमें गेम लूप होता है, वैश्विक दायरे में, और एक वैश्विक फ़ंक्शन लिखते हैं जो वैश्विक ऑब्जेक्ट से गेम लूप चरण को कॉल करेगा:

#if __EMSCRIPTEN__
#include <emscripten.h>
Engine *EMSCRIPTEN_GLOBAL_GAME_ENGINE = nullptr;
void emscripten_game_loop_step() {
	EMSCRIPTEN_GLOBAL_GAME_ENGINE->Run();
}
#endif

इसके बाद, आपको यह सुनिश्चित करना होगा कि एप्लिकेशन में कोई पृष्ठभूमि थ्रेड नहीं हैं; यदि हैं, तो एकल-थ्रेडेड निष्पादन के लिए उन्हें फिर से लिखने के लिए तैयार हो जाएं, या एम्सस्क्रिप्टन में phtread लाइब्रेरी का उपयोग करें।
Surreal इंजन में बैकग्राउंड थ्रेड का उपयोग संगीत चलाने के लिए किया जाता है, मुख्य इंजन थ्रेड से वर्तमान ट्रैक, संगीत चलाने की आवश्यकता या उसकी अनुपस्थिति के बारे में डेटा आता है, फिर बैकग्राउंड थ्रेड म्यूटेक्स के माध्यम से एक नई स्थिति प्राप्त करता है और नया संगीत बजाना शुरू कर देता है, या रुक जाता है। प्लेबैक के दौरान संगीत को बफ़र करने के लिए बैकग्राउंड थ्रेड का भी उपयोग किया जाता है।
पाथ्रेड के साथ एम्सस्क्रिप्टेन के लिए सररियल इंजन बनाने के मेरे प्रयास असफल रहे, क्योंकि एसडीएल2 और ओपनएएल पोर्ट बिना पाथ्रेड समर्थन के बनाए गए थे, और मैं संगीत के लिए उनका पुनर्निर्माण नहीं करना चाहता था। इसलिए, मैंने लूप का उपयोग करके पृष्ठभूमि संगीत स्ट्रीम की कार्यक्षमता को एकल-थ्रेडेड निष्पादन में स्थानांतरित कर दिया। C++ कोड से pthread कॉल्स को हटाकर, मैंने बफ़रिंग और संगीत प्लेबैक को मुख्य थ्रेड में स्थानांतरित कर दिया, ताकि कोई देरी न हो, मैंने बफ़र को कुछ सेकंड तक बढ़ा दिया।
आगे, मैं ग्राफिक्स और ध्वनि के विशिष्ट कार्यान्वयन का वर्णन करूंगा।

वल्कन समर्थित नहीं है!

हाँ, Vulkan HTML5 में समर्थित नहीं है, हालाँकि सभी मार्केटिंग ब्रोशर Vulkan के मुख्य लाभ के रूप में क्रॉस-प्लेटफ़ॉर्म और व्यापक प्लेटफ़ॉर्म समर्थन प्रस्तुत करते हैं। इस कारण से, मुझे सरलीकृत OpenGL प्रकार – के लिए अपना स्वयं का मूल ग्राफ़िक्स रेंडरर लिखना पड़ा। ईएस, इसका उपयोग मोबाइल उपकरणों पर किया जाता है, कभी-कभी इसमें आधुनिक ओपनजीएल की फैशनेबल विशेषताएं शामिल नहीं होती हैं, लेकिन यह वेबजीएल को बहुत अच्छी तरह से पोर्ट करता है, जो कि एम्सस्क्रिप्टेन लागू करता है। सबसे सरल जीयूआई डिस्प्ले के लिए बुनियादी टाइल रेंडरिंग, बीएसपी रेंडरिंग लिखना और मॉडल + मैप रेंडर करना दो सप्ताह में पूरा हो गया। यह शायद परियोजना का सबसे कठिन हिस्सा था। Surreal इंजन रेंडरिंग की पूर्ण कार्यक्षमता को लागू करने के लिए अभी भी बहुत काम बाकी है, इसलिए कोड और पुल अनुरोधों के रूप में पाठकों की किसी भी मदद का स्वागत है।

OpenAL समर्थित!

बड़ी किस्मत यह है कि Surreal इंजन ऑडियो आउटपुट के लिए OpenAL का उपयोग करता है। OpenAL में एक सरल हैलो वर्ल्ड लिखने और इसे Emscripten का उपयोग करके WebAssembly में इकट्ठा करने के बाद, मुझे यह स्पष्ट हो गया कि सब कुछ कितना सरल था, और मैंने ध्वनि को पोर्ट करना शुरू कर दिया।
कई घंटों की डिबगिंग के बाद, यह स्पष्ट हो गया कि एम्सस्क्रिप्टेन के ओपनएएल कार्यान्वयन में कई बग हैं, उदाहरण के लिए, जब मोनो चैनलों की संख्या को पढ़ना शुरू किया जाता है, तो विधि एक अनंत संख्या लौटाती है, और अनंत आकार के वेक्टर को प्रारंभ करने का प्रयास करने के बाद, C++ अपवाद वेक्टर::लेंथ_एरर के साथ क्रैश हो जाता है।
हम मोनो चैनलों की संख्या को 2048 तक हार्डकोड करके इससे निजात पाने में कामयाब रहे:

		alcGetIntegerv(alDevice, ALC_MONO_SOURCES, 1, &monoSources);
		alcGetIntegerv(alDevice, ALC_STEREO_SOURCES, 1, &stereoSources);

#if __EMSCRIPTEN__
		monoSources = 2048; // for some reason Emscripten's OpenAL gives infinite monoSources count, bug?
#endif

क्या कोई नेटवर्क है?

Surreal इंजन वर्तमान में ऑनलाइन खेल का समर्थन नहीं करता है, बॉट्स के साथ खेलना समर्थित है, लेकिन हमें इन बॉट्स के लिए AI लिखने के लिए किसी की आवश्यकता है। सैद्धांतिक रूप से, आप Websockets का उपयोग करके WebAssembly/Emscripten पर एक नेटवर्क गेम लागू कर सकते हैं।

निष्कर्ष

अंत में, मैं यह कहना चाहूंगा कि पुस्तकालयों के उपयोग के कारण Surreal इंजन की पोर्टिंग काफी सुचारू हो गई, जिसके लिए Emscripten पोर्ट हैं, साथ ही Emscripten पर WebAssembly के लिए C++ में एक गेम को लागू करने का मेरा पिछला अनुभव भी है। विषय पर ज्ञान के स्रोतों और भंडारों के लिंक नीचे दिए गए हैं।
एम-एम-एम-राक्षस हत्या!
इसके अलावा, यदि आप प्रोजेक्ट में मदद करना चाहते हैं, अधिमानतः वेबजीएल/ओपनजीएल ईएस रेंडरिंग कोड के साथ, तो मुझे टेलीग्राम में लिखें:
https://t.me/demenscave

लिंक

https://demensdeum.com/demos/SurrealEngine/

https://github.com/demensdeum/SurrealEngine-Emscripten

https://github.com/dpjudas/SurrealEngine

जब दो डिवाइस NAT या सख्त फ़ायरवॉल के पीछे होते हैं और एक दूसरे को सीधे “देख” नहीं सकते हैं, तो वीपीएन मानक समाधान प्रतीत होता है। लेकिन एक पूर्ण विकसित L3 सुरंग (जैसे वायरगार्ड या ओपनवीपीएन) अक्सर अनावश्यक होती है: इसके लिए रूट अधिकारों की आवश्यकता होती है, वर्चुअल इंटरफेस स्थापित करना पड़ता है, और मौजूदा मार्गों के साथ टकराव हो सकता है।

ऐसे मामलों में, छेनी का उपयोग करना सुविधाजनक है – एक टीसीपी/यूडीपी सुरंग जो HTTP के शीर्ष पर चलती है और डेटा ट्रांसफर के लिए वेबसॉकेट का उपयोग करती है। इस नोट में मैं दिखाऊंगा कि एक इंटरमीडिएट सर्वर के माध्यम से एक क्लाइंट से दूसरे क्लाइंट तक पोर्ट को “फॉरवर्ड” कैसे किया जाए।

यह कैसे काम करता है?

स्थिति की कल्पना करें: आपके पास क्लाइंट A (उदाहरण के लिए, आपका होम सर्वर), क्लाइंट B (आपका कार्य लैपटॉप) और सार्वजनिक IP पते वाला एक VPS है। ग्राहक ए और बी वीपीएस तक पहुंच सकते हैं, लेकिन एक दूसरे को नहीं।

अग्रेषण योजना इस प्रकार होगी:
1. क्लाइंट ए वीपीएस से जुड़ता है और सर्वर पर एक “रिवर्स” पोर्ट खोलता है। अब सर्वर के पोर्ट X पर आने वाली हर चीज़ क्लाइंट A के पोर्ट Y पर जाती है।
2. क्लाइंट बी वीपीएस से जुड़ता है और पोर्ट Z को अपनी स्थानीय मशीन से सर्वर के पोर्ट X तक अग्रेषित करता है।
3. परिणामस्वरूप, क्लाइंट B localhost:Z तक पहुंचता है और क्लाइंट A:Y पर समाप्त होता है।

यह दृष्टिकोण उन मामलों में समाधानों में से एक है जहां वीपीएस के साथ संचार एल 3 परत को लागू नहीं करता है या ग्राहकों के बीच रूटिंग को कॉन्फ़िगर करने की कोई क्षमता नहीं है। हम विशेष रूप से एप्लिकेशन और पोर्ट स्तर पर काम करते हैं।

चरण 1: सर्वर प्रारंभ करें

अपने VPS पर, बस Chisel को सर्वर मोड में चलाएँ। क्लाइंट को सर्वर साइड पर पोर्ट खोलने की अनुमति देने के लिए <कोड>–रिवर्स ध्वज की आवश्यकता होती है।

chisel server --port 8080 --reverse

चरण 2: क्लाइंट ए (स्रोत) को कनेक्ट करना

मान लीजिए कि क्लाइंट ए पोर्ट 3000 पर अपने स्थानीय वेब सर्वर तक पहुंच खोलना चाहता है। वह वीपीएस से जुड़ता है और कहता है: “सर्वर पर पोर्ट 2000 रिजर्व करें और इसे मुझे 3000 पर अग्रेषित करें।”

chisel client vps-ip:8080 R:2000:127.0.0.1:3000

अब वीपीएस (लूपबैक इंटरफ़ेस पर) पर पोर्ट 2000 क्लाइंट ए की ओर ले जाता है।

चरण 3: क्लाइंट बी (उपभोक्ता) को कनेक्ट करना

अब क्लाइंट बी इस संसाधन तक पहुंचना चाहता है। यह उसी वीपीएस से जुड़ता है और अपने स्थानीय पोर्ट 8080 को सर्वर के पोर्ट 2000 पर भेजता है।

chisel client vps-ip:8080 8080:127.0.0.1:2000

तैयार! अब, जब आप क्लाइंट बी पर http://localhost:8080 खोलेंगे, तो आप क्लाइंट ए पर चल रही सेवा देखेंगे।

सुरक्षा और बारीकियाँ

चिसेल --auth ध्वज के माध्यम से प्रमाणीकरण का समर्थन करता है, जिसे सार्वजनिक सर्वर के माध्यम से काम करते समय अत्यधिक अनुशंसित किया जाता है। आप ट्रैफ़िक को एन्क्रिप्ट करने के लिए टीएलएस प्रमाणपत्र का भी उपयोग कर सकते हैं।

इस दृष्टिकोण का मुख्य लाभ यह है कि TUN/TAP डिवाइस और जटिल रूटिंग टेबल की कोई आवश्यकता नहीं है। यह एक स्ट्रिप-डाउन सुरंग है जो बिल्कुल एक काम करती है: वेबसॉकेट कनेक्शन के माध्यम से बंदरगाहों को बांधती है। यदि आप पोर्ट 443 के माध्यम से काम करने के लिए चिसेल को कॉन्फ़िगर करते हैं तो यह कॉर्पोरेट प्रॉक्सी के माध्यम से भी काम करता है।

आउटपुट

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

लिंक

https://github.com/jpillora/chisel

आप कोड पर काम करने, परिकल्पनाओं को समझने, स्थितियों को समायोजित करने में घंटों बिताते हैं, लेकिन बग अभी भी पुन: उत्पन्न होता है। परिचित लग रहा है? हताशा की इस स्थिति को अक्सर “भूत शिकार” कहा जाता है। ऐसा लगता है कि प्रोग्राम आपके सुधारों को नज़रअंदाज़ करते हुए अपना जीवन जी रहा है।

इस स्थिति के लिए सबसे आम – और सबसे कष्टप्रद – कारणों में से एक है एप्लिकेशन में पूरी तरह से गलत जगह पर त्रुटि की तलाश करना।

“झूठे लक्षणों” का जाल

जब हम कोई त्रुटि देखते हैं, तो हमारा ध्यान उस स्थान पर जाता है जहां उसने “शूट” किया था। लेकिन जटिल प्रणालियों में, जहां बग होता है (क्रैश या गलत मान) घटनाओं की एक लंबी श्रृंखला का अंत मात्र है। जब आप अंत को ठीक करने का प्रयास करते हैं, तो आप लक्षणों से लड़ रहे हैं, बीमारी से नहीं।

यही वह जगह है जहां फ़्लोचार्ट अवधारणा आती है।

यह वास्तविकता में कैसे काम करता है

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

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

<ब्लॉककोट>
परिणाम: आप एल्गोरिथम के एक हिस्से में “परफेक्ट” कोड फिक्स पर घंटों बिताते हैं, जो निस्संदेह, एल्गोरिथम के दूसरे हिस्से में समस्या को ठीक करने के लिए कुछ नहीं करता है जहां यह वास्तव में विफल रहता है।

<घंटा />

बग को हराने के लिए एल्गोरिदम

बंद दरवाजे पर पिटाई रोकने के लिए, आपको निदान के प्रति अपना दृष्टिकोण बदलना होगा:

• परिणाम ट्री में स्थिति ढूंढें:कोड लिखने से पहले, आपको बिल्कुल वही पथ निर्धारित करना होगा जो एप्लिकेशन ने लिया है। किस बिंदु पर तर्क ने गलत मोड़ ले लिया? किस विशिष्ट स्थिति (राज्य) के कारण समस्या उत्पन्न हुई?
• पुनरुत्पादन 80% सफलता है: यह आमतौर पर परीक्षकों और स्वचालित परीक्षणों द्वारा किया जाता है। यदि बग “फ़्लोटिंग” है, तो संयुक्त रूप से स्थितियों की खोज करने की प्रक्रिया में विकास शामिल है।
• जितना संभव हो उतनी जानकारी का उपयोग करें: लॉग, ओएस संस्करण, डिवाइस पैरामीटर, कनेक्शन प्रकार (वाई-फाई/5जी) और यहां तक ​​​​कि एक विशिष्ट दूरसंचार ऑपरेटर स्थानीयकरण के लिए महत्वपूर्ण हैं।

त्रुटि के क्षण का “फ़ोटोग्राफ़”

आदर्श रूप से, इसे ठीक करने के लिए, आपको बग पुन: उत्पन्न होने के समय एप्लिकेशन की पूर्ण स्थिति प्राप्त करने की आवश्यकता है। इंटरेक्शन लॉग भी अत्यंत महत्वपूर्ण हैं: वे न केवल अंतिम बिंदु दिखाते हैं, बल्कि संपूर्ण उपयोगकर्ता पथ भी दिखाते हैं (विफलता से पहले कौन सी कार्रवाइयां हुईं)। इससे यह समझने में मदद मिलती है कि एक समान स्थिति को दोबारा कैसे बनाया जाए।

भविष्य की युक्ति: यदि आप किसी जटिल मामले का सामना करते हैं, तो स्थिति दोबारा होने की स्थिति में कोड के इस अनुभाग में विस्तारित डिबग लॉगिंग जानकारी जोड़ें।

<घंटा />

एआई के युग में “मायावी” स्थिति की समस्या

एलएलएम (बड़े भाषा मॉडल) का उपयोग करने वाली आधुनिक प्रणालियों में, शास्त्रीय नियतिवाद (“एक इनपुट, एक आउटपुट”) का अक्सर उल्लंघन किया जाता है। आप बिल्कुल वही इनपुट डेटा पास कर सकते हैं, लेकिन एक अलग परिणाम प्राप्त कर सकते हैं।

ऐसा आधुनिक उत्पादन प्रणालियों की गैर-नियतिवाद के कारण होता है:

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

ऐसी परिस्थितियों में, “उसी स्थिति” को पुन: उत्पन्न करना लगभग असंभव हो जाता है। परीक्षण के लिए केवल एक सांख्यिकीय दृष्टिकोण ही आपको यहां बचा सकता है।

<घंटा />

जब तर्क विफल हो जाता है: स्मृति समस्याएं

यदि आप “असुरक्षित” भाषाओं (C या C++) के साथ काम कर रहे हैं, तो बग मेमोरी करप्शन के कारण हो सकता है।

ये सबसे गंभीर मामले हैं: एक मॉड्यूल में त्रुटि दूसरे में डेटा को “ओवरराइट” कर सकती है। यह पूरी तरह से अस्पष्ट और पृथक विफलताओं की ओर ले जाता है जिन्हें सामान्य एप्लिकेशन लॉजिक का उपयोग करके पता नहीं लगाया जा सकता है।

वास्तुकला स्तर पर अपनी सुरक्षा कैसे करें?

ऐसे “रहस्यमय” बग से बचने के लिए, आपको आधुनिक तरीकों का उपयोग करना चाहिए:

• मल्टीथ्रेडेड प्रोग्रामिंग पैटर्न:स्पष्ट सिंक्रनाइज़ेशन दौड़ की स्थितियों को समाप्त कर देता है।
• थ्रेड-सुरक्षित भाषाएँ: उपकरण जो संकलन समय पर मेमोरी सुरक्षा की गारंटी देते हैं:
  • जंग: स्वामित्व प्रणाली मेमोरी त्रुटियों को समाप्त करती है।
  • स्विफ्ट 6 कंकरेंसी:मजबूत डेटा अलगाव जांच।
  • एरलांग: अभिनेता मॉडल के माध्यम से पूर्ण प्रक्रिया अलगाव।

सारांश

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

(और ऐसे समाधान कैसे बनाएं जो अपडेट के बाद भी काम करते रहें)

“ऐप्स केवल सार्वजनिक एपीआई का उपयोग कर सकते हैं और उन्हें वर्तमान शिपिंग ओएस पर चलना चाहिए।” ऐप्पल ऐप समीक्षा दिशानिर्देश

यदि आपने कभी किसी नए ढांचे के साथ काम करना शुरू किया है और खुद को यह सोचते हुए पाया है: “अब मैं खुद ही सब कुछ समझ लूंगा, दस्तावेज पढ़ना बहुत लंबा है,” आप निश्चित रूप से अकेले नहीं हैं। हममें से कई लोगों में स्वाभाविक खोजी प्रवृत्ति होती है: पहले प्रयास करें, और उसके बाद ही निर्देशों को देखें। और यह बिल्कुल सामान्य है.

हालाँकि, इस स्तर पर बहक जाना और ऐसी स्थिति में पहुँचना आसान हो सकता है जहाँ कोड बढ़िया काम करता है, लेकिन शायद सिस्टम की गैर-स्पष्ट विशेषताओं पर निर्भर करता है।

कभी-कभी केवल “इसे स्वयं ही समझ लेना” पर्याप्त क्यों नहीं होता?

फ्रेमवर्क, विशेष रूप से बंद फ्रेमवर्क, जटिल और बहुस्तरीय सिस्टम हैं। वे अक्सर आंतरिक तर्क और अनुकूलन छिपाते हैं:

*सार्वजनिक दस्तावेज़ीकरण में वर्णित नहीं हैं;
*इस बात की गारंटी न दें कि व्यवहार भविष्य में भी बना रहेगा;
* नए संस्करण जारी होने के साथ बदल सकता है;
* इसमें डेवलपर्स को ज्ञात विशेषताएं शामिल हो सकती हैं जिन्हें अभी तक ठीक नहीं किया गया है।

जब हम सहज ज्ञान से कार्य करते हैं, तो दस्तावेजी नियमों के बजाय यादृच्छिक अवलोकनों पर वास्तुकला का निर्माण करने का जोखिम होता है। यह कोड को अपडेट के प्रति अधिक संवेदनशील बना सकता है।

दस्तावेज़ीकरण एक सीमा नहीं है, बल्कि एक विश्वसनीय समर्थन है

फ़्रेमवर्क डेवलपर हमारी सहायता के लिए मैनुअल बनाते हैं। दस्तावेज़ीकरण के अंतर्गत कार्य करते हुए, हमें मिलता है:

* स्थिरता;
* सहायता;
* पूर्वानुमेय सिस्टम व्यवहार।

इन सीमाओं से परे जाकर, हम अतिरिक्त जोखिम उठाते हैं, और ऐसे कोड को बनाए रखना अधिक कठिन हो जाता है।

प्रयोग? निश्चित रूप से। लेकिन सीमाओं की समझ के साथ.
किसी डेवलपर में जिज्ञासा होना एक महान गुण है। नई चीज़ों की खोज करना और उन्हें आज़माना नितांत आवश्यक है। लेकिन यहाँ एक छोटी सी इच्छा है:

प्रयोग करने का सबसे आरामदायक तरीका सर्वोत्तम प्रथाओं पर भरोसा करना है।

दस्तावेज़ीकरण एक मानचित्र है जो दिखाता है कि कौन से पथ सबसे सुरक्षित हैं और रचनाकारों द्वारा समर्थित हैं।

एक बाहरी परिप्रेक्ष्य: विशेषज्ञ की सलाह

हम अक्सर अनुभवी सहकर्मियों से सीखते हैं:

*वे उपयोगी पाठ्यक्रम संचालित करते हैं,
*सम्मेलनों में बोलें,
*अद्भुत किताबें और ब्लॉग लिखें,
* उनके अनूठे दृष्टिकोण को साझा करें।

उनमें से कई सचमुच मूल्यवान अनुभव साझा करते हैं। लेकिन यह याद रखने योग्य है: यदि लेखक के दृष्टिकोण आधिकारिक दस्तावेज़ीकरण के विपरीत हैं, तो वे नाजुक हो सकते हैं।

ऐसे “अनुभवजन्य पैटर्न” कभी-कभी:

* केवल ढांचे के एक विशिष्ट संस्करण पर काम करें;
* अद्यतनों के प्रति संवेदनशील;
* असामान्य परिस्थितियों में अप्रत्याशित व्यवहार कर सकता है।

समुदाय से सीखना महान और लाभदायक है। लेकिन किसी भी सलाह, यहां तक ​​कि सबसे आधिकारिक सलाह को भी हमेशा आधिकारिक मैनुअल के साथ सावधानीपूर्वक जांचा जाना चाहिए।

SOLID के बारे में थोड़ा

SOLID सिद्धांतों के तीन विचार इस दृष्टिकोण को पूरी तरह से पूरक करते हैं:

* खुला/बंद सिद्धांत: सार्वजनिक एपीआई के माध्यम से व्यवहार को बढ़ाने का प्रयास करें और, यदि संभव हो तो, छिपे हुए कार्यान्वयन पर निर्भर न रहें।
* लिस्कोव प्रतिस्थापन सिद्धांत: अनुबंध पर भरोसा करें, विशिष्ट कार्यान्वयन पर नहीं। अन्यथा, हुड के नीचे परिवर्तन अप्रत्याशित कठिनाइयों का कारण बन सकता है।
* निर्भरता व्युत्क्रमण: विवरणों पर नहीं, अमूर्तताओं पर निर्भरताएँ बनाएँ।

व्यवहार में, इसका मतलब यह है कि ढांचे के आंतरिक, गैर-दस्तावेज विवरण से बंधा होना सिस्टम को भंगुर बना देता है।
सार्वजनिक इंटरफ़ेस और अनुबंधों के आधार पर, हमें मिलता है:

* फ्रेमवर्क में बदलाव से कोड का बेहतर अलगाव;
* परीक्षण में आसानी;
* वास्तुकला की पूर्वानुमेयता और विश्वसनीयता।

अगर कोई बग है तो क्या होगा?

ऐसा भी होता है कि सब कुछ नियमों के अनुसार किया जाता है, लेकिन परिणाम उम्मीदों के अनुरूप नहीं होता है। ढाँचे विकसित होते रहते हैं और हमेशा सही नहीं होते। इस तरह के मामलों में:

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

यदि उदाहरण वर्कअराउंड पर निर्भर करता है, तो डेवलपर्स के लिए सहायता प्रदान करना अधिक कठिन होगा।

फ़्रेमवर्क से अधिकतम लाभ कैसे प्राप्त करें

*दस्तावेज़ देखें.
* लेखकों के मार्गदर्शकों और अनुशंसाओं का पालन करें।
* वर्णित कार्यक्षमता के भीतर प्रयोग करें।
* आधिकारिक स्रोतों के साथ इंटरनेट से सलाह की जाँच करें।
* फ्रेमवर्क अनुबंधों का सम्मान करते हुए बग्स का स्थानीयकरण करें।

निष्कर्ष

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

मैनुअल और दस्तावेज़ीकरण उत्कृष्ट समर्थन हैं जो वास्तव में विश्वसनीय समाधान बनाने में मदद करते हैं।

स्रोत

https://developer.apple.com/app-store/review/guidelines/
https://en.wikipedia.org/wiki/SOLID
https://en.wikipedia.org/wiki/API
https://en.wikipedia.org/wiki/RTFM

इस नोट में, मैं Linux पर iOS के लिए C++ SDL एप्लिकेशन बनाने, सशुल्क Apple डेवलपर सदस्यता के बिना IPA संग्रह पर हस्ताक्षर करने और जेलब्रेक के बिना macOS का उपयोग करके इसे एक साफ़ डिवाइस (iPad) पर इंस्टॉल करने की प्रक्रिया का वर्णन करूंगा।

सबसे पहले, आइए Linux के लिए बिल्ड टूलचेन इंस्टॉल करें:
https://github.com/tpoechtrager/cctools-port

टूलचेन को रिपॉजिटरी से डाउनलोड करना होगा, फिर इंस्टॉलेशन पूरा करने के लिए गोडोट इंजन वेबसाइट पर दिए गए निर्देशों का पालन करें:
https://docs.godotengine.org/ru/latest/development/compiling/cross-compiling_for_ios_on_linux.html

फिलहाल, आपको cctools-port बनाने के लिए Xcode dmg डाउनलोड करना होगा और वहां से sdk को कॉपी करना होगा। इस चरण को macOS पर पूरा करना आसान है; बस स्थापित Xcode से आवश्यक sdk फ़ाइलों की प्रतिलिपि बनाएँ। सफल असेंबली के बाद, टर्मिनल में क्रॉस-कंपाइलर टूलचेन का पथ शामिल होगा।
इसके बाद, आप iOS के लिए SDL एप्लिकेशन बनाना शुरू कर सकते हैं। चलिए cmake खोलें और C++ कोड बनाने के लिए आवश्यक परिवर्तन जोड़ें:

SET(CMAKE_SYSTEM_NAME Darwin)
SET(CMAKE_C_COMPILER arm-apple-darwin11-clang)
SET(CMAKE_CXX_COMPILER arm-apple-darwin11-clang++)
SET(CMAKE_LINKER arm-apple-darwin11-ld)

अब आप सेमेक का उपयोग करके संकलन कर सकते हैं और बना सकते हैं, लेकिन क्रॉस-कंपाइलर टूलचेन में $PATH जोड़ना न भूलें:

PATH=$PATH:~/Sources/cctools-port/usage_examples/ios_toolchain/target/bin

फ्रेमवर्क और एसडीएल के साथ सही लिंकिंग के लिए, हम उन्हें सीएमके में लिखते हैं, उदाहरण के लिए गेम स्पेस जगुआर की निर्भरताएँ:

target_link_libraries(
${FSEGT_PROJECT_NAME}
${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libclang_rt.ios.a
${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libSDL2.a
${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libSDL2_mixer.a
${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libSDL2_image.a
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreServices.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/ImageIO.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/Metal.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/AVFoundation.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/GameController.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreMotion.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreGraphics.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/AudioToolbox.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreAudio.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/QuartzCore.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/OpenGLES.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/UIKit.framework"
"${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/Foundation.framework"
)

मेरे मामले में, SDL, SDL_Image, SDL_mixer लाइब्रेरीज़ को स्टैटिक लिंकिंग के लिए पहले से ही macOS पर Xcode में संकलित किया गया है; फ्रेमवर्क Xcode से कॉपी किया गया। libclang_rt.ios.a लाइब्रेरी भी जोड़ी गई है, जिसमें iOS-विशिष्ट रनटाइम कॉल शामिल हैं, उदाहरण के लिए isOSVersionAtLeast। ओपनजीएल ईएस के साथ काम करने के लिए एक मैक्रो शामिल है, जो एंड्रॉइड के समान मोबाइल संस्करण में असमर्थित कार्यों को अक्षम करता है।
सभी निर्माण समस्याओं को हल करने के बाद, आपको हाथ के लिए असेंबल की गई बाइनरी मिलनी चाहिए। इसके बाद, आइए जेलब्रेक के बिना डिवाइस पर असेंबल बाइनरी चलाने पर विचार करें।
MacOS पर, डेवलपर प्रोग्राम के लिए भुगतान किए बिना, Xcode इंस्टॉल करें, Apple पोर्टल पर पंजीकरण करें। Xcode में एक खाता जोड़ें -> प्राथमिकताएँ -> खाते, एक रिक्त एप्लिकेशन बनाएं और वास्तविक डिवाइस पर बनाएं। असेंबली के दौरान, डिवाइस आपके निःशुल्क डेवलपर खाते में जोड़ दिया जाएगा। असेंबली और लॉन्च के बाद, आपको संग्रह बनाने की आवश्यकता है; ऐसा करने के लिए, जेनेरिक iOS डिवाइस और उत्पाद चुनें -> पुरालेख। एक बार संग्रह बन जाने के बाद, उसमें से Embedded.mobileprovision और PkgInfo फ़ाइलें निकालें। बिल्ड लॉग से डिवाइस तक, सही हस्ताक्षर कुंजी के साथ कोडसाइन लाइन ढूंढें, एक्सटेंशन ऐप.xcent के साथ एंटाइटेलमेंट फ़ाइल का पथ, इसे कॉपी करें।
संग्रह से .app फ़ोल्डर की प्रतिलिपि बनाएँ, संग्रह में बाइनरी को Linux में क्रॉस-कंपाइलर द्वारा संकलित एक से बदलें (उदाहरण के लिए, SpaceJaguar.app/SpaceJaguar), फिर .app में आवश्यक संसाधन जोड़ें, संग्रह से .app में PkgInfo और एम्बेडेड.mobileprovision फ़ाइलों की अखंडता की जाँच करें, यदि आवश्यक हो तो फिर से कॉपी करें। हम कोडसाइन कमांड – का उपयोग करके .app पर पुनः हस्ताक्षर करते हैं। कोडसाइन को साइन के लिए एक इनपुट कुंजी की आवश्यकता होती है, एंटाइटेलमेंट फ़ाइल का पथ (.plist एक्सटेंशन के साथ इसका नाम बदला जा सकता है)
पुन: हस्ताक्षर करने के बाद, एक पेलोड फ़ोल्डर बनाएं, .app एक्सटेंशन वाले फ़ोल्डर को वहां ले जाएं, रूट में पेलोड के साथ एक ज़िप संग्रह बनाएं, .ipa एक्सटेंशन के साथ संग्रह का नाम बदलें। उसके बाद, Xcode में, उपकरणों की सूची खोलें और नए आईपीए को डिवाइस के अनुप्रयोगों की सूची में खींचें और छोड़ें; Apple कॉन्फिगरेटर 2 के माध्यम से इंस्टॉलेशन इस विधि के लिए काम नहीं करता है। यदि पुन: हस्ताक्षर सही ढंग से किया जाता है, तो नए बाइनरी वाला एप्लिकेशन 7-दिवसीय प्रमाणपत्र के साथ iOS डिवाइस (उदाहरण के लिए, iPad) पर इंस्टॉल किया जाएगा, यह परीक्षण अवधि के लिए पर्याप्त है।

स्रोत

https://github.com/tpoechtrager/cctools-port

https://docs.godotengine.org/ru/latest/development/compiling/cross-compiling_for_ios_on_linux.html

https://jonnyzzz.com/blog/2018/06/13/link-error-3/

https://stackoverflow.com/questions/6896029/re-sign-ipa-iphone

https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/Procedures/Procedures.html

इस पोस्ट में मैं उबंटू पर MinGW32 टूलचेन का उपयोग करके विंडोज़ के लिए लाइब्रेरी और एप्लिकेशन बनाने की प्रक्रिया का वर्णन करूंगा।
वाइन स्थापित करें, मिंगव:

sudo apt-get install wine mingw-w64

इसके बाद, आप पहले से ही विंडोज़ के लिए C/C++ एप्लिकेशन बना सकते हैं:

# C
i686-w64-mingw32-gcc helloWorld.c -o helloWorld32.exe      # 32-bit
x86_64-w64-mingw32-gcc helloWorld.c -o helloWorld64.exe    # 64-bit
 
# C++
i686-w64-mingw32-g++ helloWorld.cc -o helloWorld32.exe     # 32-bit
x86_64-w64-mingw32-g++ helloWorld.cc -o helloWorld64.exe   # 64-bit

एकत्रित एक्सई को वाइन का उपयोग करके जांचा जा सकता है।
इसके बाद, आइए CMake बिल्ड, CMakeLists.txt फ़ाइल में परिवर्तनों को देखें, बिल्ड फ़ाइल में MinGW विशिष्ट चीज़ें जोड़ते हुए:

if (MINGW32)
set(CMAKE_SYSTEM_NAME Windows)
SET(CMAKE_C_COMPILER i686-w64-mingw32-gcc)
SET(CMAKE_CXX_COMPILER i686-w64-mingw32-g++)
SET(CMAKE_RC_COMPILER i686-w64-mingw32-windres)
set(CMAKE_RANLIB i686-w64-mingw32-ranlib)
endif()

// для сборки shared dll
elseif (MINGW32)
add_library(FlameSteelEngineGameToolkit.dll SHARED ${SOURCE_FILES})
else()

// обязательно линкуем со всеми зависимостями
if (MINGW32)
target_link_libraries(
                        FlameSteelEngineGameToolkit.dll 
                        -static-libgcc
                        -static-libstdc++
                        SDL2 
                        SDL2_mixer 
                        /home/demensdeum/Sources/cube-art-project-bootstrap/FlameSteelFramework/FlameSteelCore/FlameSteelCore.dll
                        /home/demensdeum/Sources/cube-art-project-bootstrap/FlameSteelFramework/FlameSteelBattleHorn/FlameSteelBattleHorn.dll
                        /home/demensdeum/Sources/cube-art-project-bootstrap/FlameSteelFramework/FlameSteelCommonTraits/FlameSteelCommonTraits.dll)

set_target_properties(FlameSteelEngineGameToolkit.dll PROPERTIES
        PREFIX ""
        SUFFIX ""
        LINK_FLAGS "-Wl,--add-stdcall-alias"
        POSITION_INDEPENDENT_CODE 0 # this is to avoid MinGW warning; 
        # MinGW generates position-independent-code for DLL by default
)
else()

हम एकत्र करते हैं:

cmake -DMINGW32=1 .
make

आप जो एकत्र कर रहे हैं उसके आधार पर आउटपुट एक डीएलएल या एक्सई होगा। एक कामकाजी उदाहरण के लिए, आप नए क्यूब-आर्ट-प्रोजेक्ट और उसके पुस्तकालयों के भंडार को देख सकते हैं:
https://gitlab.com/demensdeum/cube-art-project

https://gitlab.com/demensdeum/FlameSteelEngineGameToolkitFSGL

https://gitlab.com/demensdeum/cube-art-project-bootstrap

स्रोत
https://arrayfire.com/cross-compile-to-windows-from-linux/

इस पोस्ट में, मैं CMake और osxcross का उपयोग करके Ubuntu बिल्ड मशीन पर macOS के लिए क्रॉस-प्लेटफ़ॉर्म C++ एप्लिकेशन बनाने का वर्णन करूंगा।
सबसे पहले, osxcross टूलचेन स्थापित करें:
https://github.com/tpoechtrager/osxcross
स्थापना 3 चरणों में होती है, डाउनलोडिंग निर्भरताएँ:

cd tools
./get_dependencies.sh

आधिकारिक Apple वेबसाइट से XCode.xip डाउनलोड करें, फिर XCode से SDK डाउनलोड करें:

./gen_sdk_package_pbzx.sh /media/demensdeum/2CE62A79E62A4404/LinuxSupportStorage/xcode111.xip

मुझे आशा है कि आपने अंतिम चरण में XCode लाइसेंस अनुबंध पढ़ा होगा? इसके बाद, आवश्यक उपसर्ग के साथ टूलचेन बनाएं:

INSTALLPREFIX=/home/demensdeum/Apps/osxcross ./build.sh 

अब आप पिछले चरण की उपसर्ग निर्देशिका से osxcross का उपयोग कर सकते हैं। आइए CMake के लिए एक नया बिल्ड मैक्रो जोड़ें और सभी आवश्यक चीज़ें लिखें:

if (OSXCROSS)
SET(CMAKE_SYSTEM_NAME Darwin)
SET(CMAKE_C_COMPILER o64-clang)
SET(CMAKE_CXX_COMPILER o64-clang++)
SET(CMAKE_C_COMPILER_AR x86_64-apple-darwin19-ar)
SET(CMAKE_CXX_COMPILER_AR x86_64-apple-darwin19-ar)
SET(CMAKE_LINKER x86_64-apple-darwin19-ld)
SET(ENV{OSXCROSS_MP_INC} 1)
endif()

डायनामिक लिंकिंग मेरे लिए सफल नहीं रही, इसलिए हम पुस्तकालयों को स्थिर रूप से निर्यात करते हैं:

if (OSXCROSS)
add_library(FlameSteelCore STATIC ${SOURCE_FILES})
else()

इसके बाद, आपको इस तथ्य का सामना करना पड़ सकता है कि आपके पास osxcross के लिए आवश्यक लाइब्रेरी नहीं है, SDL2 का उपयोग करते समय मुझे इसका सामना करना पड़ा। osxcross तैयार लाइब्रेरी पैकेजों का समर्थन करता है – मैकपोर्ट्स। उदाहरण के लिए, SDL2-मिक्सर स्थापित करना:

osxcross-macports -v install libsdl2_mixer

इसके बाद, आप हमेशा की तरह सेमेक-मेक लिंक में लाइब्रेरी/एप्लिकेशन बनाना शुरू कर सकते हैं, यदि आवश्यक हो तो लाइब्रेरी की स्टैटिक लिंकिंग निर्दिष्ट करना न भूलें।

पुस्तकालयों की मैन्युअल असेंबली

वर्तमान में, मुझे स्थैतिक लिंकिंग के दौरान पुस्तकालयों के गलत संग्रह की समस्या का सामना करना पड़ा है; अंतिम एप्लिकेशन बनाते समय मुझे त्रुटि प्राप्त होती है:

file was built for archive which is not the architecture being linked (x86_64)

इस टिकट के समान, हम एक वर्कअराउंड लागू करने में कामयाब रहे जिसके परिणामस्वरूप बिल्ड सही ढंग से पूरा हुआ। आइए स्टैटिक लाइब्रेरी को अनज़िप करें और ओएसएक्सक्रॉस आर्काइवर का उपयोग करके इसे नए सिरे से बनाएं:

ar x ../libFlameSteelCore.a
rm ../libFlameSteelCore.a
x86_64-apple-darwin19-ar rcs ../libFlameSteelCore.a *.o

इसके अलावा, जिन समस्याओं पर मैं व्यक्तिगत रूप से विचार करता हूं उनमें से एक सीधे उबंटू पर मैकओएस अनुप्रयोगों को चलाने की क्षमता की कमी है (कम से कम कार्यक्षमता के हिस्से के साथ)। बेशक, एक परियोजना है darling, लेकिन समर्थन अभी भी वांछित होने के लिए बहुत कुछ बाकी है।

स्रोत

https://github.com/tpoechtrager/osxcross

आजकल, आपको क्लाउड सेवाओं पर निर्भर रहने की ज़रूरत नहीं है: आप पूरी तरह से अपने हार्डवेयर पर उच्च-गुणवत्ता वाली छवियां उत्पन्न कर सकते हैं। इस पोस्ट में, मैं वर्णन करूंगा कि ComfyUI का उपयोग करके आपके कंप्यूटर पर आधुनिक FLUX मॉडल को स्थानीय रूप से कैसे चलाया जाए।

ComfyUI नोड-आधारित आर्किटेक्चर का उपयोग करता है। यह आपको इसकी अनुमति देता है:
– पीढ़ी के हर चरण पर पूरी तरह से नियंत्रण रखें।
– आसानी से तैयार “वर्कफ़्लोज़” साझा करें

FLUX एक बड़ा मॉडल है, इसलिए हार्डवेयर आवश्यकताएँ SD 1.5 या SDXL से अधिक हैं:
– वीडियो कार्ड (जीपीयू): 12 जीबी वीआरएएम या उच्चतर (आरामदायक काम के लिए) के साथ एनवीडिया आरटीएक्स। यदि आपके पास 8 जीबी या उससे कम है, तो आपको परिमाणित संस्करण (जीजीयूएफ या एनएफ4) का उपयोग करना होगा।
– रैंडम एक्सेस मेमोरी (रैम): न्यूनतम 16 जीबी (अधिमानतः 32 जीबी और अधिक)।
– डिस्क स्थान: मॉडलों और घटकों के लिए लगभग 20-50 जीबी।

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

`टेक्स्ट टू इमेज (फ्लक्स.1 डेव)` नोड में अंग्रेजी में एक संकेत लिखें, रिज़ॉल्यूशन का चयन करें (फ्लक्स 1024×1024 और इससे भी अधिक के साथ अच्छा काम करता है) और RUN दबाएँ।

पहली पीढ़ी में समय लग सकता है क्योंकि मॉडलों को वीडियो कार्ड मेमोरी में लोड किया जाएगा।

https://github.com/comfyanonymous/ComfyUI

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

स्थानीय वाइब कोडिंग के लिए उपकरण

आरामदायक कार्य के लिए हमें तीन मुख्य घटकों की आवश्यकता है:
– एलएम स्टूडियो: स्थानीय एलएलएम डाउनलोड करने और चलाने के लिए एक सुविधाजनक एप्लिकेशन। यह GGUF मॉडल के साथ काम करने की सभी जटिलताओं को स्वीकार करता है और OpenAI API के साथ संगत एक स्थानीय सर्वर स्थापित करता है।
– वीएस कोड: एक लोकप्रिय और परिचित कोड संपादक।
– जारी रखें: वीएस कोड के लिए एक्सटेंशन जो तंत्रिका नेटवर्क को सीधे कार्य वातावरण में एकीकृत करता है। आपको चैट करने, रीफैक्टरिंग के लिए कोड हाइलाइट करने और स्वत: पूर्ण का समर्थन करने की अनुमति देता है।

हार्डवेयर आवश्यकताएँ

स्थानीय भाषा मॉडल स्मृति गहन हैं:
– वीडियो कार्ड (जीपीयू): 8 जीबी वीआरएएम या उच्चतर के साथ एनवीडिया (7-8 बिलियन पैरामीटर वाले मॉडल के साथ आरामदायक काम के लिए)। भारी मॉडलों के लिए 16 जीबी वीआरएएम की आवश्यकता होगी।
– डिस्क स्थान: विभिन्न डाउनलोड किए गए मॉडलों को संग्रहीत करने के लिए लगभग 500 जीबी।

लिंक को कॉन्फ़िगर करना

सेटअप प्रक्रिया काफी सरल है और टर्मिनल में जटिल हेरफेर की आवश्यकता नहीं है:
1. एलएम स्टूडियो डाउनलोड और इंस्टॉल करें। क्वेन कोडर या gemma3:12b जैसे हल्के मॉडल को खोजने के लिए अंतर्निहित खोज का उपयोग करें।
2. एलएम स्टूडियो में, स्थानीय सर्वर टैब पर जाएं और स्टार्ट सर्वर पर क्लिक करें। डिफ़ॉल्ट रूप से यह `http://localhost:1234/v1` पर प्रारंभ होगा।
3. वीएस कोड खोलें और प्लगइन स्टोर से जारी रखें एक्सटेंशन इंस्टॉल करें।
4. जारी रखें कॉन्फ़िगरेशन फ़ाइल खोलें और `ओपनाई` प्रदाता और एलएम स्टूडियो से अपने स्थानीय सर्वर का पता निर्दिष्ट करते हुए एक नया मॉडल जोड़ें।

फिर आप जारी रखें साइडबार में सीधे अपने स्थानीय एलएलएम के साथ संवाद कर सकते हैं, अपने कोड के बारे में प्रश्न पूछ सकते हैं और नए घटक तैयार कर सकते हैं।

यह क्यों काम करता है?

जैसा कि मैंने पहले लिखा था, एलएलएम फ्लैट संरचना और WET (हर चीज़ दो बार लिखें) कोड के साथ बेहतर करते हैं। जब जटिल आर्किटेक्चर को डिजाइन करने की बात आती है तो स्थानीय पैरामीटर मॉडल GPT-4 जैसे दिग्गजों से कमतर हो सकते हैं, लेकिन वे बॉयलरप्लेट कोड उत्पन्न करने, सरल कार्यों को फिर से तैयार करने और तेजी से प्रोटोटाइप करने में सक्षम हैं।

इसके अतिरिक्त, स्थानीय वाइब कोडिंग के साथ, आपका कोड मशीन को कभी नहीं छोड़ता है। यह इस संयोजन को कॉर्पोरेट विकास और संवेदनशील डेटा के साथ काम करने के लिए आदर्श बनाता है।

आउटपुट

स्थानीय तंत्रिका नेटवर्क एक प्रोग्रामर को पूरी तरह से बदलने या एक जटिल प्रणाली को डिजाइन करने में सक्षम नहीं हैं। हालाँकि, एलएम स्टूडियो + वीएस कोड + कंटिन्यू का संयोजन क्लाउड सेवाओं से स्वतंत्रता प्रदान करता है और गोपनीयता बनाए रखता है। यदि आप छोटे मॉडलों की सीमाओं को स्वीकार करने और परियोजना वास्तुकला को स्वतंत्र रूप से नियंत्रित करने के इच्छुक हैं तो यह नियमित कार्यों के लिए पूरी तरह से काम करने वाला सहायक उपकरण है।

लिंक

https://code.visualstudio.com/
https://lmstudio.ai/
https://continue.dev/

स्रोत

https://youtu.be/IqqCwhG46jY
https://www.youtube.com/watch?v=7AImkA96mE8

पहले, तंत्रिका नेटवर्क का उपयोग करके वीडियो बनाना रनवे या लूमा जैसी क्लाउड सेवाओं का विशेषाधिकार था। आज, यदि आपके पास आधुनिक एनवीडिया ग्राफिक्स कार्ड है, तो आप सीधे अपने कंप्यूटर पर उच्च गुणवत्ता वाले वीडियो बना सकते हैं। इस पोस्ट में, मैं आपको बताऊंगा कि ComfyUI और प्रभावी LTX-2.3 मॉडल का उपयोग करके स्थानीय वीडियो पीढ़ी कैसे सेट की जाए।

वीडियो निर्माण के लिए उपकरण

काम के लिए हमें आवश्यकता होगी:
– ComfyUI: नोड-आधारित आर्किटेक्चर के साथ एक शक्तिशाली इंटरफ़ेस जो आपको पीढ़ी प्रक्रिया को लचीले ढंग से अनुकूलित करने की अनुमति देता है।
– LTX-2.3: लाइटरिक्स का एक आधुनिक मॉडल, जो अपेक्षाकृत मध्यम वीडियो मेमोरी आवश्यकताओं के साथ सहज और विस्तृत वीडियो बनाने के लिए अनुकूलित है।

हार्डवेयर आवश्यकताएँ

छवियों के साथ काम करने की तुलना में वीडियो बनाना कहीं अधिक संसाधन-गहन प्रक्रिया है:
– वीडियो कार्ड (जीपीयू): 8 जीबी वीआरएएम के साथ एनवीडिया आरटीएक्स 768×512 के रिज़ॉल्यूशन के लिए आवश्यक न्यूनतम है। आरामदायक संचालन और उच्च रिज़ॉल्यूशन के लिए, 16-24 जीबी वीआरएएम होना अत्यधिक वांछनीय है।
– रैंडम एक्सेस मेमोरी (रैम): न्यूनतम 32 जीबी। डाउनलोड करते समय वीडियो मॉडल और VAE बहुत अधिक जगह लेते हैं।
– डिस्क स्थान: मॉडल और संबंधित घटकों के लिए लगभग 500 जीबी।

सेटअप और लॉन्च

ComfyUI में LTX-2.3 लॉन्च करने की प्रक्रिया इस प्रकार है:
1. ComfyUI अपडेट करें: मॉडल अपेक्षाकृत नया है, इसलिए सुनिश्चित करें कि आपके पास इंटरफ़ेस का नवीनतम संस्करण स्थापित है।
2. वर्कफ़्लो स्थापित करें: सबसे आसान तरीका LTX वीडियो के लिए तैयार JSON टेम्पलेट ढूंढना है। वीडियो अव्यक्त स्थान के साथ काम करने के लिए मॉडल को विशिष्ट नोड्स की आवश्यकता होती है।
3. संकेत और पैरामीटर: अंग्रेजी में दृश्य का विवरण दर्ज करें। ध्यान दें कि LTX-2.3 गति को अच्छी तरह से समझता है (उदाहरण के लिए “कैमरा चारों ओर घूमता है”, “तेज गति”)।

LTX-2.3 क्यों चुनें?

LTX-2.3 उल्लेखनीय है क्योंकि यह मालिकाना क्लाउड सेवाओं के बराबर परिणाम देता है, लेकिन स्थानीय रूप से चलता है। यह आपको देता है:
– पूर्ण गोपनीयता: आपके संकेत और जेनरेट किए गए वीडियो अन्य लोगों के सर्वर पर नहीं जाते हैं।
– नियंत्रण: आप प्रत्येक प्रयास के लिए भुगतान किए बिना फ्रेम दर (एफपीएस), रिज़ॉल्यूशन और शीघ्र शक्ति के साथ प्रयोग कर सकते हैं।

स्थानीय वीडियो पीढ़ी अभी भी सक्रिय विकास में है, और LTX-2.3 “होम हॉलीवुड” की दुनिया में एक शानदार प्रविष्टि है।

लिंक

https://github.com/comfyanonymous/ComfyUI
https://huggingface.co/Lightricks/LTX-Video

आजकल, आपको सामग्री बनाने के लिए क्लाउड सेवाओं पर निर्भर रहने की ज़रूरत नहीं है: आप पूरी तरह से अपने हार्डवेयर पर उच्च गुणवत्ता वाला संगीत उत्पन्न कर सकते हैं। इस पोस्ट में, मैं वर्णन करूंगा कि ComfyUI का उपयोग करके आपके कंप्यूटर पर आधुनिक ACE-Step-1.5 मॉडल को स्थानीय रूप से कैसे चलाया जाए।

ComfyUI नोड-आधारित आर्किटेक्चर का उपयोग करता है। यह आपको इसकी अनुमति देता है:
– ऑडियो जेनरेशन के हर चरण को पूरी तरह से नियंत्रित करें।
– आसानी से तैयार “वर्कफ़्लोज़” साझा करें।

एसीई-स्टेप-1.5 संगीत निर्माण के लिए एक उन्नत मॉडल है जिसके लिए महत्वपूर्ण कम्प्यूटेशनल संसाधनों की आवश्यकता होती है। हार्डवेयर आवश्यकताएँ कई सरल सिंथेसाइज़र की तुलना में अधिक हैं:
– वीडियो कार्ड (जीपीयू): उच्च गुणवत्ता पर आरामदायक काम के लिए 8 जीबी वीआरएएम या उच्चतर (12 जीबी+ अनुशंसित) के साथ एनवीडिया आरटीएक्स।
– रैंडम एक्सेस मेमोरी (रैम): न्यूनतम 16 जीबी (अधिमानतः 32 जीबी और अधिक)।
– प्रोसेसर (सीपीयू): AVX/CUDA कंप्यूटिंग के लिए अच्छे समर्थन के साथ आधुनिक मल्टी-कोर प्रोसेसर।
– डिस्क स्थान: मॉडलों और घटकों के लिए लगभग 20-50 जीबी।

ACE-Step-1.5 को चलाने का सबसे आसान तरीका तैयार ऑडियो जेनरेशन टेम्पलेट का उपयोग करना है। बस वर्कफ़्लो विंडो में संगीत टेक्स्ट से ऑडियो खोजें और इंस्टॉल करें।

`प्रॉम्प्ट इनपुट` नोड में शैली और मनोदशा का वर्णन करने वाला एक संकेत लिखें (उदाहरण के लिए, “भारी बास के साथ उत्थान सिंथवेव ट्रैक”)। वांछित अवधि निर्दिष्ट करें और RUN दबाएँ।
पहली पीढ़ी में समय लग सकता है, क्योंकि मॉडलों को वीडियो कार्ड मेमोरी में लोड किया जाएगा और जटिल ध्वनिक पैटर्न को संसाधित किया जाएगा।

https://github.com/comfyanonymous/ComfyUI
https://www.youtube.com/watch?v=UAlLD5fS7-c

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

मैंने प्रोजेक्ट को Apple M2 प्रोसेसर के साथ मैकबुक पर भी चलाया, और मुझे पता है कि AMD के वीडियो कार्ड के नवीनतम मॉडल समर्थित हैं।

MacOS पर इंस्टॉल करने के लिए, ollama वेबसाइट पर जाएँ:
https://ollama.com/download/mac

“MacOS के लिए डाउनलोड करें” पर क्लिक करें, आप ollama-darwin.zip फॉर्म का एक संग्रह डाउनलोड करेंगे, संग्रह के अंदर Ollama.app होगा जिसे “एप्लिकेशन” में कॉपी करने की आवश्यकता है। इसके बाद, Ollama.app लॉन्च करें, सबसे अधिक संभावना है कि इंस्टॉलेशन प्रक्रिया पहले लॉन्च पर होगी। उसके बाद, ट्रे में आपने ओलामा आइकन देखा, ट्रे घड़ी के ठीक बगल में शीर्ष पर है।

उसके बाद, एक नियमित macOS टर्मिनल लॉन्च करें, और किसी भी ओलामा मॉडल को डाउनलोड, इंस्टॉल और चलाने के लिए कमांड टाइप करें। उपलब्ध मॉडलों, विवरणों और उनकी विशेषताओं की सूची ओलामा वेबसाइट पर देखी जा सकती है:
https://ollama.com/search

यदि लॉन्च के समय यह आपके वीडियो कार्ड में फिट नहीं बैठता है तो सबसे कम पैरामीटर वाला मॉडल चुनें।

उदाहरण के लिए, llama3.1:नवीनतम मॉडल लॉन्च करने का आदेश:

ollama run llama3.1:latest

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

सूत्रों का कहना है
https://www.youtube.com/watch?v=Wjrdr0NU4Sk
https://ollama.com

यदि आप वीडियो को स्थिर करना चाहते हैं और कैमरा शेक को दूर करना चाहते हैं, तो `ffmpeg` टूल एक शक्तिशाली समाधान प्रदान करता है। अंतर्निहित फ़िल्टर `vidstabdetect` और `vidstabtransform` के लिए धन्यवाद, आप जटिल वीडियो संपादकों का उपयोग किए बिना पेशेवर परिणाम प्राप्त कर सकते हैं।

काम के लिए तैयारी

शुरू करने से पहले, सुनिश्चित करें कि आपका `ffmpeg` `vidstab` लाइब्रेरी का समर्थन करता है। लिनक्स पर आप इसे कमांड से जांच सकते हैं:

bash  
ffmpeg -filters | grep vidstab  

यदि लाइब्रेरी स्थापित नहीं है, तो आप इसे जोड़ सकते हैं:

sudo apt install ffmpeg libvidstab-dev  

ब्रू के माध्यम से macOS के लिए इंस्टालेशन:

brew install libvidstab
brew install ffmpeg

अब चलिए प्रक्रिया पर आगे बढ़ते हैं।

चरण 1: गति विश्लेषण

सबसे पहले आपको वीडियो की गति का विश्लेषण करना होगा और स्थिरीकरण मापदंडों के साथ एक फ़ाइल बनानी होगी।

ffmpeg -i input.mp4 -vf vidstabdetect=shakiness=10:accuracy=15 transfile=transforms.trf -f null -  

पैरामीटर:

अस्थिरता: वीडियो शेक स्तर (डिफ़ॉल्ट 5, अधिक जटिल मामलों के लिए 10 तक बढ़ाया जा सकता है)।
सटीकता: विश्लेषण सटीकता (डिफ़ॉल्ट 15)।
ट्रांसफ़ाइल: गति मापदंडों को सहेजने के लिए फ़ाइल का नाम।

चरण 2: स्थिरीकरण लागू करें

अब आप परिवर्तन फ़ाइल का उपयोग करके स्थिरीकरण लागू कर सकते हैं:

ffmpeg -i input.mp4 -vf vidstabtransform=input=transforms.trf:zoom=5 output.mp4

पैरामीटर:

इनपुट: परिवर्तन मापदंडों के साथ फ़ाइल को इंगित करता है (पहले चरण में बनाया गया)।
ज़ूम: काले किनारों को हटाने के लिए ज़ूम कारक (उदाहरण के लिए 5 – कलाकृतियों को हटाए जाने तक ऑटो ज़ूम)।

मैं आपके ध्यान में 1936 से एलन ट्यूरिंग के लेख “ऑन कंप्यूटेबल नंबर्स विद एन एप्लीकेशन टू द प्रॉब्लम ऑफ रिजॉल्यूशन” के पहले पन्नों का अनुवाद प्रस्तुत करता हूं। पहले अध्याय में कंप्यूटर का विवरण है, जो बाद में आधुनिक कंप्यूटिंग का आधार बन गया।

लेख और स्पष्टीकरण का पूरा अनुवाद अमेरिकी लोकप्रिय चार्ल्स पेटज़ोल्ड की पुस्तक में पढ़ा जा सकता है, जिसका शीर्षक है “रीडिंग ट्यूरिंग: ए जर्नी थ्रू ट्यूरिंग हिस्टोरिकल आर्टिकल ऑन कम्प्यूटेबिलिटी एंड ट्यूरिंग मशीन्स” (आईएसबीएन 978-5-97060-231-7, 978-0-470-22905-7)

मूल लेख:
https://www.astro.puc.cl/~rparra/tools/PAPERS/turing_1936.pdf

समाधान समस्या के अनुप्रयोग के साथ गणनीय संख्याओं पर

ए. एम. ट्यूरिंग

[28 मई 1936 को प्राप्त – 12 नवंबर 1936 को पढ़ें]

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

पैराग्राफ 9 और 10 में मैं यह दिखाने के लिए कुछ तर्क देता हूं कि गणना योग्य संख्याओं में वे सभी संख्याएं शामिल होती हैं जिन्हें स्वाभाविक रूप से गणना योग्य माना जाता है। विशेष रूप से, मैं दिखाता हूँ कि संख्याओं के कुछ बड़े वर्ग गणना योग्य हैं। इनमें शामिल हैं, उदाहरण के लिए, सभी बीजगणितीय संख्याओं के वास्तविक भाग, बेसेल फ़ंक्शंस के शून्य के वास्तविक भाग, संख्याएँ π, ई और अन्य। हालाँकि, गणना योग्य संख्याओं में सभी निश्चित संख्याएँ शामिल नहीं होती हैं, जैसा कि एक निश्चित संख्या के निम्नलिखित उदाहरण से प्रमाणित होता है जो गणना योग्य नहीं है।

यद्यपि गणना योग्य संख्याओं का वर्ग बहुत बड़ा है और कई मामलों में वास्तविक संख्याओं के वर्ग के समान है, फिर भी यह गणना योग्य है। §8 में मैं कुछ ऐसे तर्कों पर विचार करता हूं जो इसके विपरीत तर्क देते प्रतीत होंगे। जब इनमें से किसी एक तर्क को सही ढंग से लागू किया जाता है, तो ऐसे निष्कर्ष निकाले जाते हैं जो पहली नज़र में गोडेल* के समान होते हैं। इन परिणामों का अत्यंत महत्वपूर्ण अनुप्रयोग है। विशेष रूप से, जैसा कि नीचे दिखाया गया है (§11), समाधान समस्या का कोई समाधान नहीं हो सकता।

हाल के एक लेख में, अलोंजो चर्च ने “प्रभावी गणनाशीलता” का विचार पेश किया, जो “कम्प्यूटेबिलिटी” के मेरे विचार के बराबर है लेकिन इसकी एक पूरी तरह से अलग परिभाषा है। समाधान की समस्या के संबंध में चर्च भी इसी तरह के निष्कर्ष पर पहुंचता है। “कम्प्यूटेबिलिटी” और “प्रभावी रूप से गणना योग्य” की समानता का प्रमाण इस लेख के परिशिष्ट में प्रस्तुत किया गया है।

1. कंप्यूटर

हम पहले ही कह चुके हैं कि गणनीय संख्याएँ वे संख्याएँ हैं जिनके दशमलव स्थान परिमित साधनों द्वारा गिनने योग्य होते हैं। यहां एक स्पष्ट परिभाषा की आवश्यकता है। जब तक हम §9 तक नहीं पहुंच जाते, यह लेख यहां दी गई परिभाषाओं को सही ठहराने का कोई वास्तविक प्रयास नहीं करेगा। अभी के लिए, मैं सिर्फ यह नोट करूंगा कि (इसके लिए) तार्किक तर्क यह है कि मानव स्मृति, आवश्यकता से, सीमित है।

आइए वास्तविक संख्या की गणना करने की प्रक्रिया में एक व्यक्ति की तुलना एक ऐसी मशीन से करें जो केवल सीमित संख्या में शर्तों q1, q2, …, qR को पूरा करने में सक्षम है; आइए इन स्थितियों को “एम-कॉन्फिगरेशन” कहें। यह (अर्थात, इस प्रकार परिभाषित) मशीन एक “टेप” (कागज के अनुरूप) से सुसज्जित है। मशीन से गुजरने वाली यह बेल्ट खंडों में विभाजित है। आइए उन्हें “वर्ग” कहें। ऐसे प्रत्येक वर्ग में किसी न किसी प्रकार का “प्रतीक” हो सकता है। किसी भी क्षण, केवल एक ही ऐसा वर्ग होता है, मान लीजिए कि वां, जिसमें वह प्रतीक होता है जो “इस मशीन में है।” आइए ऐसे वर्ग को “स्कैन किया हुआ प्रतीक” कहें। एक “स्कैन किया हुआ पात्र” एकमात्र ऐसा पात्र है जिसके बारे में मशीन को, ऐसा कहा जा सकता है, “सीधे पता” होता है। हालाँकि, अपने एम-कॉन्फ़िगरेशन को बदलकर, मशीन उन कुछ पात्रों को प्रभावी ढंग से याद रख सकती है जिन्हें उसने पहले “देखा” (स्कैन किया है)। किसी भी क्षण मशीन का संभावित व्यवहार एम-कॉन्फ़िगरेशन क्यूएन और स्कैन किए गए प्रतीक*** द्वारा निर्धारित किया जाता है। आइए प्रतीकों की इस जोड़ी को qn, “कॉन्फ़िगरेशन” कहते हैं। इस प्रकार निर्दिष्ट कॉन्फ़िगरेशन किसी दी गई मशीन के संभावित व्यवहार को निर्धारित करता है। इनमें से कुछ कॉन्फ़िगरेशन में, जिनमें स्कैन किया गया वर्ग खाली है (यानी, कोई वर्ण नहीं है), मशीन स्कैन किए गए वर्ग पर एक नया वर्ण लिखती है, और इनमें से अन्य कॉन्फ़िगरेशन में यह स्कैन किए गए वर्ण को मिटा देती है। यह मशीन दूसरे वर्ग को स्कैन करने के लिए भी जाने में सक्षम है, लेकिन इस तरह यह केवल दाएं या बाएं बगल वाले वर्ग तक ही जा सकती है। इनमें से किसी भी ऑपरेशन के अलावा, मशीन का एम-कॉन्फ़िगरेशन बदला जा सकता है। इस मामले में, कुछ लिखित वर्ण अंकों का एक क्रम बनाएंगे, जो गणना की जा रही वास्तविक संख्या का दशमलव भाग है। उनमें से बाकी “स्मृति की सहायता” के लिए गलत चिह्नों से अधिक कुछ नहीं होंगे। इस स्थिति में, केवल उपर्युक्त गलत चिह्नों को ही मिटाया जा सकता है।

मेरा दावा है कि यहां जिन ऑपरेशनों पर विचार किया गया है उनमें वे सभी ऑपरेशन शामिल हैं जिनका उपयोग गणना में किया जाता है। मशीन सिद्धांत की समझ रखने वाले पाठक के लिए इस कथन का तर्क समझना आसान है। इसलिए, अगले भाग में मैं “मशीन”, “टेप”, “स्कैन” आदि शब्दों के अर्थ की समझ के आधार पर संबंधित सिद्धांत को विकसित करना जारी रखूंगा।

*गोडेल “प्रिंसिपिया गणित के औपचारिक रूप से अनिर्णीत वाक्यों पर (व्हाइटहेड और रसेल द्वारा 1910, 1912 और 1913 में प्रकाशित) और संबंधित सिस्टम, भाग I,” गणित का जर्नल। भौतिकी, जर्मन में मासिक बुलेटिन संख्या 38 (1931 के लिए, पृ. 173-198)।
** अलोंजो चर्च, “प्राथमिक संख्या सिद्धांत में एक अनिर्णीत समस्या,” गणित के अमेरिकी जे., नंबर 58 (1936), पीपी. 345-363।
*** अलोंजो चर्च, “रिज़ॉल्यूशन की समस्या पर एक नोट,” सिम्बोलिक लॉजिक के जे., नंबर 1 (1936), पीपी. 40-41