Windows on kenji.blog

Microsoft.Windows.AI के नवीनतम API उपयोग के उदाहरण और नमूना कोड

Fri, 11 Sep 2026 18:00:00 +0900

Microsoft.Windows.AI के नवीनतम API उपयोग के उदाहरण और नमूना कोड: Windows Copilot Runtime की गहराई की खोज

1. परिचय: एक नए Windows युग की शुरुआत जहाँ AI मूल रूप से एकीकृत है

हाल ही के वर्षों में, AI तकनीक का विकास उल्लेखनीय रहा है, और क्लाउड पर बड़े भाषा मॉडल (LLM) के उपयोग से एज डिवाइस (स्थानीय पीसी) पर AI अनुमान (inference) की ओर तेज़ी से प्रतिमान बदलाव (paradigm shift) हो रहा है। इसके मूल में “Windows Copilot Runtime” है, जो Microsoft द्वारा Windows 11 के लिए प्रदान किया गया है, और इसे संचालित करने के लिए “Microsoft.Windows.AI” API है।

क्लाउड API (जैसे OpenAI या Azure OpenAI) का उपयोग करके एप्लिकेशन विकसित करना आसान है, लेकिन विलंबता (latency), गोपनीयता और निरंतर लागत जैसी चुनौतियाँ हमेशा बनी रहती हैं। दूसरी ओर, स्थानीय रूप से AI मॉडल चलाकर, आप बिना डिवाइस के बाहर गोपनीय डेटा भेजे, ऑफ़लाइन काम करने वाले अल्ट्रा-लो लेटेंसी एप्लिकेशन बना सकते हैं।

इस लेख में, हम C# और C++ के व्यावहारिक नमूना कोड के साथ आर्किटेक्चर से लेकर प्रदर्शन ट्यूनिंग तक, भविष्य के Windows एप्लिकेशन विकास के लिए आवश्यक स्थानीय AI सुविधाओं को लागू करने के तरीके के बारे में विस्तार से बताएंगे। हम केवल API को कॉल करने के अलावा, अंतर्निहित हार्डवेयर (NPU और GPU) के उपयोग और DirectML के साथ एकीकरण जैसे उन्नत तकनीकी विवरणों में गहराई से जाएंगे।

2. Windows Copilot Runtime और आर्किटेक्चर का समग्र दृश्य

Windows Copilot Runtime AI स्टैक का एक सेट है जिसे डेवलपर्स के लिए Windows पर AI मॉडल को आसानी से एकीकृत और अधिकतम प्रदर्शन निकालने के लिए डिज़ाइन किया गया है। यह रनटाइम OS स्तर पर हार्डवेयर त्वरण (hardware acceleration) को अमूर्त करता है और डेवलपर्स को एक एकीकृत इंटरफ़ेस प्रदान करता है।

graph TD App["Windows एप्लिकेशन (C# / C++)"] --> API["Microsoft.Windows.AI APIs"] App --> ORT["ONNX Runtime"] API --> WCR["Windows Copilot Runtime (OS लेयर)"] WCR --> SLM["स्थानीय मॉडल (Phi-Silica, आदि)"] ORT --> DML["DirectML Execution Provider"] SLM --> DML DML --> DXCore["DXCore / DirectX 12"] DXCore --> NPU["NPU (न्यूरल प्रोसेसिंग यूनिट)"] DXCore --> GPU["GPU (ग्राफिक्स प्रोसेसिंग यूनिट)"] DXCore --> CPU["CPU"]

जैसा कि ऊपर दिया गया आर्किटेक्चर आरेख दिखाता है, एप्लिकेशन उच्च-स्तरीय Microsoft.Windows.AI API का उपयोग करके OS में निर्मित छोटे भाषा मॉडल (SLM: जैसे Phi-Silica) तक सीधे पहुंच सकते हैं। कस्टम मॉडल का उपयोग करते समय, ONNX Runtime और DirectML के माध्यम से स्पष्ट रूप से हार्डवेयर त्वरण का उपयोग करना भी संभव है। चूँकि OS लेयर CPU, GPU और NPU में वर्कलोड के वितरण को अनुकूलित करती है, इसलिए डेवलपर्स हार्डवेयर के अंतर के बारे में गहराई से चिंता किए बिना उच्च-प्रदर्शन वाले AI ऐप्स बना सकते हैं।

3. हार्डवेयर त्वरण और NPU का गणितीय मूल्यांकन

नवीनतम Copilot+ PC में NPU (न्यूरल प्रोसेसिंग यूनिट) होता है, जो AI प्रोसेसिंग के लिए विशेष प्रोसेसर है। NPU के प्रदर्शन का मूल्यांकन आमतौर पर TOPS (Tera Operations Per Second) में किया जाता है।

AI मॉडल के अनुमान में, विशेष रूप से मैट्रिक्स गुणन (GEMM: General Matrix Multiply) की गणना क्षमता थ्रूपुट निर्धारित करती है। हार्डवेयर के सैद्धांतिक अधिकतम प्रदर्शन $P_{\text{peak}}$ का अनुमान निम्नलिखित सूत्र द्वारा लगाया जाता है:

$$ P_{\text{peak}} = f \times N_{\text{cores}} \times N_{\text{MACs/core}} \times 2 $$

यहाँ,

$f$ NPU की क्लॉक फ्रीक्वेंसी (Hz) है
$N_{\text{cores}}$ NPU में कोर की संख्या है
$N_{\text{MACs/core}}$ प्रति कोर MAC (Multiply-Accumulate) यूनिट्स की संख्या है
अंतिम $2$ इसलिए है क्योंकि एक MAC ऑपरेशन को दो ऑपरेशन (गुणा और जोड़) (FLOPs/OPs) के रूप में गिना जाता है।

उदाहरण के लिए, 1.5GHz फ्रीक्वेंसी, 4 कोर और प्रत्येक कोर में 4096 MACs वाले NPU के लिए:

$$ P_{\text{peak}} = 1.5 \times 10^9 \times 4 \times 4096 \times 2 \approx 49.15 \text{ TOPS} $$

यह गणितीय रूप से प्रदर्शित करता है कि प्रदर्शन Windows 11 Copilot+ PC की 40 TOPS की आवश्यकता को पार कर जाता है।

साथ ही, AI मॉडल, विशेष रूप से LLM का अनुमान (डिकोड चरण), मेमोरी-बाउंड (Memory-Bound) होने की प्रवृत्ति रखता है। सिस्टम मेमोरी की सैद्धांतिक बैंडविड्थ $BW$ की गणना इस प्रकार की जाती है:

$$ BW = f_{\text{mem}} \times W_{\text{bus}} \times \frac{2}{8} $$

