Windows on kenji.blog

Contoh Penggunaan API Terbaru dan Kode Sampel Microsoft.Windows.AI

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

Contoh Penggunaan API Terbaru dan Kode Sampel Microsoft.Windows.AI: Menyelami Kedalaman Windows Copilot Runtime

1. Pendahuluan: Era Baru Windows di Mana AI Terintegrasi Secara Asli

Dalam beberapa tahun terakhir, evolusi teknologi AI sangat luar biasa, dan telah terjadi pergeseran paradigma yang cepat dari pemanfaatan model bahasa besar (LLM) di cloud menuju inferensi AI pada perangkat edge (PC lokal). Inti dari hal ini adalah “Windows Copilot Runtime” yang disediakan oleh Microsoft untuk Windows 11, dan API “Microsoft.Windows.AI” untuk mengoperasikannya.

Pengembangan aplikasi menggunakan API cloud (seperti OpenAI atau Azure OpenAI) memang mudah, namun selalu diiringi dengan tantangan terkait latensi, privasi, dan biaya yang berkelanjutan. Di sisi lain, dengan menjalankan model AI secara lokal, Anda dapat mewujudkan aplikasi dengan latensi yang sangat rendah yang berfungsi bahkan saat offline, tanpa perlu mengirimkan data sensitif keluar dari perangkat.

Artikel ini memberikan panduan yang sangat mendetail mengenai metode implementasi fitur AI lokal, yang akan menjadi keharusan dalam pengembangan aplikasi Windows di masa depan, lengkap dengan contoh kode praktis dalam C# dan C++, mulai dari arsitektur hingga penyesuaian performa. Kami tidak hanya sekadar memanggil API, tetapi juga akan mendalami detail teknis tingkat lanjut seperti pemanfaatan perangkat keras di baliknya (NPU dan GPU), serta integrasinya dengan DirectML.

2. Gambaran Umum Arsitektur dan Windows Copilot Runtime

Windows Copilot Runtime adalah serangkaian tumpukan AI yang dirancang agar pengembang dapat dengan mudah mengintegrasikan model AI pada Windows, sekaligus mendapatkan performa terbaik. Runtime ini mengabstraksi akselerasi perangkat keras pada tingkat OS dan menyediakan antarmuka terpadu bagi para pengembang.

graph TD App["Aplikasi Windows (C# / C++)"] --> API["API Microsoft.Windows.AI"] App --> ORT["ONNX Runtime"] API --> WCR["Windows Copilot Runtime (Lapisan OS)"] WCR --> SLM["Model Lokal (Phi-Silica, dll.)"] ORT --> DML["Penyedia Eksekusi DirectML"] SLM --> DML DML --> DXCore["DXCore / DirectX 12"] DXCore --> NPU["NPU (Unit Pemrosesan Saraf)"] DXCore --> GPU["GPU (Unit Pemrosesan Grafis)"] DXCore --> CPU["CPU"]

Seperti yang ditunjukkan pada diagram arsitektur di atas, aplikasi dapat mengakses secara langsung model bahasa berskala kecil (SLM: seperti Phi-Silica) yang tertanam dalam OS dengan menggunakan API Microsoft.Windows.AI tingkat tinggi. Selain itu, saat menggunakan model kustom, dimungkinkan juga untuk secara eksplisit memanfaatkan akselerasi perangkat keras melalui ONNX Runtime dan DirectML. Karena lapisan OS mengoptimalkan distribusi beban kerja ke CPU, GPU, dan NPU, pengembang dapat membangun aplikasi AI berkinerja tinggi tanpa perlu terlalu menyadari perbedaan perangkat keras.

3. Evaluasi Matematis Akselerasi Perangkat Keras dan NPU

PC Copilot+ terbaru dilengkapi dengan NPU (Neural Processing Unit), yaitu prosesor yang dikhususkan untuk pemrosesan AI. Performa NPU umumnya dievaluasi dalam TOPS (Tera Operations Per Second).

Dalam inferensi model AI, khususnya kemampuan komputasi Perkalian Matriks Umum (GEMM: General Matrix Multiply) sangat menentukan throughput. Performa puncak teoritis dari perangkat keras $P_{\text{peak}}$ diperkirakan dengan rumus berikut:

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

Di mana:

$f$ adalah frekuensi clock NPU (Hz)
$N_{\text{cores}}$ adalah jumlah core di dalam NPU
$N_{\text{MACs/core}}$ adalah jumlah unit MAC (Multiply-Accumulate) per core
Angka $2$ di bagian akhir dikarenakan satu operasi MAC dihitung sebagai dua operasi (FLOPs/OPs) yaitu perkalian dan penjumlahan.

Sebagai contoh, untuk NPU dengan frekuensi 1.5GHz, 4 core, dan masing-masing core memiliki 4096 MACs,

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

Secara matematis telah ditunjukkan bahwa performa ini memenuhi persyaratan PC Copilot+ Windows 11 yaitu 40 TOPS.

Selain itu, inferensi model AI, terutama untuk LLM (fase dekode), cenderung mengalami keterbatasan memori (Memory-Bound). Bandwidth teoritis memori sistem $BW$ dihitung sebagai berikut:

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

