Cara Menggunakan Semantic Kernel: Panduan Praktikal dengan Corak, Prompt dan Plugin
Pernahkah anda cuba menggabungkan LLM dengan aplikasi anda dan akhirnya mendapat prompt, fungsi pembantu dan keadaan yang rapuh dan kusut? Semantic Kernel (SK) wujud untuk menyelesaikan masalah ini. Ia adalah rangka kerja orkestrasi sumber terbuka yang ringan daripada Microsoft untuk membina aplikasi berasaskan AI yang menggabungkan bahasa semula jadi, alatan dan memori—tanpa menjadikan kod anda menjadi 'prompt spaghetti bowl'.
Dalam panduan ini, kita akan meneliti cara menggunakan Semantic Kernel daripada asas hingga corak pengeluaran secara praktikal dan berorientasikan penyelesaian. Anda akan mempelajari cara menyusun prompt, memasang alatan, menambah memori, memanggil berbilang model dan menggunakan ejen yang bertindak secara konsisten. Kami akan memastikan contoh-contoh ini berasas dan menunjukkan kepada anda perkara yang penting.
Apakah Itu Semantic Kernel—dan Mengapa Menggunakannya?
Semantic Kernel ialah SDK yang membantu anda:
- Mengarang prompt dan fungsi ("kemahiran"/plugin) ke dalam saluran paip.
- Memanggil berbilang model (OpenAI, Azure OpenAI, model tempatan) secara bergantian.
- Menambah memori untuk konteks dan ingatan jangka panjang melalui pembenaman.
- Merancang dan mengatur tugas berbilang langkah dengan keadaan yang boleh dipercayai.
- Mengintegrasikan alatan (API, pangkalan data, fail I/O) dengan selamat dan secara deterministik.
Anggap SK sebagai pengawal yang menyelaraskan LLM, logik aplikasi anda dan data pengguna. Daripada mengekodkan prompt yang panjang dan panggilan alatan ad hoc secara tegar, anda mentakrifkan fungsi semantik boleh guna semula dan fungsi asli dengan input/output yang jelas.
Kes penggunaan biasa:
- Pembantu sokongan pelanggan dengan penjanaan tambahan perolehan (RAG)
- Ejen aliran kerja (meringkaskan → mengelaskan → mengambil tindakan)
- Soal Jawab dokumen dengan memori dan petikan
- Kandungan kreatif dan saluran paip penjanaan kod
Permulaan Pantas: Aplikasi Semantic Kernel Pertama Anda
Di bawah ialah aliran minimum untuk menunjukkan cara menggunakan Semantic Kernel dengan model sembang dan prompt yang mudah. Kami akan menggunakan C# untuk kejelasan; anda boleh melakukan perkara yang sama dalam Python atau Java.
1) Pasang pakej
# .NET
dotnet add package Microsoft.SemanticKernel
# Pilihan: penyambung dan perancang berbeza mengikut versi
2) Konfigurasikan kernel dan model
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;
var builder = Kernel.CreateBuilder;
// Pilih pembekal anda: OpenAI atau Azure OpenAI
builder.AddOpenAIChatCompletion(
modelId: "gpt-4o-mini", // atau model pilihan anda
apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);
var kernel = builder.Build;
3) Takrifkan fungsi semantik (prompt)
using Microsoft.SemanticKernel.SemanticFunctions;
var prompt = @"Anda ialah penerang yang ringkas.
Terangkan konsep '{topic}' dalam 3 poin untuk pemula.";
var explainFunc = kernel.CreateFunctionFromPrompt(prompt);
var result = await explainFunc.InvokeAsync(kernel, new { ["topic"] = "vector embeddings" });
Console.WriteLine(result);
Inilah terasnya: kernel, model dan prompt yang diubah menjadi fungsi boleh guna semula dengan input.
Fungsi Semantik vs. Fungsi Asli
- Fungsi semantik: Dikuasakan oleh prompt. Anda menciptanya daripada templat, menghantar pemboleh ubah dan mendapatkan teks atau output berstruktur.
- Fungsi asli: Fungsi kod biasa yang SK dedahkan kepada LLM untuk penggunaan alatan.
Contoh fungsi asli yang mendapatkan cuaca daripada API anda dan mendedahkannya kepada model:
public class WeatherPlugin
{
[KernelFunction, Description("Dapatkan cuaca untuk bandar")]
public async Task<string> GetWeatherAsync(
[Description("Nama bandar")] string city)
{
// Panggil API cuaca anda di sini
var temp = 22; // ruang letak
return $"Cuaca di {city}: {temp}°C dan cerah";
}
}
// Daftar plugin
var weather = new WeatherPlugin;
kernel.Plugins.AddFromObject(weather, pluginName: "weather");
Kini prompt anda boleh memanggil weather.GetWeatherAsync sebagai alatan, membolehkan model mendasarkan respons dalam data sebenar.
Corak Prompt Yang Benar-benar Berfungsi
Apabila mempelajari cara menggunakan Semantic Kernel, kemenangan terpantas datang daripada corak prompt yang berdisiplin:
- Utamakan sistem: Gunakan mesej sistem yang kukuh untuk menetapkan nada, persona, keselamatan dan format output.
- Slot pemboleh ubah: Namakan ruang letak dengan jelas (cth.,
{topic}, {audience}) dan sahkan input.
- Kontrak output: Minta format berstruktur seperti JSON; sertakan skema dalam prompt.
- Beberapa contoh: Berikan contoh ringkas untuk gaya dan format, bukan kandungan yang mengembang.
- Langkah keselamatan: Sertakan kekangan (“Jika data hilang, tanya soalan penjelasan dahulu”).
Contoh prompt berstruktur di dalam SK:
var prompt = @"
Anda ialah enjin pengelasan.
Tugas: Kelaskan `mesej` ke dalam salah satu daripada [Pengebilan, Sokongan Teknikal, Jualan].
Kembalikan JSON yang ketat: { \"label\": string, \"confidence\": number }
mesej: {message}
";
var classify = kernel.CreateFunctionFromPrompt(prompt);
var output = await classify.InvokeAsync(kernel, new { ["message"] = "Saya tidak boleh log masuk ke akaun saya." });
Console.WriteLine(output); // {"label":"Sokongan Teknikal","confidence":0.89}
Menambah Memori: Pembenaman, RAG dan Tetingkap Konteks
LLM mudah lupa. Memori menjadikannya berguna.
- Konteks jangka pendek: Automatik melalui sejarah perbualan.
- Memori jangka panjang: Simpan pembenaman nota pengguna, dokumen atau peristiwa dan dapatkan semula bahagian yang berkaitan untuk konteks.
- RAG: Sebelum memanggil fungsi penjanaan, tanya stor vektor anda dan masukkan hasil ke dalam prompt.
Contoh: tambah memori teks dengan pembenaman dan dapatkan semula konteks.
using Microsoft.SemanticKernel.Memory;
var memory = new MemoryBuilder
.WithMemoryStore(new VolatileMemoryStore) // tukar untuk DB vektor (Qdrant, Pinecone, Azure AI Search)
.WithTextEmbeddingGeneration(
new OpenAITextEmbeddingGeneration("text-embedding-3-small", Environment.GetEnvironmentVariable("OPENAI_API_KEY")))
.Build;
await memory.SaveInformationAsync(
collection: "policies", id: "refund-policy",
text: "Pelanggan boleh meminta bayaran balik dalam tempoh 30 hari dari pembelian dengan bukti resit."
);
// Kemudian: dapatkan semula dan masukkan ke dalam prompt
var results = memory.SearchAsync("refund window", collection: "policies", limit: 3, minRelevanceScore: 0.7);
await foreach (var item in results)
{
Console.WriteLine($"Relevan: {item.Metadata.Text}");
}
Kemudian suapkan padanan teratas ke dalam fungsi semantik anda sebagai pemboleh ubah konteks. Petua: pastikan bahagian kecil (200–400 token) dan nyahduplikasi.
Penggunaan Alatan dan Perancangan: Aliran Kerja Berbilang Langkah
Semantic Kernel menyokong perancang yang boleh memecahkan matlamat pengguna kepada langkah-langkah dan memilih fungsi yang hendak dipanggil. Ini sesuai apabila anda mempunyai kotak alatan fungsi asli dan semantik.
Corak:
- Kumpul matlamat dan kekangan daripada pengguna.
- Draf pelan (urutan panggilan fungsi dengan argumen).
- Laksanakan langkah demi langkah, sahkan output dan pulih daripada ralat.
Contoh pseudokod:
// 1) Takrifkan plugin (semantik + asli) seperti sebelumnya
// 2) Gunakan perancang (permukaan API mungkin berbeza mengikut versi)
var goal = "Ringkaskan polisi yang dilampirkan, kelaskan risiko dan e-melkan laporan";
// Andaikan kita mempunyai plugin: fail, ringkaskan, kelaskan, e-mel
// Perancang akan memasang pelan: files.Load → summarize.Run → classify.Run → email.Send
// Laksanakan pelan secara berurutan, sahkan output JSON antara langkah
Amalan terbaik:
- Jadikan langkah-langkah idempoten dan boleh diuji.
- Tetapkan skema output eksplisit antara langkah.
- Gunakan percubaan semula/undur pada alatan berangkaian.
- Log input/output untuk kebolehcerapan (tetapi gosok PII).
Strategi Berbilang Model: Pilih Model Yang Tepat untuk Tugas
Dengan menggunakan Semantic Kernel, anda boleh menghalakan tugas ke model yang berbeza:
- Draf pantas → model kecil dan murah
- Langkah-langkah yang memerlukan penaakulan yang berat → model yang lebih besar
- Pembenaman → model pembenaman khusus
- Kod → model yang dioptimumkan kod
Dalam praktiknya:
var kernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey)
.Build;
var fastKernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey) // dioptimumkan kelajuan
.Build;
// Halakan prompt yang lebih mudah ke fastKernel; tugas yang kompleks ke kernel
Atau, konfigurasikan berbilang perkhidmatan dalam kernel yang sama dan pilih setiap fungsi.
Daripada Prototaip kepada Pengeluaran: Langkah Keselamatan dan Pengujian
Apabila anda mempelajari cara menggunakan Semantic Kernel dalam aplikasi sebenar, kebolehpercayaan adalah penting:
- Output utamakan skema: Gunakan skema JSON dan pintu
TryParse.
- Determinisme apabila diperlukan: Tetapkan suhu rendah dan kekang output.
- Penapis keselamatan: Tambah penapis kandungan dan prompt pasukan merah.
- Penyimpanan cache: Cache hasil RAG dan penjanaan yang stabil.
- Kebolehcerapan: Log templat prompt, pemboleh ubah, kependaman, penggunaan token.
- Ujian unit: Prompt ujian emas dengan perbandingan syot kilat.
Contoh: sahkan output JSON.
record Classification(string label, double confidence);
bool TryParseClassification(string text, out Classification cls)
{
try { cls = System.Text.Json.JsonSerializer.Deserialize<Classification>(text)!; return true; }
catch { cls = default!; return false; }
}
Corak Dunia Sebenar Yang Boleh Anda Guna Semula
- Chatbot RAG:
dapatkan semula(konteks) → jawab(soalan, konteks) dengan petikan.
- Aliran kerja kelulusan: kelaskan → jana draf → semakan manusia → hantar.
- Operasi kandungan: gariskan → draf → semak fakta → laraskan nada → terbitkan.
- Ejen dengan alatan: calendar.lookup, docs.search, email.send; dengan perancangan dan memori.
Petua: Kapsulkan setiap langkah sebagai fungsi (semantik atau asli) dan karang menjadi saluran paip.
Contoh: Soal Jawab Dokumen dengan Petikan
Mari kita sambungkan saluran paip Soal Jawab mudah yang memetik sumber menggunakan RAG.
// 1) Masukkan dokumen ke dalam memori
await memory.SaveInformationAsync("handbook", "vacation-policy",
"Pekerja mengumpul 1.5 hari PTO setiap bulan dan boleh membawa lebihan 5 hari.");
// 2) Dapatkan semula konteks untuk soalan
var top = memory.SearchAsync("carry over PTO", "handbook", limit: 3, minRelevanceScore: 0.75);
var contexts = new List<string>;
await foreach (var r in top) contexts.Add(r.Metadata.Text);
// 3) Tanya dengan konteks dan minta petikan
var qaPrompt = @"
Anda menjawab dengan ketat daripada konteks yang diberikan. Jika hilang, katakan anda tidak tahu.
Sertakan petikan sebaris seperti [sumber i] menggunakan indeks item konteks bermula pada 1.
Konteks:
1) {{ctx1}}
2) {{ctx2}}
Soalan: {{q}}
";
var qa = kernel.CreateFunctionFromPrompt(qaPrompt);
var variables = new KernelArguments
{
["ctx1"] = contexts.ElementAtOrDefault(0) ?? "",
["ctx2"] = contexts.ElementAtOrDefault(1) ?? "",
["q"] = "Berapa hari PTO yang boleh saya bawa lebihan?"
};
var answer = await qa.InvokeAsync(kernel, variables);
Console.WriteLine(answer);
Perangkap Biasa (dan Cara Mengelakkannya)
- Prompt gergasi tunggal: Pecahkan kepada fungsi; hantar hanya konteks yang anda perlukan.
- Tiada kontrak output: Sentiasa takrifkan skema untuk langkah yang boleh dibaca mesin.
- RAG tanpa kebersihan: Bahagikan dengan baik, nyahduplikasi dan susun mengikut perkaitan dan kebaharuan.
- Penyebaran alatan: Pastikan antara muka plugin kecil dan didokumenkan.
- Tiada manusia dalam gelung: Tambah kelulusan untuk tindakan berisiko tinggi.
Cara Menggunakan Semantic Kernel dengan Bahagian Depan
- Aplikasi web: Hoskan orkestrasi SK anda dalam lapisan API; strim token ke UI.
- UI Sembang: Kekalkan keadaan perbualan di bahagian pelayan; pangkas dan ringkaskan.
- Pengesahan: Panggilan selamat penyamaran—jangan sesekali biarkan model mencetak token. Pintu panggilan alatan melalui bahagian belakang anda.
Senarai Semak Penggunaan
- Pemboleh ubah persekitaran untuk kunci dan titik akhir
- Had kadar dan percubaan semula untuk panggilan model/alatan
- Kawalan sumber templat prompt
- Sandaran stor vektor dan pengendalian PII
- Papan pemuka kebolehcerapan (kependaman, kos, ralat)
- Ujian A/B untuk prompt dan penghalaan
Penyelesaian Masalah Gaya Soalan Lazim
- “Model berhalusinasi walaupun dengan RAG.” Ketatkan arahan: "Jawab hanya daripada konteks" dan sertakan contoh penolakan. Tingkatkan kekhususan perolehan dan kurangkan suhu.
- “JSON terus rosak.” Tambah contoh mini JSON yang sah dan larang ulasan. Sahkan selepas dan parafrasa semula apabila gagal.
- “Kependaman tinggi.” Dapatkan semula bahagian yang lebih sedikit dan lebih berkaitan; tukar langkah mudah kepada model yang lebih kecil; selaraskan langkah bebas.
- “Kos meningkat.” Cache, mampatkan konteks dan halakan tugas mudah ke model yang lebih murah.
Perlu Diperhatikan: Bina Lebih Pantas dengan Sider.AI
Jika anda membuat prototaip prompt, menguji aliran alatan atau membandingkan respons merentas model, teman seperti Sider.ai boleh mempercepatkan lelaran. Anda boleh mendraf prompt, menjalankan perbandingan A/B dan menangkap coretan boleh guna semula sebelum memindahkannya ke dalam templat Semantic Kernel—sesuai untuk menajamkan arahan dan skema output. Langkah Seterusnya: Ubah Ini Menjadi Ejen Yang Berfungsi
- Mulakan dengan satu tugas yang jelas (cth., kelaskan e-mel sokongan).
- Takrifkan fungsi semantik/asli dengan input/output yang ketat.
- Tambah memori hanya jika ia meningkatkan jawapan dengan ketara.
- Instrumentasikan segala-galanya; uji dengan sampel dunia sebenar.
- Ulangi prompt menggunakan kotak pasir, kemudian kodkan dalam SK.
Perkara utama:
- Semantic Kernel membantu anda mengarang prompt, alatan dan memori menjadi aliran kerja yang boleh dipercayai.
- Gunakan skema output, perancang dan penghalaan berbilang model untuk keteguhan dan kawalan kos.
- RAG serta langkah keselamatan mengalahkan prompt gergasi setiap masa.
Sebaik sahaja anda menguasai cara menggunakan Semantic Kernel dengan corak ini, anda akan menghantar ciri AI yang bukan sahaja demo yang mengagumkan—tetapi sistem yang boleh dipercayai.
Soalan Lazim
S1:Untuk apa Semantic Kernel digunakan dalam aplikasi AI?
Semantic Kernel ialah SDK orkestrasi untuk membina aliran kerja AI yang menggabungkan prompt LLM, alatan (fungsi asli) dan memori. Ia membantu anda menyusun tugas, menambah RAG dan memanggil berbilang model dengan pasti.
S2:Bagaimanakah cara saya menggunakan Semantic Kernel untuk RAG dengan dokumen saya?
Masukkan dokumen anda ke dalam stor vektor melalui API memori SK, kemudian dapatkan semula bahagian yang paling berkaitan setiap pertanyaan dan masukkan ke dalam prompt anda. Ini meningkatkan ketepatan dan mengurangkan halusinasi.
S3:Bolehkah Semantic Kernel memanggil API dan perkhidmatan luaran?
Ya. Balut API sebagai fungsi asli dalam plugin dan daftarkannya dengan kernel supaya model boleh menggunakannya sebagai alatan. Pastikan antara muka kecil dan kuatkan pengesahan input/output.
S4:Model manakah yang berfungsi dengan Semantic Kernel?
Semantic Kernel menyokong OpenAI, Azure OpenAI dan penyambung lain. Anda boleh menghalakan tugas ke model yang berbeza—contohnya, model yang lebih kecil untuk draf dan model yang lebih besar untuk langkah yang memerlukan penaakulan yang intensif.
S5:Bagaimanakah cara saya membuat output Semantic Kernel konsisten (cth., JSON)?
Gunakan prompt berstruktur yang menuntut JSON yang ketat dan sertakan contoh atau skema minimal. Tetapkan suhu rendah, sahkan output selepas panggilan dan cuba semula atau baiki apabila penghuraian gagal.