LPDDR5x-8533 मेमोरी ($f_{\text{mem}} = 8533 \text{ MT/s}$) और 128-बिट बस ($W_{\text{bus}} = 128$) के मामले में, बैंडविड्थ लगभग $136 \text{ GB/s}$ है। AI एप्लिकेशन को अनुकूलित करते समय, यह महत्वपूर्ण है कि इस बैंडविड्थ को कैसे बचाया जाए, और बाद में वर्णित मॉडल क्वांटिज़ेशन (Quantization) आवश्यक हो जाता है।

4. विकास पर्यावरण सेटअप

नवीनतम Windows AI API का उपयोग करने के लिए, आपको निम्नलिखित पर्यावरण और टूलचेन सेट अप करने होंगे:

OS: Windows 11 संस्करण 24H2 या उच्चतर (Copilot+ PC आवश्यकताओं को पूरा करने वाले NPU-सज्जित उपकरणों की दृढ़ता से अनुशंसा की जाती है)
SDK: Windows App SDK (v1.5 या उच्चतर AI एक्सटेंशन सपोर्ट के साथ)
विकास वातावरण: Visual Studio 2022 (v17.10 या उच्चतर), C++ का उपयोग करके नेटिव डेवलपमेंट वर्कलोड और .NET डेस्कटॉप डेवलपमेंट वर्कलोड
पैकेज: NuGet के माध्यम से Microsoft.Windows.AI और Microsoft.ML.OnnxRuntime.DirectML स्थापित करें

1
2
3
4
5
6


<!-- .csproj कॉन्फ़िगरेशन का उदाहरण -->
<ItemGroup>
 <PackageReference Include="Microsoft.Windows.AI" Version="1.0.0-preview1" />
 <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.240311000" />
 <PackageReference Include="Microsoft.ML.OnnxRuntime.DirectML" Version="1.17.1" />
</ItemGroup>

5. 【Deep Dive 1】 C# का उपयोग करके स्थानीय भाषा मॉडल (Phi-Silica) का उपयोग करना

Windows Copilot Runtime में Microsoft द्वारा विकसित एक अत्यधिक कुशल छोटा भाषा मॉडल “Phi-Silica” OS के मानक घटक के रूप में शामिल है। यह नेटवर्क से गीगाबाइट-आकार के मॉडल डाउनलोड किए बिना ऑफ़लाइन वातावरण में उन्नत प्राकृतिक भाषा प्रसंस्करण (पाठ सारांश, कोड जनरेशन, चैटबॉट) को सक्षम बनाता है।

नीचे Microsoft.Windows.AI.Generative नेमस्पेस का उपयोग करके C# में चैट AI बनाने के लिए एक उन्नत नमूना कोड दिया गया है। यह स्ट्रीमिंग प्रतिक्रियाओं का समर्थन करता है और UI थ्रेड को ब्लॉक किए बिना वास्तविक समय में टेक्स्ट उत्पन्न करता है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Windows.AI.Generative;

namespace WindowsAI.Sample
{
 public class LocalLanguageModelService
 {
 private LanguageModel _languageModel;
 private bool _isInitialized = false;

 /// <summary>
 /// भाषा मॉडल को इनिशियलाइज़ करता है। NPU की उपलब्धता की जाँच करता है और मॉडल को इष्टतम डिवाइस पर लोड करता है।
 /// </summary>
 public async Task InitializeAsync()
 {
 if (_isInitialized) return;

 Console.WriteLine("स्थानीय AI मॉडल (Phi-Silica) के लिए सिस्टम आवश्यकताओं और उपलब्धता की जाँच की जा रही है...");

 // जाँच करें कि क्या मॉडल सिस्टम पर उपलब्ध है (यदि समर्थित नहीं है, तो डाउनलोड के लिए प्रेरित किया जा सकता है)
 var availability = await LanguageModel.CheckAvailabilityAsync();
 if (availability != LanguageModelAvailability.Available)
 {
 throw new InvalidOperationException($"स्थानीय AI मॉडल वर्तमान में उपलब्ध नहीं है। स्थिति: {availability}");
 }

 // मॉडल का एक उदाहरण बनाएँ (इस समय, मेमोरी स्पेस में मैपिंग और NPU इनिशियलाइज़ेशन किया जाता है)
 _languageModel = await LanguageModel.CreateAsync();
 _isInitialized = true;

 Console.WriteLine("भाषा मॉडल इनिशियलाइज़ेशन पूरा हुआ। DirectML के माध्यम से हार्डवेयर त्वरण सक्रिय है।");
 }

 /// <summary>
 /// उपयोगकर्ता का प्रॉम्प्ट प्राप्त करता है और स्ट्रीमिंग के रूप में प्रतिक्रिया उत्पन्न करता है।
 /// </summary>
 public async Task GenerateResponseStreamAsync(string prompt, CancellationToken cancellationToken)
 {
 if (!_isInitialized) await InitializeAsync();

 Console.WriteLine($"\n[उपयोगकर्ता इनपुट]: {prompt}\n[AI असिस्टेंट]: ");

 // जनरेशन के लिए हाइपरपैरामीटर सेट करें
 var options = new LanguageModelOptions
 {
 Temperature = 0.7f,
 TopP = 0.9f,
 MaxTokens = 2048,
 RepetitionPenalty = 1.1f
 };

 // वार्तालाप संदर्भ बनाएँ
 var context = new LanguageModelContext();
 context.AddSystemMessage("आप Windows के स्थानीय NPU पर सीधे चलने वाले एक उन्नत AI असिस्टेंट हैं। चरण दर चरण तार्किक रूप से सोचें और संक्षेप में उत्तर दें।");
 context.AddUserMessage(prompt);

 try
 {
 // स्ट्रीमिंग अनुमान API को कॉल करें
 var responseStream = _languageModel.GenerateResponseStreamAsync(context, options);

 // IAsyncEnumerable के रूप में लौटाए गए चंक्स को असिंक्रोनस रूप से पुनरावृत्त (iterate) करें
 await foreach (var chunk in responseStream.WithCancellation(cancellationToken))
 {
 // उत्पन्न टोकन (चंक) को वास्तविक समय में कंसोल पर आउटपुट करें
 // UI एप्लिकेशन के मामले में, इसे TextBox आदि में प्रतिबिंबित करने के लिए यहाँ DispatcherQueue का उपयोग करें
 Console.Write(chunk.Text);
 }
 Console.WriteLine();
 }
 catch (OperationCanceledException)
 {
 Console.WriteLine("\n[उपयोगकर्ता या सिस्टम द्वारा जनरेशन रद्द कर दिया गया]");
 }
 catch (Exception ex)
 {
 Console.WriteLine($"\n[एक गंभीर त्रुटि हुई: {ex.Message}]");
 }
 }
 }
}

5.1 C# कार्यान्वयन में आर्किटेक्चर की व्याख्या