Untuk memori LPDDR5x-8533 ($f_{\text{mem}} = 8533 \text{ MT/s}$) dan bus 128-bit ($W_{\text{bus}} = 128$), bandwidth-nya adalah sekitar $136 \text{ GB/s}$. Dalam pengoptimalan aplikasi AI, cara menghemat bandwidth ini sangatlah penting, sehingga Kuantisasi (Quantization) model yang akan dijelaskan nanti menjadi hal yang sangat krusial.

4. Pengaturan Lingkungan Pengembangan

Untuk menggunakan API Windows AI terbaru, Anda perlu menyiapkan lingkungan dan rantai alat (toolchain) berikut.

OS: Windows 11 versi 24H2 atau yang lebih baru (Sangat disarankan perangkat yang dilengkapi NPU dan memenuhi persyaratan PC Copilot+)
SDK: Windows App SDK (versi yang mendukung ekstensi AI, v1.5 atau yang lebih baru)
Lingkungan Pengembangan: Visual Studio 2022 (v17.10 atau yang lebih baru), dengan beban kerja pengembangan asli C++ dan pengembangan desktop .NET
Paket: Instal Microsoft.Windows.AI dan Microsoft.ML.OnnxRuntime.DirectML melalui NuGet

1
2
3
4
5
6


<!-- Contoh pengaturan .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] Memanfaatkan Model Bahasa Lokal (Phi-Silica) Menggunakan C#

Windows Copilot Runtime mencakup “Phi-Silica”, sebuah model bahasa skala kecil dengan efisiensi tinggi yang dikembangkan oleh Microsoft, sebagai komponen standar OS. Hal ini memungkinkan pemrosesan bahasa alami tingkat lanjut (peringkasan teks, pembuatan kode, chatbot) dalam lingkungan offline tanpa harus mengunduh model berukuran gigabyte dari jaringan.

Berikut ini adalah contoh kode tingkat lanjut untuk membangun AI obrolan menggunakan C# dengan memanfaatkan namespace Microsoft.Windows.AI.Generative. Kode ini mendukung respons streaming dan menghasilkan teks secara real-time tanpa memblokir utas (thread) 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>
 /// Melakukan inisialisasi model bahasa. Memeriksa ketersediaan NPU dan memuat model ke perangkat yang optimal.
 /// </summary>
 public async Task InitializeAsync()
 {
 if (_isInitialized) return;

 Console.WriteLine("Memeriksa persyaratan sistem dan ketersediaan model AI lokal (Phi-Silica)...");

 // Memeriksa apakah model tersedia di sistem (jika tidak didukung, unduhan mungkin akan diminta)
 var availability = await LanguageModel.CheckAvailabilityAsync();
 if (availability != LanguageModelAvailability.Available)
 {
 throw new InvalidOperationException($"Model AI lokal saat ini tidak tersedia. Status: {availability}");
 }

 // Membuat instans model (pada titik ini, pemetaan ke ruang memori dan inisialisasi NPU akan dilakukan)
 _languageModel = await LanguageModel.CreateAsync();
 _isInitialized = true;

 Console.WriteLine("Inisialisasi model bahasa telah selesai. Akselerasi perangkat keras melalui DirectML aktif.");
 }

 /// <summary>
 /// Menerima prompt pengguna dan menghasilkan respons secara streaming.
 /// </summary>
 public async Task GenerateResponseStreamAsync(string prompt, CancellationToken cancellationToken)
 {
 if (!_isInitialized) await InitializeAsync();

 Console.WriteLine($"\n[Input Pengguna]: {prompt}\n[Asisten AI]: ");

 // Mengatur hyperparameter saat inferensi
 var options = new LanguageModelOptions
 {
 Temperature = 0.7f,
 TopP = 0.9f,
 MaxTokens = 2048,
 RepetitionPenalty = 1.1f
 };

 // Membangun konteks percakapan
 var context = new LanguageModelContext();
 context.AddSystemMessage("Anda adalah asisten AI tingkat lanjut yang berjalan langsung di NPU lokal Windows. Berpikirlah secara logis selangkah demi selangkah, dan jawablah dengan singkat.");
 context.AddUserMessage(prompt);

 try
 {
 // Pemanggilan API inferensi streaming
 var responseStream = _languageModel.GenerateResponseStreamAsync(context, options);

 // Memproses potongan-potongan (chunk) yang dikembalikan sebagai IAsyncEnumerable secara asinkron
 await foreach (var chunk in responseStream.WithCancellation(cancellationToken))
 {
 // Menampilkan token (chunk) yang dihasilkan ke konsol secara real-time
 // Untuk aplikasi UI, gunakan DispatcherQueue di sini untuk menerapkannya ke TextBox, dll.
 Console.Write(chunk.Text);
 }
 Console.WriteLine();
 }
 catch (OperationCanceledException)
 {
 Console.WriteLine("\n[Pembuatan dibatalkan oleh pengguna atau sistem]");
 }
 catch (Exception ex)
 {
 Console.WriteLine($"\n[Terjadi kesalahan fatal: {ex.Message}]");
 }
 }
 }
}

5.1 Penjelasan Arsitektur pada Implementasi C#

Inti dari kode ini adalah verifikasi prapelaksanaan oleh LanguageModel.CheckAvailabilityAsync() dan pembuatan streaming asinkron oleh GenerateResponseStreamAsync. Saat Copilot Runtime yang berjalan di latar belakang OS menerima panggilan API ini, ia secara internal meluncurkan ONNX Runtime dan memilih Execution Provider yang optimal (untuk banyak PC terbaru, DirectML + NPU) berdasarkan konfigurasi sistem.

Pengembang tidak perlu memikirkan bentuk tensor model, implementasi tokenizer, atau manajemen memori KV cache sama sekali, dan dapat mengintegrasikan alur inferensi AI mutakhir ke dalam aplikasi hanya dengan beberapa baris kode C#.

6. [Deep Dive 2] Inferensi Berkecepatan Tinggi dari Model Kustom Menggunakan C++ dan DirectML

Saat menangani domain tertentu (seperti segmentasi gambar eksklusif, pengenalan suara, model deteksi objek kustom, dll.) yang tidak dapat dicakup hanya oleh model bahasa standar OS, pengembang perlu berinteraksi langsung dengan ONNX Runtime dan DirectML yang berada di lapisan bawah Microsoft.Windows.AI.

Dengan menggunakan C++, manajemen memori dapat dioptimalkan secara ekstrem untuk mendapatkan performa puncak dari NPU/GPU. Berikut adalah implementasi inti dari inisialisasi tingkat lanjut dan alur inferensi untuk mengeksekusi model kustom format ONNX (misalnya: YOLOv8) dalam C++ menggunakan DirectML.

 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;
 // Optimasi jumlah thread
 sessionOptions.SetIntraOpNumThreads(1);
 // Mengatur tingkat optimasi graf secara maksimum
 sessionOptions.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);

 // 1. Penambahan DirectML Execution Provider (DML EP)
 // device_id = 0 adalah adaptor yang disarankan default sistem (NPU atau GPU berkinerja tinggi)
 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 berhasil dilampirkan." << std::endl;
 } else {
 std::cerr << "[Peringatan] Gagal mendapatkan DirectML API. Berjalan dalam mode fallback CPU." << std::endl;
 if (status != nullptr) ortApi.ReleaseStatus(status);
 }

 // 2. Memuat model dan membuat sesi
 try {
 session = Ort::Session(env, modelPath.c_str(), sessionOptions);
 std::cout << "[Info] Berhasil memuat model ONNX dan graf komputasi telah dikompilasi." << std::endl;
 } catch (const Ort::Exception& e) {
 std::cerr << "[Error] Gagal memuat model: " << e.what() << std::endl;
 throw;
 }
 }

 void RunInference(const std::vector<float>& imageTensor, const std::vector<int64_t>& inputShape) {
 // 3. Pembuatan buffer untuk tensor input
 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. Pengambilan nama node input/output secara dinamis
 auto inputNamePtr = session.GetInputNameAllocated(0, allocator);
 auto outputNamePtr = session.GetOutputNameAllocated(0, allocator);
 const char* inputNames[] = { inputNamePtr.get() };
 const char* outputNames[] = { outputNamePtr.get() };

 // 5. Eksekusi inferensi (di-offload ke NPU/GPU melalui DirectML)
 std::cout << "[Info] Memulai eksekusi mesin inferensi..." << 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. Pengambilan dan analisis tensor hasil
 float* outputData = outputTensors.front().GetTensorMutableData<float>();
 size_t outputSize = outputTensors.front().GetTensorTypeAndShapeInfo().GetElementCount();

 std::cout << "[Hasil] Inferensi selesai: " << duration.count() << " md" << std::endl;
 std::cout << "[Hasil] Jumlah elemen dari tensor output: " << outputSize << std::endl;
 // ※Setelah ini, menerapkan pemrosesan NMS (Non-Maximum Suppression) dan penggambaran kotak pembatas (bounding box) untuk tensor output
 }
};

int main() {
 try {
 // Jalur model ONNX yang akan dieksekusi
 CustomVisionAIProcessor processor(L"models/yolov8n_quantized.onnx");

 // Data gambar buatan untuk inferensi (Batch Size 1 x 3 Channels 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 << "Program ditutup secara tidak normal: " << e.what() << std::endl;
 return -1;
 }
 return 0;
}

6.1 Pentingnya Manajemen Memori dan Inferensi Zero-Copy dalam C++

Keuntungan terbesar menggunakan DirectML di C++ adalah kemampuannya untuk berintegrasi secara erat dengan DirectX 12 (DX12). Kode di atas menyertakan penyalinan data dari memori CPU standar untuk tujuan edukasi, tetapi dalam aplikasi mesin game atau pemrosesan video yang sebenarnya, ada banyak kasus di mana gambar (texture) sudah disimpan dalam ruang memori GPU atau NPU menggunakan DX12.