इस कोड का मूल LanguageModel.CheckAvailabilityAsync() के साथ निष्पादन-पूर्व सत्यापन (pre-execution validation) और GenerateResponseStreamAsync का उपयोग करके एसिंक्रोनस स्ट्रीमिंग है। जब OS के बैकग्राउंड में चलने वाला Copilot Runtime इस API कॉल को प्राप्त करता है, तो यह आंतरिक रूप से ONNX Runtime शुरू करता है और सिस्टम कॉन्फ़िगरेशन के आधार पर इष्टतम निष्पादन प्रदाता (Execution Provider) (कई आधुनिक PC में DirectML + NPU) का चयन करता है।

डेवलपर्स मॉडल के टेंसर आकार, टोकनाइज़र कार्यान्वयन, या KV कैश के मेमोरी प्रबंधन की चिंता किए बिना केवल C# कोड की कुछ पंक्तियों के साथ अपने एप्लिकेशनों में अत्याधुनिक AI अनुमान पाइपलाइनों को एकीकृत कर सकते हैं।

6. 【Deep Dive 2】 C++ और DirectML का उपयोग करके कस्टम मॉडल का उच्च गति अनुमान

जब उन विशिष्ट डोमेन से निपटा जाता है जिन्हें केवल OS के मानक भाषा मॉडल (जैसे कस्टम छवि विभाजन, वाक् पहचान, कस्टम ऑब्जेक्ट डिटेक्शन मॉडल आदि) द्वारा कवर नहीं किया जा सकता है, तो डेवलपर्स को सीधे ONNX Runtime और DirectML में हेरफेर करने की आवश्यकता होती है, जो Microsoft.Windows.AI की निचली परतों में स्थित हैं।

C++ का उपयोग करके, आप मेमोरी आवंटन को अत्यधिक अनुकूलित कर सकते हैं और NPU/GPU के चरम प्रदर्शन को प्राप्त कर सकते हैं। नीचे DirectML का उपयोग करके C++ में ONNX प्रारूप कस्टम मॉडल (जैसे YOLOv8) चलाने के लिए एक उन्नत इनिशियलाइज़ेशन और अनुमान पाइपलाइन का मुख्य कार्यान्वयन दिया गया है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include <onnxruntime_cxx_api.h>
#include <dml_provider_factory.h>

class CustomVisionAIProcessor {
private:
 Ort::Env env;
 Ort::Session session{nullptr};
 Ort::AllocatorWithDefaultOptions allocator;

public:
 CustomVisionAIProcessor(const std::wstring& modelPath)
 : env(ORT_LOGGING_LEVEL_WARNING, "VisionAIProcessor") {

 Ort::SessionOptions sessionOptions;
 // थ्रेड की संख्या का अनुकूलन
 sessionOptions.SetIntraOpNumThreads(1);
 // ग्राफ़ अनुकूलन स्तर को अधिकतम पर सेट करें
 sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);

 // 1. DirectML Execution Provider (DML EP) जोड़ें
 // device_id = 0 सिस्टम का डिफ़ॉल्ट अनुशंसित एडेप्टर है (NPU या उच्च प्रदर्शन वाला GPU)
 const OrtApi& ortApi = Ort::GetApi();
 OrtDmlApi* dmlApi = nullptr;
 OrtStatus* status = ortApi.GetExecutionProviderApi("DML", ORT_API_VERSION, reinterpret_cast<void**>(&dmlApi));

 if (status == nullptr && dmlApi != nullptr) {
 Ort::ThrowOnError(dmlApi->SessionOptionsAppendExecutionProvider_DML(sessionOptions, 0));
 std::cout << "[Info] DirectML Execution Provider को सफलतापूर्वक संलग्न किया गया।" << std::endl;
 } else {
 std::cerr << "[Warning] DirectML API प्राप्त करने में विफल। CPU फॉलबैक मोड में चल रहा है।" << std::endl;
 if (status != nullptr) ortApi.ReleaseStatus(status);
 }

 // 2. मॉडल लोड करें और सत्र बनाएँ
 try {
 session = Ort::Session(env, modelPath.c_str(), sessionOptions);
 std::cout << "[Info] ONNX मॉडल को सफलतापूर्वक लोड किया गया और गणना ग्राफ़ संकलित किया गया।" << std::endl;
 } catch (const Ort::Exception& e) {
 std::cerr << "[Error] मॉडल लोड विफल: " << e.what() << std::endl;
 throw;
 }
 }

 void RunInference(const std::vector<float>& imageTensor, const std::vector<int64_t>& inputShape) {
 // 3. इनपुट टेंसर के लिए बफर बनाएँ
 Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
 Ort::Value inputTensor = Ort::Value::CreateTensor<float>(
 memoryInfo,
 const_cast<float*>(imageTensor.data()),
 imageTensor.size(),
 inputShape.data(),
 inputShape.size()
 );

 // 4. इनपुट और आउटपुट नोड के नाम गतिशील रूप से प्राप्त करें
 auto inputNamePtr = session.GetInputNameAllocated(0, allocator);
 auto outputNamePtr = session.GetOutputNameAllocated(0, allocator);
 const char* inputNames[] = { inputNamePtr.get() };
 const char* outputNames[] = { outputNamePtr.get() };

 // 5. अनुमान निष्पादित करें (DirectML के माध्यम से NPU/GPU पर ऑफलोड किया गया)
 std::cout << "[Info] अनुमान इंजन का निष्पादन शुरू हो रहा है..." << std::endl;
 auto startTime = std::chrono::high_resolution_clock::now();

 auto outputTensors = session.Run(Ort::RunOptions{nullptr}, inputNames, &inputTensor, 1, outputNames, 1);

 auto endTime = std::chrono::high_resolution_clock::now();
 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

 // 6. परिणाम टेंसर प्राप्त करें और पार्स करें
 float* outputData = outputTensors.front().GetTensorMutableData<float>();
 size_t outputSize = outputTensors.front().GetTensorTypeAndShapeInfo().GetElementCount();

 std::cout << "[Result] अनुमान पूर्ण: " << duration.count() << " ms" << std::endl;
 std::cout << "[Result] आउटपुट टेंसर के तत्वों की संख्या: " << outputSize << std::endl;
 // * इसके बाद, आउटपुट टेंसर पर NMS (Non-Maximum Suppression) और बाउंडिंग बॉक्स ड्राइंग प्रोसेसिंग लागू करें
 }
};

int main() {
 try {
 // निष्पादित किए जाने वाले ONNX मॉडल का पथ
 CustomVisionAIProcessor processor(L"models/yolov8n_quantized.onnx");

 // अनुमान के लिए डमी छवि डेटा (बैच आकार 1 x 3 चैनल x 640 x 640)
 std::vector<int64_t> inputShape = {1, 3, 640, 640};
 std::vector<float> dummyImage(1 * 3 * 640 * 640, 0.5f);

 processor.RunInference(dummyImage, inputShape);
 } catch (const std::exception& e) {
 std::cerr << "प्रोग्राम असामान्य रूप से समाप्त हुआ: " << e.what() << std::endl;
 return -1;
 }
 return 0;
}