Dalam hal ini, Anda dapat memanfaatkan fungsionalitas binding tingkat lanjut dari OrtDmlApi untuk secara langsung memetakan sumber daya DX12 sebagai tensor ONNX Runtime guna mewujudkan “Inferensi Zero-Copy”. Hal ini sepenuhnya mengeliminasi biaya tambahan transfer data antar bus PCIe (konsumsi bandwidth $BW$ yang telah disebutkan sebelumnya), dan secara dramatis meningkatkan frame rate dalam pemrosesan video real-time.

7. Optimasi Performa dan Praktik Terbaik

Berikut ini adalah ringkasan strategi pengoptimalan yang sangat penting ketika mengembangkan aplikasi AI kelas atas dengan memanfaatkan Windows AI API dan DirectML.

7.1 Kuantisasi Model (Quantization) dan Olive Toolkit

Untuk mengeluarkan kekuatan sejati NPU, sebuah keharusan mutlak untuk mengkuantisasi bobot dan aktivasi model AI dari FP32 (presisi tunggal floating-point) ke INT8 atau INT4. Arsitektur NPU sangat dioptimalkan untuk operasi bilangan bulat, dan bila dibandingkan dengan FP32, INT8 secara teoritis dapat memberikan throughput 4 kali lebih besar dengan efisiensi daya yang jauh lebih tinggi.

Dengan menggunakan toolchain Olive (ONNX Live) yang disediakan oleh Microsoft, Anda dapat mengoptimalkan model seperti PyTorch secara otomatis untuk lingkungan Windows. Olive sangat mendukung pengoptimalan atensi (attention) khusus untuk model Transformer serta kompilasi graf per perangkat keras.

7.2 Trade-off antara Pemrosesan Batch vs Streaming Interaktif

Dalam pemanggilan API, menggabungkan beberapa permintaan inferensi untuk pemrosesan batch dapat meningkatkan efisiensi komputasi NPU. Namun, dalam antarmuka pengguna interaktif seperti chatbot, waktu hingga token pertama ditampilkan (TTFT: Time To First Token) lebih menentukan pengalaman pengguna (UX) dibandingkan dengan throughput. Oleh karena itu, dalam desain UI interaktif, pengaturan ukuran batch ke 1 dan memprioritaskan pembuatan streaming adalah praktik terbaik.

7.3 Sinkronisasi dengan Tugas Latar Belakang dan OS

Inferensi AI menghabiskan banyak daya lokal dan sumber daya sistem. Dengan berintegrasi bersama App Lifecycle API Windows, aplikasi diharuskan untuk menunda (Suspend) tugas inferensi berprioritas rendah atau membatasi konsumsi sumber daya saat berjalan di latar belakang.

sequenceDiagram participant User as "Pengguna" participant App as "Aplikasi Windows (C#)" participant API as "Microsoft.Windows.AI" participant OS as "Windows Copilot Runtime" participant ORT as "ONNX Runtime (DML)" participant NPU as "Perangkat Keras NPU" User->>App: "Memasukkan prompt" App->>API: "GenerateResponseStreamAsync()" API->>OS: "Pengiriman tugas inferensi" OS->>ORT: "Permintaan eksekusi graf" ORT->>NPU: "Eksekusi daftar perintah melalui DirectML" NPU-->>ORT: "Komputasi selesai (pembuatan 1 token)" ORT-->>OS: "Tensor hasil" OS-->>API: "Teks yang didekodekan" API-->>App: "Chunk IAsyncEnumerable" App-->>User: "Penggambaran teks real-time di UI" Note over ORT,NPU: "Mengulang loop ini dengan kecepatan tinggi sampai selesai"

Diagram sekuensial ini menunjukkan keindahan pemrosesan asinkron, di mana data mengalir tanpa henti dari perangkat keras NPU paling bawah ke lapisan presentasi aplikasi, tanpa memblokir utas (thread) UI sama sekali.

8. Prospek Masa Depan dan Evolusi AI Windows

API Microsoft.Windows.AI dan Copilot Runtime terus berkembang pesat secara progresif. Pergeseran paradigma berikut ini diharapkan dalam pembaruan masa depan untuk pengembang:

Integrasi OS asali untuk API multimoda: Memproses secara sinkron dan tanpa hambatan bukan hanya teks, tetapi juga audio, gambar, dan bahkan siaran video langsung, untuk menyediakan inferensi AI lintas moda secara standar di tingkat OS.
Dukungan tingkat sistem untuk RAG (Retrieval-Augmented Generation): Menghubungkan kumpulan dokumen pribadi dalam PC lokal atau indeks Pencarian Windows (Windows Search) dengan model AI di dalam kotak pasir OS yang aman, untuk membangun asisten AI pribadi yang sangat mutakhir dengan perlindungan privasi yang sempurna.
Penskalaan sumber daya NPU yang dinamis: Ketika beberapa aplikasi AI berjalan secara bersamaan (misalnya, pembatalan kebisingan di latar belakang dan pembuatan kode di latar depan), penjadwal kernel Windows akan mengganti konteks eksekusi NPU secara dinamis untuk menjamin Quality of Service (QoS).

9. Kesimpulan: Masa Depan Aplikasi yang Diubah oleh AI Lokal

Copilot Runtime Windows 11 dan API Microsoft.Windows.AI telah membawa senjata “AI Lokal” yang sangat tangguh bagi semua pengembang Windows. Anda tidak lagi harus bergantung sepenuhnya pada API cloud. Sangat mungkin untuk menawarkan kepada pengguna sebuah pengalaman AI generasi mendatang yang menghilangkan latensi dan sangat melindungi privasi, sekaligus mampu beroperasi penuh bahkan tanpa koneksi internet (offline).

Dengan menerapkan pengintegrasian model bahasa standar sistem menggunakan C#, evaluasi performa matematis, serta pengetahuan tentang pengoptimalan perangkat keras ekstrem menggunakan C++ dan DirectML yang dijelaskan dalam artikel ini, Anda dapat menciptakan aplikasi Windows “Asli AI” (AI-native) generasi berikutnya dengan tangan Anda sendiri. Potensi tak terbatas yang ditawarkan oleh AI menanti tepat di balik kode yang Anda tulis.

※Catatan: Artikel ini ditulis berdasarkan versi pratinjau API dan spesifikasi terbaru pada bulan September 2026. Karena spesifikasi API dan persyaratan perangkat keras dapat berubah melalui pembaruan Windows, pastikan untuk selalu mengacu pada dokumentasi resmi Microsoft Learn saat melakukan implementasi.

【Terbaru 2026】Panduan Lengkap Menjalankan LLM Lokal di Lingkungan Windows

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

1. Pendahuluan: Mengapa LLM Lokal di Windows Sekarang?

Pada tahun 2026, evolusi AI Generatif dan Large Language Models (LLM) menunjukkan pergeseran paradigma besar dari layanan API raksasa di cloud ke “LLM lokal” yang berjalan di PC pribadi atau lingkungan on-premise. AI cloud seperti GPT-5 dari OpenAI dan Claude 3.5 dari Anthropic sangat kuat, namun tidak semua perusahaan atau individu dapat mengirimkan seluruh data mereka ke cloud. Dari perspektif privasi, keamanan, latensi, serta biaya jangka panjang dan berkelanjutan, permintaan untuk LLM lokal meningkat pesat seperti yang belum pernah terjadi sebelumnya.

Khususnya di lingkungan Windows, evolusi ekosistem LLM lokal sangat luar biasa. Hingga beberapa tahun yang lalu, menjadi rahasia umum bahwa “pengembangan dan eksekusi AI sama dengan Linux”, tetapi pada tahun 2026, Windows telah bertransformasi menjadi platform AI yang sangat kuat dan mudah digunakan.

Artikel ini memberikan panduan lengkap untuk membangun, mengoperasikan, dan mengoptimalkan LLM lokal di lingkungan Windows, berdasarkan tren teknologi terbaru tahun 2026. Mulai dari pengaturan sederhana menggunakan Ollama untuk pemula, optimasi ekstrem memanfaatkan llama.cpp untuk pengguna tingkat lanjut, hingga pemahaman mendalam tentang arsitektur dan pendekatan matematis perhitungan VRAM, serta fine-tuning lokal, kami akan menjelaskannya secara menyeluruh dengan volume yang melimpah.

1.1 Tren Teknologi Seputar LLM Lokal Tahun 2026

Tren utama yang membentuk ekosistem LLM lokal saat ini adalah sebagai berikut:

Adopsi Penuh Format GGUF: GGUF (GPT-Generated Unified Format), yang mengintegrasikan metadata dan tensor ke dalam satu file, telah sepenuhnya menjadi standar de facto. Ini memungkinkan eksekusi di lingkungan mana pun hanya dengan mengunduh satu file dari Hugging Face.
Demokratisasi Arsitektur MoE (Mixture of Experts): Banyak model MoE berskala kecil namun berkinerja tinggi telah dirilis. Dengan hanya mengaktifkan beberapa “ahli” selama inferensi, ini mencapai kinerja yang sebanding dengan model raksasa sambil menekan beban komputasi PC konsumen.
Abstraksi dan Optimasi Lanjutan dari Mesin Inferensi: Alat seperti Ollama, LM Studio, dan AnythingLLM telah disempurnakan, sehingga pengguna tidak perlu lagi peduli dengan dependensi kompleks seperti instalasi driver CUDA. Selain itu, dengan dukungan asli Windows untuk FlashAttention 3, kecepatan inferensi meningkat secara dramatis.
Pemanfaatan NPU dan Kemunculan PC Windows Copilot+: Bahkan pada laptop tanpa GPU, teknologi yang menggunakan NPU (Neural Processing Unit) bawaan untuk menjalankan LLM skala kecil (SLM: Small Language Models) dengan konsumsi daya rendah telah mencapai tahap praktis.

2. Persyaratan Perangkat Keras dan Persiapan OS

Untuk menjalankan LLM lokal pada kecepatan yang praktis (15-30 token atau lebih per detik), pemilihan perangkat keras adalah yang paling penting.

2.1 Konfigurasi Perangkat Keras yang Disarankan

Seiring dengan evolusi PC AI, spesifikasi yang dibutuhkan juga berubah.