6.1 C++ में मेमोरी प्रबंधन और शून्य-कॉपी अनुमान का महत्व

C++ के साथ DirectML का उपयोग करने का सबसे बड़ा लाभ DirectX 12 (DX12) के साथ घनिष्ठ एकीकरण की क्षमता है। उपरोक्त कोड में शैक्षिक दृष्टिकोण से मानक CPU मेमोरी से डेटा कॉपी करना शामिल है, लेकिन वास्तविक गेम इंजन और वीडियो प्रोसेसिंग एप्लिकेशन में, कई मामले ऐसे होते हैं जहाँ DX12 का उपयोग करके छवियों (टेक्सचर) को GPU या NPU के मेमोरी स्पेस में पहले ही रखा जाता है।

इस मामले में, आप OrtDmlApi के उन्नत बाइंडिंग सुविधाओं का उपयोग करके “शून्य-कॉपी अनुमान (Zero-Copy Inference)” प्राप्त कर सकते हैं, जो DX12 संसाधनों को सीधे ONNX Runtime टेंसर के रूप में मैप करता है। यह PCIe बस में डेटा ट्रांसफर ओवरहेड (ऊपर उल्लिखित बैंडविड्थ $BW$ की खपत) को पूरी तरह से समाप्त कर देता है, जिससे वास्तविक समय के वीडियो प्रोसेसिंग में फ्रेम दर में नाटकीय रूप से सुधार होता है।

7. प्रदर्शन अनुकूलन और सर्वोत्तम अभ्यास

Windows AI API और DirectML का उपयोग करके प्रथम श्रेणी के AI एप्लिकेशन विकसित करने के लिए कुछ आवश्यक अनुकूलन रणनीतियाँ नीचे दी गई हैं।

7.1 मॉडल क्वांटिज़ेशन (Quantization) और Olive टूलकिट

NPU की वास्तविक शक्ति को उजागर करने के लिए, यह एक पूर्ण आवश्यकता है कि AI मॉडल के वज़न और सक्रियण (activations) को FP32 (सिंगल प्रिसिजन फ्लोटिंग पॉइंट) से INT8 या INT4 में क्वांटाइज़ (Quantize) किया जाए। NPU का आर्किटेक्चर पूर्णांक अंकगणित (integer arithmetic) के लिए विशिष्ट है, और FP32 की तुलना में, INT8 सैद्धांतिक रूप से 4 गुना थ्रूपुट और महत्वपूर्ण बिजली बचत प्राप्त करता है।

Microsoft द्वारा प्रदान की गई Olive (ONNX Live) टूलचेन का उपयोग करके, आप Windows वातावरण के लिए PyTorch आदि जैसे मॉडल को स्वचालित रूप से अनुकूलित कर सकते हैं। Olive ट्रांसफार्मर मॉडल के लिए विशेष अटेंशन (attention) अनुकूलन और प्रति-हार्डवेयर ग्राफ़ संकलन का दृढ़ता से समर्थन करता है।

7.2 बैच प्रोसेसिंग बनाम इंटरैक्टिव स्ट्रीमिंग का ट्रेड-ऑफ़

API कॉल्स में, आप कई अनुमान अनुरोधों को एक साथ बैच करके NPU के उपयोग (Compute Utilization) को बढ़ा सकते हैं। हालाँकि, चैटबॉट जैसे इंटरैक्टिव UI के मामले में, थ्रूपुट के बजाय पहले टोकन के प्रदर्शित होने तक का समय (TTFT: Time To First Token) उपयोगकर्ता अनुभव (UX) निर्धारित करता है। इसलिए, इंटरैक्टिव UI के लिए सर्वोत्तम अभ्यास बैच आकार को 1 पर सेट करना और स्ट्रीमिंग जनरेशन को प्राथमिकता देना है।

7.3 बैकग्राउंड कार्य और OS के साथ एकीकरण

AI अनुमान बहुत अधिक स्थानीय शक्ति और सिस्टम संसाधनों की खपत करता है। Windows के App Lifecycle API के साथ एकीकरण करके, आपको एप्लिकेशन के बैकग्राउंड में जाने पर कम प्राथमिकता वाले अनुमान कार्यों को निलंबित (Suspend) करने या संसाधन की खपत को कम करने वाली कार्यक्षमता लागू करने की आवश्यकता होती है।

sequenceDiagram participant User as "उपयोगकर्ता" participant App as "Windows ऐप (C#)" participant API as "Microsoft.Windows.AI" participant OS as "Windows Copilot Runtime" participant ORT as "ONNX Runtime (DML)" participant NPU as "NPU हार्डवेयर" User->>App: "प्रॉम्प्ट दर्ज करें" App->>API: "GenerateResponseStreamAsync()" API->>OS: "अनुमान कार्य डिस्पैच करें" OS->>ORT: "ग्राफ़ निष्पादन अनुरोध" ORT->>NPU: "DirectML के माध्यम से कमांड सूची निष्पादित करें" NPU-->>ORT: "गणना पूर्ण (1 टोकन उत्पन्न)" ORT-->>OS: "टेंसर परिणाम" OS-->>API: "डिकोड किया गया पाठ" API-->>App: "IAsyncEnumerable चंक" App-->>User: "UI पर वास्तविक समय वर्ण आरेखण" Note over ORT,NPU: "पूरा होने तक इस लूप को तेज़ गति से दोहराएँ"

यह अनुक्रम आरेख (sequence diagram) UI थ्रेड को बिल्कुल ब्लॉक किए बिना एसिंक्रोनस प्रोसेसिंग की सुंदरता को दर्शाता है, जहाँ डेटा निम्नतम स्तर के NPU हार्डवेयर से एप्लिकेशन की प्रेजेंटेशन लेयर तक स्ट्रीमिंग की तरह बहता है।

8. भविष्य की संभावनाएँ और Windows AI का विकास

Microsoft.Windows.AI API और Copilot Runtime वर्तमान में तेज़ गति से विकसित हो रहे हैं। भविष्य के डेवलपर अपडेट्स में निम्नलिखित प्रतिमान बदलावों (paradigm shifts) की उम्मीद है:

मल्टीमॉडल API का OS-नेटिव एकीकरण: टेक्स्ट ही नहीं, बल्कि वॉयस, इमेज और यहाँ तक कि लाइव वीडियो फ़ीड को भी निर्बाध रूप से एक साथ प्रोसेस करना, जो OS स्तर पर क्रॉस-मॉडल AI अनुमान को मानक के रूप में प्रदान करेगा।
RAG (Retrieval-Augmented Generation) के लिए सिस्टम-स्तर का समर्थन: स्थानीय PC के भीतर व्यक्तिगत दस्तावेज़ों और Windows Search इंडेक्स को OS के सुरक्षित सैंडबॉक्स में AI मॉडल से जोड़ना, जिससे उपयोगकर्ता की गोपनीयता को पूरी तरह से सुरक्षित रखते हुए एक अति-उन्नत व्यक्तिगत AI असिस्टेंट का निर्माण हो सके।
NPU का डायनेमिक रिसोर्स स्केलिंग: जब कई AI एप्लिकेशन एक साथ चल रहे हों (उदाहरण के लिए, बैकग्राउंड में शोर रद्दीकरण (noise cancellation) और फोरग्राउंड में कोड जनरेशन), तो Windows कर्नेल शेड्यूलर QoS (Quality of Service) की गारंटी देने के लिए NPU के निष्पादन संदर्भ को गतिशील रूप से स्विच करने में सक्षम होगा।

9. निष्कर्ष: भविष्य के एप्लिकेशन जिन्हें स्थानीय AI बदल देगा

Windows 11 के Copilot Runtime और Microsoft.Windows.AI API सभी Windows डेवलपर्स के लिए “स्थानीय AI” का एक अत्यंत शक्तिशाली हथियार लेकर आए हैं। अब क्लाउड API पर पूरी तरह निर्भर रहने की कोई आवश्यकता नहीं है। विलंबता को समाप्त करते हुए और गोपनीयता बनाए रखते हुए उपयोगकर्ताओं को अगली पीढ़ी का AI अनुभव प्रदान करना संभव है जो पूरी तरह से ऑफ़लाइन भी काम करता है।

सिस्टम-मानक भाषा मॉडलों के एकीकरण का उपयोग करें जो इस लेख में C# का उपयोग करके समझाए गए हैं, गणितीय प्रदर्शन मूल्यांकन, और C++ और DirectML का उपयोग करके अत्यधिक हार्डवेयर अनुकूलन के ज्ञान का उपयोग करके अपने स्वयं के हाथों से अगली पीढ़ी के “AI-नेटिव” Windows एप्लिकेशन बनाएँ। AI द्वारा लाई गई अनंत संभावनाएँ उस कोड के ठीक आगे फैली हुई हैं जो आप लिखते हैं।

※नोट: यह लेख सितंबर 2026 तक पूर्वावलोकन API और नवीनतम विशिष्टताओं (specifications) के आधार पर लिखा गया है। चूँकि Windows अपडेट के कारण API विशिष्टताएँ और हार्डवेयर आवश्यकताएँ बदल सकती हैं, इसलिए लागू करते समय कृपया हमेशा आधिकारिक Microsoft Learn दस्तावेज़ देखें।

【2026 का नवीनतम】विंडोज़ वातावरण में लोकल LLM चलाने की संपूर्ण मार्गदर्शिका

Fri, 11 Sep 2026 10:00:00 +0900

1. प्रस्तावना: अब विंडोज़ पर लोकल LLM क्यों?

2026 तक, जनरेटिव AI और लार्ज लैंग्वेज मॉडल (LLM) का विकास एक बड़ा प्रतिमान बदलाव (paradigm shift) दिखा रहा है, जो क्लाउड पर विशाल API सेवाओं से हटकर व्यक्तिगत पीसी और ऑन-प्रिमाइसेस वातावरण में चलने वाले ‘लोकल LLM’ की ओर बढ़ रहा है। OpenAI का GPT-5 और Anthropic का Claude 3.5 जैसे क्लाउड AI बहुत शक्तिशाली हैं, लेकिन कंपनियाँ और व्यक्ति अपना सारा डेटा क्लाउड पर नहीं भेज सकते हैं। गोपनीयता (Privacy), सुरक्षा, विलंबता (latency), और दीर्घकालिक व टिकाऊ लागत के दृष्टिकोण से लोकल LLM की मांग पहले से कहीं अधिक तेजी से बढ़ रही है।

विशेष रूप से विंडोज़ वातावरण में लोकल LLM के इकोसिस्टम का विकास उल्लेखनीय रहा है। कुछ साल पहले तक “AI विकास और निष्पादन (execution) का मतलब Linux है” यह एक सामान्य बात थी, लेकिन 2026 में विंडोज़ एक बहुत ही शक्तिशाली और सुलभ AI प्लेटफॉर्म में बदल गया है।

इस लेख में, 2026 के नवीनतम तकनीकी रुझानों को ध्यान में रखते हुए, विंडोज़ वातावरण में लोकल LLM के निर्माण, संचालन और अनुकूलन (optimization) के लिए एक संपूर्ण मार्गदर्शिका प्रदान की गई है। शुरुआती लोगों के लिए Ollama का उपयोग करके सरल सेटअप से लेकर, उन्नत उपयोगकर्ताओं के लिए llama.cpp का उपयोग करके अत्यधिक अनुकूलन (extreme optimization), VRAM गणना के गणितीय दृष्टिकोण, आर्किटेक्चर की गहरी समझ, और लोकल फाइन-ट्यूनिंग तक, हम इसे विस्तार से समझाएंगे।

1.1 2026 में लोकल LLM के तकनीकी रुझान

वर्तमान लोकल LLM इकोसिस्टम को आकार देने वाले प्रमुख रुझान इस प्रकार हैं:

GGUF फॉर्मेट का पूर्ण उपयोग: GGUF (GPT-Generated Unified Format), जो मेटाडेटा और टेंसर को एक ही फ़ाइल में एकीकृत करता है, अब पूरी तरह से वास्तविक मानक (de facto standard) बन गया है। इसके कारण, केवल Hugging Face से एक फ़ाइल डाउनलोड करके इसे किसी भी वातावरण में चलाना संभव हो गया है।
MoE (Mixture of Experts) आर्किटेक्चर का लोकतंत्रीकरण (Democratization): छोटे लेकिन उच्च-प्रदर्शन वाले कई MoE मॉडल जारी किए गए हैं। अनुमान (inference) के दौरान केवल कुछ विशेषज्ञों (experts) को सक्रिय करके, यह उपभोक्ता पीसी (consumer PC) के कम्प्यूटेशनल भार को कम रखते हुए विशाल मॉडलों के बराबर प्रदर्शन दे रहा है।
इन्फरेंस इंजन (Inference Engine) का उच्च अमूर्तीकरण (Abstraction) और अनुकूलन: Ollama, LM Studio, AnythingLLM जैसे टूल बहुत परिष्कृत हो गए हैं, जिससे उपयोगकर्ताओं को CUDA ड्राइवर इंस्टॉल करने जैसी जटिल निर्भरताओं (dependencies) की चिंता करने की आवश्यकता नहीं है। इसके अलावा, FlashAttention 3 के विंडोज़ नेटिव समर्थन (native support) से इन्फरेंस गति में नाटकीय रूप से सुधार हुआ है।
NPU का उपयोग और Windows Copilot+ PC का उदय: NPU (Neural Processing Unit) का उपयोग करके छोटे LLM (SLM: Small Language Models) को कम बिजली की खपत के साथ चलाने की तकनीक व्यावहारिक चरण में प्रवेश कर चुकी है, यहाँ तक कि उन लैपटॉप में भी जिनमें GPU नहीं है।