OS: Windows 11 Pro (24H2 atau lebih baru). Diperlukan untuk memanfaatkan fungsionalitas penuh WSL2, manajemen memori tingkat lanjut, dan API terbaru dari DirectML.
CPU: Intel Core Ultra seri 200 ke atas, atau AMD Ryzen seri 9000 ke atas. Saat menggunakan inferensi CPU bersama-sama, komunikasi memori bandwidth tinggi sangat penting.
RAM: Minimal 32GB, disarankan 64GB atau lebih. Bandwidth memori utama (MB/s) menjadi bottleneck penentu selama inferensi CPU atau offloading. Memori berkecepatan tinggi DDR5-6000 atau lebih adalah ideal.
GPU: NVIDIA seri RTX 4000/5000. Dalam LLM lokal, yang paling penting bukanlah kinerja komputasi melainkan “kapasitas VRAM”.
- Entry level: RTX 4060 Ti (versi 16GB) - Kinerja biaya (cost-performance) terbaik. Sangat cocok untuk model kelas 8B-14B.
- Menengah (Mid-range): RTX 4070 Ti SUPER (16GB) / RTX 4080 SUPER (16GB)
- High-end: RTX 4090 (24GB) / RTX 5090 (32GB) - Diperlukan untuk menjalankan model terkuantisasi kelas 30B-70B.
Penyimpanan: SSD NVMe PCIe Gen4 atau Gen5. Mengurangi waktu pemuatan model puluhan GB secara dramatis.

2.2 Pengaturan WSL2 (Windows Subsystem for Linux 2)

Meskipun banyak alat GUI berjalan secara native di Windows, WSL2 sangat praktis untuk pengembangan menggunakan Python, kompilasi alat terbaru, dan fine-tuning LoRA yang akan dijelaskan nanti. Di lingkungan Windows 11 terbaru, hanya dengan menginstal driver NVIDIA di sisi host, GPU (CUDA) dapat digunakan secara transparan dari WSL2.

Buka PowerShell dengan hak administrator dan jalankan berikut ini:

1
2
3
4
5


# Instalasi WSL2 dan Ubuntu terbaru
wsl --install -d Ubuntu-24.04

# Pembaruan kernel
wsl --update

Setelah instalasi, jalankan nvidia-smi di terminal WSL2. Jika GPU terdeteksi secara normal, instalasi berhasil.

3. Arsitektur LLM Lokal dan Mekanisme Inferensi

Memahami struktur internal bagaimana model menghasilkan teks di lingkungan lokal sangat berguna untuk pemecahan masalah dan pengoptimalan.

Diagram Mermaid di bawah ini menunjukkan alur (pipeline) inferensi LLM lokal yang umum.