2. हार्डवेयर आवश्यकताएँ और OS की तैयारी

लोकल LLM को व्यावहारिक गति (15-30 टोकन प्रति सेकंड या अधिक) पर चलाने के लिए हार्डवेयर का चयन सबसे महत्वपूर्ण है।

2.1 अनुशंसित हार्डवेयर कॉन्फ़िगरेशन

AI PC के विकास के साथ, आवश्यक विनिर्देश (specifications) भी बदल रहे हैं।

OS: Windows 11 Pro (24H2 या बाद का संस्करण)। WSL2 की पूर्ण कार्यक्षमता और उन्नत मेमोरी प्रबंधन, साथ ही नवीनतम DirectML API का उपयोग करने के लिए यह आवश्यक है।
CPU: Intel Core Ultra 200 सीरीज़ या उससे ऊपर, या AMD Ryzen 9000 सीरीज़ या उससे ऊपर। यदि CPU इन्फरेंस का भी उपयोग किया जा रहा है, तो ब्रॉडबैंड मेमोरी कम्युनिकेशन अनिवार्य है।
RAM: न्यूनतम 32GB, 64GB या उससे अधिक अनुशंसित। मुख्य मेमोरी की बैंडविड्थ (MB/s) CPU इन्फरेंस या ऑफलोडिंग के दौरान एक निर्णायक अड़चन (bottleneck) बन जाती है। DDR5-6000 या उच्चतर गति वाली मेमोरी आदर्श है।
GPU: NVIDIA RTX 4000/5000 सीरीज़। लोकल LLM में सबसे महत्वपूर्ण कम्प्यूटेशनल प्रदर्शन नहीं बल्कि “VRAM क्षमता” है।
- एंट्री लेवल: RTX 4060 Ti (16GB संस्करण) - सबसे अच्छा कॉस्ट-परफॉरमेंस। 8B से 14B क्लास के मॉडलों के लिए आदर्श।
- मिड-रेंज: RTX 4070 Ti SUPER (16GB) / RTX 4080 SUPER (16GB)
- हाई-एंड: RTX 4090 (24GB) / RTX 5090 (32GB) - 30B से 70B क्लास के क्वांटाइज्ड मॉडलों (quantized models) को चलाने के लिए आवश्यक।
स्टोरेज: PCIe Gen4 या Gen5 NVMe SSD। यह दसियों GB के मॉडलों के लोड होने के समय को काफी कम कर देता है।

2.2 WSL2 (Windows Subsystem for Linux 2) सेटअप

कई GUI टूल मूल रूप से (natively) विंडोज़ पर काम करते हैं, लेकिन Python का उपयोग करके विकास करने, नवीनतम टूल को संकलित (compile) करने और बाद में बताए गए LoRA फाइन-ट्यूनिंग के लिए WSL2 बहुत उपयोगी है। नवीनतम Windows 11 वातावरण में, केवल होस्ट साइड पर NVIDIA ड्राइवर स्थापित करके WSL2 से पारदर्शी (transparently) रूप से GPU (CUDA) का उपयोग किया जा सकता है।

एडमिनिस्ट्रेटर प्रिविलेज (Administrator privileges) के साथ PowerShell खोलें और निम्नलिखित चलाएँ:

1
2
3
4
5


# WSL2 और नवीनतम Ubuntu इंस्टाल करें
wsl --install -d Ubuntu-24.04

# कर्नेल अपडेट करें
wsl --update

इंस्टॉलेशन के बाद, WSL2 टर्मिनल में nvidia-smi चलाएँ। यदि GPU सही तरीके से पहचाना जाता है, तो यह सफल है।

3. लोकल LLM आर्किटेक्चर और इन्फरेंस मैकेनिज्म

यह समझना कि लोकल वातावरण में मॉडल टेक्स्ट कैसे उत्पन्न करता है और इसकी आंतरिक संरचना क्या है, समस्या निवारण (troubleshooting) और अनुकूलन (optimization) के लिए बहुत उपयोगी है।

नीचे दिया गया Mermaid आरेख एक सामान्य लोकल LLM के इन्फरेंस पाइपलाइन को दर्शाता है।