graph TD User["Input Pengguna (Prompt)"] --> Tokenizer["Tokenizer (Tokenizer)"] Tokenizer --> Embedding["Lapisan Penyematan (Embedding)"] subgraph "Transformer Block (x Layers)" Embedding --> Attn["Perhatian Diri (Self-Attention)"] Attn --> KVCache["Cache KV (Penyimpanan Key/Value)"] Attn --> FFN["Jaringan Feed-Forward (FFN)"] end FFN --> Logits["Perhitungan Logit (Logits)"] Logits --> Sampler["Sampler (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["Token Output"] OutputToken --> |"Pembuatan Autoregresif"| Tokenizer OutputToken --> Decoder["Detokenizer (Detokenizer)"] Decoder --> FinalOutput["Teks Output Akhir"]

3.1 Dua Fase: Prefill dan Decode

Pembuatan teks LLM dibagi menjadi dua fase dengan karakteristik komputasi yang berbeda.

Fase Prefill (Pemrosesan Prompt): Ini adalah fase untuk memproses dan memahami seluruh prompt input sekaligus. Karena komputasi paralel memungkinkan, kapasitas komputasi GPU (FLOPS) berbanding lurus dengan kecepatan. Jika prompt panjang, fase ini bisa memakan waktu beberapa detik.
Fase Decode (Pembuatan Token): Fase ini memprediksi token demi token dan memasukkannya kembali sebagai input berikutnya (autoregresif). Karena komputasi paralel terbatas dalam fase ini, bandwidth VRAM GPU (Memory Bandwidth) menjadi bottleneck penentu.

4. Perhitungan Konsumsi VRAM dan Pemahaman Matematis Ukuran Model

Untuk menilai dengan tepat “model mana yang dapat berjalan di PC saya?”, Anda perlu memahami rumus perhitungan VRAM. Jika fallback ke memori sistem (RAM) terjadi karena kekurangan VRAM, kecepatan inferensi akan melambat 10 hingga 100 kali lipat.

4.1 VRAM Dasar Berdasarkan Ukuran Parameter

Ini adalah jumlah memori untuk memuat bobot (weights) model ke dalam VRAM. Dihitung menggunakan ukuran model $P$ (jumlah parameter, satuan: 1 Miliar = 1B) dan jumlah byte per parameter $B$.

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

Misalnya, jika memuat model parameter 8B (8 miliar) dalam FP16 (titik mengambang presisi setengah, 16-bit = 2 byte):

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

Dengan kata lain, meskipun GPU memiliki VRAM 16GB, batasnya sudah hampir tercapai hanya dengan memuat model.

4.2 Keajaiban Kuantisasi (Quantization)

Di sinilah “kuantisasi” muncul. Ini secara dramatis mengurangi ukuran model dengan menurunkan presisi parameter. Pada kuantisasi 4-bit yang paling umum (contoh: Q4_K_M), rata-rata adalah sekitar 0,55 byte per parameter.

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

Dengan demikian, jika Anda memiliki 16GB VRAM, Anda dapat menjalankan model 8B dengan kelonggaran yang cukup.

4.3 Perhitungan Cache KV (Versi Kompatibel GQA)

Selama inferensi, “Cache KV” untuk mempertahankan konteks masa lalu akan mengonsumsi VRAM. Pada model terbaru seperti Llama 3, GQA (Grouped Query Attention) diadopsi untuk menghemat memori.

Konsumsi Cache KV $V_{kv}$ (Gigabyte) direpresentasikan oleh rumus berikut.

$$ 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 $$

Disederhanakan, ini dapat dihitung dengan mudah menggunakan jumlah head key dan value $h_{kv}$.

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

Di mana:

$b$: Ukuran batch (biasanya 1 untuk penggunaan lokal pribadi)
$s$: Panjang sekuens (panjang konteks, contoh: 8192)
$l$: Jumlah lapisan (contoh: 32)
$h_{kv}$: Jumlah head KV (contoh: 8)
$d$: Jumlah dimensi per head (contoh: 128)
$B_{kv}$: Jumlah byte dari Cache KV (2 untuk FP16)

Contoh perhitungan (Llama 3 8B, konteks 8192, Cache FP16): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

Perhatikan bahwa semakin panjang panjang konteks $s$, VRAM yang dibutuhkan akan meningkat secara linier.

5. Praktik 1: Pengaturan Tercepat & Tersingkat Menggunakan Ollama

Setelah memahami teorinya, mari kita coba menjalankan LLM di lingkungan Windows secara nyata. Hingga tahun 2026, alat yang paling ramah pengguna adalah “Ollama”. Ia menyediakan CLI intuitif yang mirip Docker.

5.1 Instalasi dan Eksekusi

Unduh penginstal versi Windows dari Situs Resmi Ollama dan jalankan.
Buka PowerShell dan masukkan perintah berikut. Di sini, kita akan menggunakan llama3:8b yang mendukung bahasa Jepang.

1

ollama run llama3:8b

Pada percobaan pertama, model akan diunduh. Setelah selesai, Anda dapat langsung berinteraksi di terminal.

5.2 Pembuatan AI Kustom dengan Modelfile

Anda dapat dengan mudah membuat AI yang memiliki persona tertentu. Buat Modelfile di lokasi yang diinginkan.

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
Anda adalah insinyur perangkat lunak senior yang sangat hebat.
Untuk pertanyaan pengguna, selalu jawab secara logis dan ringkas, dengan menyertakan contoh kode.
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

Bangun model kustom Anda sendiri dan jalankan dengan perintah berikut.

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 Penggunaan dari Aplikasi Eksternal (AI Editor)

Ollama mengekspos endpoint API yang kompatibel dengan OpenAI di http://localhost:11434. Hanya dengan mengatur URL ke atas di pengaturan backend ekstensi VS Code seperti Cursor atau Continue.dev, dan menetapkan nama model ke SeniorDev dll, Anda mendapatkan asisten pengkodean lokal yang kuat secara gratis.

6. Praktik 2: Penyesuaian Kinerja Ekstrem dengan llama.cpp

Jika Anda ingin mencoba manajemen memori yang mendetail atau format terbaru (seperti kuantisasi EXL2 atau IQ) sesegera mungkin, operasikan langsung mesin intinya llama.cpp.

6.1 Langkah Build llama.cpp

Di lingkungan Windows, yang terbaik adalah membangun dari sumber menggunakan CUDA Toolkit dan CMake.

1
2
3
4
5
6
7
8


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

# Konfigurasi dan kompilasi untuk dukungan CUDA
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 Peluncuran Lanjutan dalam Mode Server

Gunakan llama-server.exe yang telah dibangun untuk meng-host model.

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: Membongkar (offload) semua lapisan yang memungkinkan ke VRAM GPU.
--flash-attn: Mengaktifkan FlashAttention 3, mencapai peningkatan kecepatan inferensi dan pengurangan konsumsi VRAM dari Cache KV.

7. GUI Frontend: LM Studio dan Membangun RAG Lokal

Jika Anda tidak nyaman dengan baris perintah, atau jika Anda ingin melakukan RAG (Retrieval-Augmented Generation) secara intuitif, gunakan GUI.

7.1 LM Studio

LM Studio adalah aplikasi brilian yang menggabungkan pencarian model, pengunduhan, pemeriksaan awal persyaratan sistem, dan bahkan UI obrolan menjadi satu. Cukup dengan menekan tombol “Local Server” di dalam aplikasi, API yang kompatibel dengan OpenAI akan dimulai.

7.2 Arsitektur RAG menggunakan AnythingLLM

Berikut adalah diagram arsitektur lingkungan RAG untuk membaca dokumen internal perusahaan atau catatan pribadi.

graph LR Document["Dokumen (PDF, MD)"] --> Chunking["Pembagian Potongan (Chunking)"] Chunking --> EmbedModel["Model Penyematan"] EmbedModel --> VectorDB["Database Vektor"] UserQuery["Pertanyaan Pengguna"] --> EmbedQuery["Penyematan Pertanyaan"] EmbedQuery --> VectorDB VectorDB --> |"Pencarian Kemiripan"| RetrievedDocs["Ekstraksi Dokumen Terkait"] UserQuery --> PromptBuilder["Pembuatan Prompt"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["LLM Lokal"] LocalLLM --> Answer["Jawaban Akhir"]

Dengan AnythingLLM versi desktop (Windows), Anda hanya perlu menentukan Ollama (LLM dan Embedding) dari layar pengaturan, dan mengaturnya untuk menggunakan VectorDB lokal (LanceDB), dan arsitektur ini selesai dalam beberapa menit. Lahirlah AI privat yang tidak mengirimkan data apa pun ke luar.

8. Fine-tuning (LoRA) di Windows WSL2

Jika Anda tidak hanya ingin menjalankannya secara lokal, tetapi juga ingin membuat model Anda lebih pintar dengan data Anda sendiri, fine-tuning menggunakan LoRA (Low-Rank Adaptation) dimungkinkan. Hingga tahun 2026, menggunakan pustaka bernama “Unsloth”, pelatihan model 8B dapat diselesaikan dalam beberapa jam bahkan dengan VRAM 16GB di lingkungan Windows WSL2.

Jalankan berikut ini di dalam Ubuntu WSL2 untuk mengatur lingkungan.

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 mengoptimalkan kernel CUDA hingga batasnya, mencapai kecepatan pelatihan sekitar 2 kali lipat dan mengurangi konsumsi VRAM hingga separuhnya dibandingkan dengan pustaka Hugging Face standar. Hanya dengan meluncurkan Jupyter Notebook dan memuat kumpulan data (format JSONL), Anda dapat melakukan pelatihan beberapa epoch bahkan pada RTX 4060 Ti dll dengan VRAM 12GB hingga 16GB.

9. Pemecahan Masalah Kinerja

Ini adalah masalah umum dan solusinya.

1. Kecepatan inferensi sangat lambat (1-2 token/s)

Penyebab: Model tidak muat sepenuhnya di VRAM dan sedang dibongkar (offload) ke memori sistem (RAM). Solusi: Periksa “Memori GPU Khusus” di Task Manager. Jika mencapai batas, kurangi ukuran konteks (-c) atau gunakan model kuantisasi dengan bit yang lebih rendah (seperti Q4_K_M).

2. Kesalahan “CUDA out of memory”

Penyebab: VRAM telah habis sepenuhnya. Ini terutama terjadi ketika percakapan diperpanjang dan Cache KV membengkak. Solusi: Secara sengaja batasi nilai num_ctx untuk Ollama atau -c untuk llama.cpp menjadi lebih kecil.

3. Pembuatan teks bahasa Jepang/Indonesia aneh

Penyebab: Ketidaksesuaian template prompt, atau model yang tidak didukung. Solusi: Gunakan model yang menyertakan Instruct dalam namanya, dan pastikan template yang benar yang ditentukan oleh pembuat model, seperti format ChatML atau Llama3, dipilih di sisi alat.

10. Kesimpulan dan Prospek Masa Depan

Pada tahun 2026, membangun LLM lokal di lingkungan Windows tidak lagi menjadi hak istimewa eksklusif segelintir insinyur. Melalui standar de facto format GGUF, munculnya ekosistem yang disempurnakan seperti Ollama dan LM Studio, serta pengoptimalan perangkat keras termasuk FlashAttention, siapa pun kini dapat dengan mudah memperoleh lingkungan AI tingkat perusahaan (enterprise).

Silakan manfaatkan poin-poin yang dijelaskan dalam artikel ini:

Gunakan perhitungan matematis VRAM untuk secara logis memilih ukuran model dan tingkat kuantisasi yang paling sesuai dengan spesifikasi PC Anda.
Gunakan Ollama untuk membangun lingkungan tercepat dan meningkatkan produktivitas secara dramatis dengan menghubungkannya ke editor AI.
Gunakan kontrol parameter lanjutan dari llama.cpp untuk memaksimalkan kinerja batas perangkat keras Anda.
Gunakan AnythingLLM untuk membangun sistem RAG lokal yang aman yang menangani data rahasia.
Manfaatkan Unsloth (WSL2) untuk melatih AI kustom yang memiliki pengetahuan khusus Anda sendiri.

“Demokratisasi” AI tidak lagi sekadar buzzword, tetapi sistem nyata yang berjalan di desktop Windows Anda. Bebaskan diri Anda dari biaya penggunaan API cloud dan risiko kebocoran informasi, serta melangkahlah sekarang ke dunia AI privat yang bebas dan kuat.