graph TD User["यूज़र इनपुट (प्रॉम्प्ट)"] --> Tokenizer["टोकेनाइज़र (Tokenizer)"] Tokenizer --> Embedding["एम्बेडिंग लेयर (Embedding)"] subgraph "Transformer Block (x Layers)" Embedding --> Attn["सेल्फ-अटेंशन (Self-Attention)"] Attn --> KVCache["KV कैश (Key/Value स्टोरेज)"] Attn --> FFN["फीड-फॉरवर्ड नेटवर्क (FFN)"] end FFN --> Logits["लॉजिट कैलकुलेशन (Logits)"] Logits --> Sampler["सैंपलर (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["आउटपुट टोकन"] OutputToken --> |"ऑटोरिग्रेसिव जनरेशन"| Tokenizer OutputToken --> Decoder["डिटोकेनाइज़र (Detokenizer)"] Decoder --> FinalOutput["अंतिम आउटपुट टेक्स्ट"]

3.1 2 चरण (Phases): Prefill और Decode

LLM टेक्स्ट जनरेशन को अलग-अलग कम्प्यूटेशनल विशेषताओं वाले दो चरणों में विभाजित किया गया है।

Prefill (प्रॉम्प्ट प्रोसेसिंग) चरण: यह वह चरण है जहाँ पूरे इनपुट प्रॉम्प्ट को एक साथ प्रोसेस किया जाता है और समझा जाता है। चूंकि समानांतर गणना (parallel computation) संभव है, इसलिए GPU की कम्प्यूटेशनल क्षमता (FLOPS) सीधे गति से संबंधित है। यदि प्रॉम्प्ट लंबा है, तो इस चरण में कुछ सेकंड लग सकते हैं।
Decode (टोकन जनरेशन) चरण: यह वह चरण है जो एक-एक करके टोकन की भविष्यवाणी करता है और इसे अगले इनपुट (autoregressive) में भेजता है। इस चरण में समानांतर गणना सीमित है, इसलिए GPU का VRAM बैंडविड्थ (Memory Bandwidth) एक निर्णायक अड़चन (bottleneck) बन जाता है।

4. VRAM खपत की गणना और मॉडल साइज़ की गणितीय समझ

“मेरे पीसी पर कौन सा मॉडल चलेगा?” इसका सही अंदाजा लगाने के लिए, आपको VRAM गणना सूत्र को समझने की आवश्यकता है। जब VRAM की कमी के कारण सिस्टम मेमोरी (RAM) पर फॉलबैक होता है, तो इन्फरेंस की गति 10 से 100 गुना धीमी हो जाती है।

4.1 पैरामीटर आकार के आधार पर बेस VRAM

यह मॉडल वेट (weights) को VRAM में लोड करने के लिए आवश्यक मेमोरी की मात्रा है। इसकी गणना मॉडल आकार $P$ (पैरामीटर्स की संख्या, इकाई: 1 बिलियन = 1B) और प्रति पैरामीटर बाइट्स की संख्या $B$ का उपयोग करके की जाती है।

$$ V_{base} = P \times B \quad \text{(GB)} $$

उदाहरण के लिए, यदि 8B (8 बिलियन) पैरामीटर वाले मॉडल को FP16 (हाफ-प्रिसिजन फ्लोटिंग-पॉइंट, 16 बिट्स = 2 बाइट्स) में लोड किया जाता है:

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

यानी 16GB VRAM वाले GPU में भी केवल मॉडल को लोड करने से ही वह लगभग अपनी सीमा तक पहुँच जाएगा।

4.2 क्वांटाइजेशन (Quantization) का जादू

यहीं पर “क्वांटाइजेशन” आता है। पैरामीटर्स की सटीकता (precision) को कम करके, मॉडल का आकार नाटकीय रूप से कम हो जाता है। सबसे आम 4-बिट क्वांटाइजेशन (उदा: Q4_K_M) के मामले में, यह प्रति पैरामीटर औसतन लगभग 0.55 बाइट्स होता है।

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

इस प्रकार, 16GB VRAM के साथ, आप 8B मॉडल को बहुत आसानी से चला सकते हैं।

4.3 KV कैश की गणना (GQA समर्थित संस्करण)

इन्फरेंस के दौरान, पिछले संदर्भ (context) को बनाए रखने के लिए “KV कैश” VRAM की खपत करता है। Llama 3 जैसे नवीनतम मॉडलों में मेमोरी बचाने के लिए GQA (Grouped Query Attention) का उपयोग किया जाता है।

KV कैश की खपत $V_{kv}$ (गीगाबाइट में) निम्नलिखित सूत्र द्वारा व्यक्त की जा सकती है:

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

इसे सरल करते हुए, हम की (key) और वैल्यू (value) के हेड्स की संख्या $h_{kv}$ का उपयोग करके आसानी से गणना कर सकते हैं:

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

जहाँ:

$b$: बैच साइज़ (व्यक्तिगत लोकल उपयोग के लिए आमतौर पर 1)
$s$: सीक्वेंस लंबाई (संदर्भ लंबाई, उदा: 8192)
$l$: लेयर्स की संख्या (उदा: 32)
$h_{kv}$: KV हेड्स की संख्या (उदा: 8)
$d$: प्रति हेड डायमेंशन (उदा: 128)
$B_{kv}$: KV कैश के बाइट्स (FP16 के लिए 2)

गणना का उदाहरण (Llama 3 8B, कॉन्टेक्स्ट 8192, FP16 कैश): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

ध्यान दें कि संदर्भ की लंबाई $s$ जितनी लंबी होगी, आवश्यक VRAM उतना ही अधिक रैखिक (linearly) रूप से बढ़ेगा।

5. अभ्यास 1: Ollama का उपयोग करके सबसे तेज़ और सबसे छोटा सेटअप

अब जब हम थ्योरी समझ चुके हैं, तो आइए वास्तव में विंडोज़ वातावरण में LLM चलाएं। 2026 तक, “Ollama” सबसे यूज़र-फ्रेंडली टूल है। यह Docker की तरह ही एक बहुत ही सहज (intuitive) CLI प्रदान करता है।

5.1 इंस्टालेशन और रन (Installation and Execution)

Ollama आधिकारिक वेबसाइट से विंडोज़ इंस्टॉलर डाउनलोड करें और इसे चलाएं।
PowerShell खोलें और निम्नलिखित कमांड दर्ज करें। यहाँ, हम जापानी समर्थित llama3:8b का उपयोग करेंगे।

1

ollama run llama3:8b

पहली बार चलाने पर, मॉडल डाउनलोड होगा। इसके पूरा होने के बाद, आप सीधे टर्मिनल में चैट कर सकते हैं।

5.2 Modelfile का उपयोग करके कस्टम AI बनाना

आप आसानी से एक विशिष्ट व्यक्तित्व (persona) वाला AI बना सकते हैं। किसी भी स्थान पर एक Modelfile बनाएं।

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
आप एक अत्यंत प्रतिभाशाली सीनियर सॉफ्टवेयर इंजीनियर हैं।
उपयोगकर्ता के प्रश्नों का उत्तर हमेशा कोड उदाहरणों के साथ तार्किक और संक्षिप्त रूप में दें।
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

अपने स्वयं के मॉडल को बिल्ड (build) करने और चलाने के लिए निम्नलिखित कमांड चलाएँ:

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 बाहरी ऐप्स (AI संपादक) से उपयोग

Ollama http://localhost:11434 पर OpenAI संगत API एंडपॉइंट को एक्सपोज़ करता है। Cursor या Continue.dev जैसे VS Code एक्सटेंशन के बैकएंड सेटिंग्स में उपरोक्त URL निर्दिष्ट करके और मॉडल के नाम के रूप में SeniorDev आदि निर्दिष्ट करके, आपको मुफ्त में एक शक्तिशाली लोकल कोडिंग असिस्टेंट मिल जाता है।

6. अभ्यास 2: llama.cpp के साथ अत्यधिक प्रदर्शन ट्यूनिंग (Extreme Performance Tuning)

यदि आप विस्तृत मेमोरी प्रबंधन चाहते हैं या नवीनतम फॉर्मेट्स (जैसे EXL2 और IQ क्वांटाइजेशन) को जल्दी आज़माना चाहते हैं, तो कोर इंजन llama.cpp का सीधे उपयोग करें।

6.1 llama.cpp के लिए बिल्ड प्रक्रिया

विंडोज़ वातावरण में, CUDA Toolkit और CMake का उपयोग करके स्रोत (source) से बिल्ड करना सबसे अच्छा तरीका है।

1
2
3
4
5
6
7
8


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build

# CUDA सपोर्ट के लिए कॉन्फ़िगर और कंपाइल करें
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 सर्वर मोड में एडवांस स्टार्टअप

मॉडल को होस्ट करने के लिए बिल्ड किए गए llama-server.exe का उपयोग करें।

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99: जहाँ तक संभव हो सभी लेयर्स को GPU VRAM में ऑफलोड करता है।
--flash-attn: FlashAttention 3 को सक्षम करता है, इन्फरेंस गति में सुधार करता है और KV कैश की VRAM खपत को कम करता है।

7. GUI फ्रंटएंड: LM Studio और लोकल RAG का निर्माण

यदि आप कमांड लाइन का उपयोग नहीं करना चाहते हैं या RAG (Retrieval-Augmented Generation) को सहजता (intuitively) से करना चाहते हैं, तो GUI का उपयोग करें।

7.1 LM Studio

LM Studio एक बेहतरीन एप्लिकेशन है जो मॉडल सर्च, डाउनलोड, सिस्टम आवश्यकता पूर्व-जाँच और चैट UI को एक जगह मिलाता है। ऐप में “Local Server” बटन दबाने से ही OpenAI संगत API शुरू हो जाता है।

7.2 AnythingLLM का उपयोग करके RAG आर्किटेक्चर

यहाँ RAG वातावरण का एक आर्किटेक्चर आरेख है जो आपके आंतरिक दस्तावेजों या व्यक्तिगत नोट्स को पढ़ सकता है:

graph LR Document["डॉक्यूमेंट (PDF, MD)"] --> Chunking["चंकिंग (Chunking)"] Chunking --> EmbedModel["एम्बेडिंग मॉडल (Embedding Model)"] EmbedModel --> VectorDB["वेक्टर डेटाबेस (Vector Database)"] UserQuery["यूज़र की क्वेरी (User Query)"] --> EmbedQuery["क्वेरी एम्बेडिंग (Query Embedding)"] EmbedQuery --> VectorDB VectorDB --> |"समानता खोज (Similarity Search)"| RetrievedDocs["संबंधित डॉक्यूमेंट्स निकालना"] UserQuery --> PromptBuilder["प्रॉम्प्ट निर्माण (Prompt Builder)"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["लोकल LLM"] LocalLLM --> Answer["अंतिम उत्तर (Final Answer)"]

AnythingLLM डेस्कटॉप संस्करण (विंडोज़) का उपयोग करके, बस सेटिंग स्क्रीन से Ollama (LLM और Embedding) निर्दिष्ट करें, और इसे लोकल VectorDB (LanceDB) का उपयोग करने के लिए सेट करें। केवल कुछ मिनटों में यह आर्किटेक्चर तैयार हो जाता है। यह एक ऐसा प्राइवेट AI बनाता है जो बाहरी रूप से कोई डेटा नहीं भेजता है।

8. Windows WSL2 पर फाइन-ट्यूनिंग (LoRA)

यदि आप मॉडल को न केवल लोकल रूप से चलाना चाहते हैं बल्कि अपने स्वयं के डेटा के साथ इसे और स्मार्ट बनाना चाहते हैं, तो आप LoRA (Low-Rank Adaptation) का उपयोग करके फाइन-ट्यूनिंग कर सकते हैं। 2026 तक, “Unsloth” नामक एक लाइब्रेरी का उपयोग करके, विंडोज़ के WSL2 वातावरण में, 16GB VRAM वाले 8B मॉडल की ट्रेनिंग कुछ ही घंटों में पूरी की जा सकती है।

वातावरण सेट करने के लिए WSL2 Ubuntu में निम्नलिखित चलाएँ:

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Unsloth ने CUDA कर्नेल को चरम सीमा तक अनुकूलित (optimize) किया है, मानक Hugging Face लाइब्रेरी की तुलना में ट्रेनिंग गति को दोगुना कर दिया है और VRAM की खपत को आधा कर दिया है। बस Jupyter Notebook शुरू करें और डेटासेट (JSONL प्रारूप) लोड करें, और कुछ ही एपोक (epochs) की ट्रेनिंग RTX 4060 Ti जैसे 12GB से 16GB VRAM वाले GPU पर संभव है।

9. परफॉरमेंस ट्रबलशूटिंग (Performance Troubleshooting)

यहाँ कुछ सामान्य समस्याएं और उनके समाधान दिए गए हैं:

1. इन्फरेंस की गति बहुत धीमी है (1 से 2 टोकन/सेकंड)

कारण: मॉडल VRAM में फिट नहीं हो रहा है और सिस्टम मेमोरी (RAM) पर ऑफलोड हो रहा है। समाधान: टास्क मैनेजर में “Dedicated GPU memory” चेक करें। यदि यह सीमा तक पहुँच गया है, तो कॉन्टेक्स्ट साइज़ (-c) कम करें या कम बिट वाले क्वांटाइज्ड मॉडल (जैसे Q4_K_M) का उपयोग करें।

2. “CUDA out of memory” एरर

कारण: VRAM पूरी तरह से खत्म हो गया है। ऐसा अक्सर तब होता है जब चैट लंबी हो जाती है और KV कैश बहुत बड़ा हो जाता है। समाधान: जानबूझकर मान को कम करें; Ollama के मामले में num_ctx, या llama.cpp के मामले में -c का मान कम करें।

3. टेक्स्ट जनरेशन (विशेषकर जापानी या हिंदी) अजीब है

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

10. निष्कर्ष और भविष्य की संभावनाएं

2026 में, विंडोज़ वातावरण में लोकल LLM का निर्माण अब केवल कुछ इंजीनियरों का विशेषाधिकार नहीं रह गया है। GGUF फॉर्मेट के वास्तविक मानक (de facto standard) बनने, Ollama और LM Studio जैसे परिष्कृत इकोसिस्टम के उदय, और FlashAttention जैसे हार्डवेयर ऑप्टिमाइज़ेशन के कारण, अब कोई भी आसानी से एंटरप्राइज़-ग्रेड AI वातावरण प्राप्त कर सकता है।

कृपया इस लेख में बताए गए निम्नलिखित बिंदुओं का उपयोग करें:

VRAM की गणितीय गणना का उपयोग करके तार्किक रूप से अपने पीसी विनिर्देशों (specs) के लिए इष्टतम मॉडल आकार और क्वांटाइजेशन स्तर चुनें।
Ollama का उपयोग करके सबसे तेज़ वातावरण सेटअप करें, और अपनी उत्पादकता बढ़ाने के लिए इसे AI एडिटर के साथ एकीकृत (integrate) करें।
llama.cpp के उन्नत पैरामीटर नियंत्रण के साथ हार्डवेयर के चरम प्रदर्शन को प्राप्त करें।
गोपनीय डेटा को संभालने के लिए AnythingLLM के साथ एक सुरक्षित लोकल RAG सिस्टम बनाएं।
अपना खुद का कस्टम AI बनाने के लिए Unsloth (WSL2) का उपयोग करें जिसमें विशेष ज्ञान हो।

AI का “लोकतंत्रीकरण” अब सिर्फ एक चर्चा का शब्द (buzzword) नहीं है, बल्कि एक वास्तविक प्रणाली है जो आपके विंडोज़ डेस्कटॉप पर चलती है। क्लाउड API उपयोग की लागतों और सूचना रिसाव (information leakage) के जोखिमों से मुक्त होकर, अभी स्वतंत्र और शक्तिशाली प्राइवेट AI की दुनिया में कदम रखें।