Tutorial Semantic Kernel: Framework AI Orchestration dari Microsoft untuk Membangun Aplikasi Cerdas

Semantic Kernel adalah SDK open-source dari Microsoft yang dirancang untuk mengintegrasikan Large Language Models (LLM) ke dalam aplikasi secara terstruktur dan modular. Framework ini memungkinkan developer membangun aplikasi AI yang menggabungkan prompt engineering, plugin system, dan agentic workflow dalam satu arsitektur yang koheren. Dalam tutorial ini, kita akan mempelajari cara menggunakan Semantic Kernel dengan Python, mulai dari instalasi hingga membangun AI agent yang mampu mengeksekusi tugas kompleks secara otonom.

Mengapa Semantic Kernel?

Berbeda dengan framework AI lainnya yang fokus pada chaining prompt sederhana, Semantic Kernel mengambil pendekatan yang lebih enterprise-ready. Beberapa keunggulan utamanya antara lain:

• Plugin Architecture: Memisahkan logika bisnis dari prompt, sehingga kode lebih maintainable
• Multi-Provider Support: Mendukung OpenAI, Azure OpenAI, Hugging Face, dan provider lainnya
• Automatic Function Calling: LLM dapat secara otomatis memilih dan mengeksekusi fungsi yang tersedia
• Memory dan RAG Built-in: Integrasi native dengan vector store untuk konteks jangka panjang
• Planner: Kemampuan untuk memecah tugas kompleks menjadi langkah-langkah yang dapat dieksekusi
• Type Safety: Strongly typed dengan dukungan Pydantic untuk validasi input/output

Semantic Kernel digunakan secara luas di produk Microsoft seperti Microsoft 365 Copilot, menjadikannya framework yang sudah teruji di skala produksi.

Instalasi

Prasyarat

Pastikan Python 3.10 atau lebih baru sudah terinstal di sistem Anda.

python --version

Instalasi Semantic Kernel

pip install semantic-kernel

Untuk fitur tambahan, Anda bisa menginstal extras yang diperlukan:

# Untuk Azure OpenAI
pip install semantic-kernel[azure]

Untuk Hugging Face
pip install semantic-kernel[huggingface]


Untuk Google AI
pip install semantic-kernel[google]

Semua provider
pip install semantic-kernel[all]

# Untuk OpenAI
OPENAIAPIKEY=sk-your-api-key-here

OPENAICHATMODELID=gpt-4o

Untuk Azure OpenAI
AZUREOPENAIAPIKEY=your-azure-key

AZUREOPENAIENDPOINT=https://your-resource.openai.azure.com/

AZUREOPENAICHATDEPLOYMENTNAME=gpt-4o

import asyncio
from semantickernel import Kernel
from semantickernel.connectors.ai.openai import OpenAIChatCompletion

kernel = Kernel()

chatservice = OpenAIChatCompletion(

    aimodelid="gpt-4o",

    serviceid="chat"
)
kernel.addservice(chatservice)

async def main():
    result = await kernel.invokeprompt("Jelaskan apa itu machine learning dalam 3 kalimat.")

    print(result)

asyncio.run(main())

import asyncio
from semantickernel import Kernel
from semantickernel.connectors.ai.openai import OpenAIChatCompletion
from semantickernel.contents import ChatHistory


kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))

chathistory = ChatHistory()
chathistory.addsystemmessage(

    "Kamu adalah asisten AI yang membantu developer Python. "
    "Jawab dengan ringkas dan berikan contoh kode jika diperlukan."
)

async def chat(userinput: str):
    chathistory.addusermessage(userinput)

    result = await kernel.invokeprompt(

        userinput,
        chathistory=chathistory
    )

    response = str(result)
    chathistory.addassistantmessage(response)

    return response

async def main():
    print(await chat("Apa itu decorator di Python?"))
    print(await chat("Berikan contoh penggunaannya"))

asyncio.run(main())

import asyncio
from semantickernel import Kernel
from semantickernel.connectors.ai.openai import OpenAIChatCompletion
from semantickernel.prompttemplate import PromptTemplateConfig

kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(

    aimodelid="gpt-4o",

    serviceid="chat"
))

promptconfig = PromptTemplateConfig(

    template="""Kamu adalah seorang {{$role}}.
Tugas: {{$task}}
Berikan jawaban yang detail dan terstruktur.""",
    inputvariables=[
        {"name": "role", "description": "Peran AI"},
        {"name": "task", "description": "Tugas yang harus dilakukan"}
    ]
)

function = kernel.addfunction(

    pluginname="writer",
    functionname="generate",

    prompttemplateconfig=promptconfig
)

async def main():
    result = await kernel.invoke(
        function,
        role="data scientist senior",
        task="Jelaskan perbedaan antara Random Forest dan Gradient Boosting"
    )
    print(result)

asyncio.run(main())

Plugin System

Plugin adalah fitur inti Semantic Kernel yang memungkinkan Anda mendefinisikan fungsi-fungsi yang dapat dipanggil oleh LLM secara otomatis.

Membuat Native Plugin

import asyncio
from datetime import datetime
from typing import Annotated
from semantickernel import Kernel

from semantickernel.connectors.ai.openai import OpenAIChatCompletion

from semantickernel.functions import kernelfunction


class UtilityPlugin:
    @kernelfunction(description="Mendapatkan tanggal dan waktu saat ini")
    def getcurrenttime(self) -> str:
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    @kernelfunction(description="Menghitung diskon dari harga asli")

    def calculatediscount(
        self,
        price: Annotated[float, "Harga asli produk"],
        discountpercent: Annotated[float, "Persentase diskon"]

    ) -> str:
        discounted = price  (1 - discountpercent / 100)
        savings = price - discounted
        return f"Harga asli: Rp{price:,.0f}, Diskon: {discountpercent}%, Harga akhir: Rp{discounted:,.0f}, Hemat: Rp{savings:,.0f}"


    @kernelfunction(description="Mengkonversi suhu dari Celsius ke Fahrenheit")
    def celsiustofahrenheit(
        self,
        celsius: Annotated[float, "Suhu dalam Celsius"]
    ) -> str:
        fahrenheit = (celsius  9/5) + 32
        return f"{celsius}°C = {fahrenheit}°F"

kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(

    aimodelid="gpt-4o",

    serviceid="chat"
))
kernel.addplugin(UtilityPlugin(), pluginname="utility")

async def main():
    result = await kernel.invokeprompt(

        "Berapa harga setelah diskon 25% dari Rp500.000?"
    )
    print(result)

asyncio.run(main())

import asyncio
import httpx
from semantickernel.functions import kernelfunction

from typing import Annotated

class WeatherPlugin:
    @kernelfunction(description="Mendapatkan informasi cuaca untuk sebuah kota")
    async def getweather(

        self,
        city: Annotated[str, "Nama kota untuk dicek cuacanya"]
    ) -> str:
        async with httpx.AsyncClient() as client:
            response = await client.get(
                "https://api.open-meteo.com/v1/forecast",
                params={
                    "latitude": 0,
                    "longitude": 0,
                    "currentweather": True
                }
            )
            data = response.json()
            weather = data.get("currentweather", {})

            return (
                f"Cuaca di {city}: "
                f"Suhu {weather.get('temperature', 'N/A')}°C, "
                f"Kecepatan angin {weather.get('windspeed', 'N/A')} km/h"
            )

plugins/
  WriterPlugin/
    Summarize/
      skprompt.txt
      config.json
    Translate/
      skprompt.txt
      config.json

Ringkas teks berikut dalam {{$targetlength}} kalimat:

{{$input}}

Ringkasan:

File config.json:

{
  "schema": 1,
  "description": "Meringkas teks panjang menjadi versi yang lebih pendek",
  "inputvariables": [

    {
      "name": "input",
      "description": "Teks yang akan diringkas"
    },
    {
      "name": "targetlength",
      "description": "Jumlah kalimat untuk ringkasan",
      "default": "3"
    }
  ]
}

Memuat plugin dari folder:

kernel.addplugin(parentdirectory="./plugins", pluginname="WriterPlugin")

import asyncio
from semantickernel import Kernel
from semantickernel.connectors.ai.openai import OpenAIChatCompletion
from semantickernel.connectors.ai.openai.promptexecutionsettings import (
    OpenAIChatPromptExecutionSettings,
)
from semantickernel.connectors.ai.functionchoicebehavior import FunctionChoiceBehavior

from semantickernel.contents import ChatHistory
from semantickernel.functions import kernelfunction
from typing import Annotated

class MathPlugin:
    @kernelfunction(description="Menambahkan dua angka")

    def add(
        self,
        a: Annotated[float, "Angka pertama"],
        b: Annotated[float, "Angka kedua"]
    ) -> float:
        return a + b

    @kernelfunction(description="Mengalikan dua angka")
    def multiply(
        self,
        a: Annotated[float, "Angka pertama"],
        b: Annotated[float, "Angka kedua"]
    ) -> float:
        return a  b


    @kernelfunction(description="Menghitung pangkat")

    def power(
        self,
        base: Annotated[float, "Basis"],
        exponent: Annotated[float, "Eksponen"]
    ) -> float:
        return base  exponent


kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))
kernel.addplugin(MathPlugin(), pluginname="math")


settings = OpenAIChatPromptExecutionSettings(
    serviceid="chat",
    functionchoicebehavior=FunctionChoiceBehavior.Auto()
)

chathistory = ChatHistory()


async def main():
    chathistory.addusermessage(
        "Berapa hasil dari (15 + 27) dikali 3, kemudian dipangkatkan 2?"
    )

    result = await kernel.invokeprompt(

        "{{$chathistory}}",
        chathistory=chathistory,
        settings=settings
    )

    print(f"Jawaban: {result}")

asyncio.run(main())

import asyncio
from semantickernel import Kernel

from semantickernel.agents import ChatCompletionAgent
from semantickernel.connectors.ai.openai import OpenAIChatCompletion
from semantickernel.contents import ChatHistory

from semantickernel.functions import kernelfunction

from typing import Annotated

class DatabasePlugin:
    @kernelfunction(description="Mengeksekusi query SQL dan mengembalikan hasil")
    def executequery(

        self,
        query: Annotated[str, "Query SQL untuk dieksekusi"]
    ) -> str:
        sampledata = {
            "SELECT COUNT() FROM users": "Total users: 1,247",
            "SELECT AVG(revenue) FROM sales WHERE month='2026-09'":
                "Average revenue September 2026: Rp45,230,000"
        }
        for key, value in sampledata.items():

            if key.lower() in query.lower():
                return value
        return f"Query executed: {query}\nRows affected: 0"

    @kernelfunction(description="Mendapatkan daftar tabel yang tersedia di database")
    def listtables(self) -> str:

        return "Tables: users, sales, products, orders, inventory"

    @kernelfunction(description="Mendapatkan skema dari sebuah tabel")
    def gettableschema(
        self,
        tablename: Annotated[str, "Nama tabel"]

    ) -> str:
        schemas = {
            "users": "id INT PK, name VARCHAR, email VARCHAR, createdat TIMESTAMP",
            "sales": "id INT PK, productid INT FK, amount DECIMAL, month VARCHAR",

            "products": "id INT PK, name VARCHAR, price DECIMAL, category VARCHAR"
        }
        return schemas.get(tablename, f"Table '{tablename}' not found")


kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))
kernel.addplugin(DatabasePlugin(), pluginname="database")


agent = ChatCompletionAgent(
    kernel=kernel,
    name="DataAnalyst",
    instructions="""Kamu adalah seorang data analyst yang ahli dalam SQL dan analisis data.
Gunakan tools database yang tersedia untuk menjawab pertanyaan pengguna.
Selalu jelaskan query yang kamu jalankan dan interpretasi hasilnya.
Jawab dalam bahasa Indonesia.""",
)

async def main():
    history = ChatHistory()
    history.addusermessage("Berapa total user yang terdaftar di sistem?")


    async for message in agent.invoke(history):
        print(f"Agent: {message.content}")

asyncio.run(main())

import asyncio
from semantickernel import Kernel
from semantickernel.agents import ChatCompletionAgent, AgentGroupChat

from semantickernel.agents.strategies import TerminationStrategy
from semantickernel.connectors.ai.openai import OpenAIChatCompletion
from semantickernel.contents import ChatMessageContent, AuthorRole


kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))

analyst = ChatCompletionAgent(
    kernel=kernel,
    name="Analyst",
    instructions="""Kamu adalah business analyst. 
Analisis masalah bisnis dan identifikasi kebutuhan teknis.
Berikan rekomendasi yang terukur dan realistis."""
)

engineer = ChatCompletionAgent(
    kernel=kernel,
    name="Engineer",
    instructions="""Kamu adalah software engineer senior.
Evaluasi rekomendasi teknis dari analyst.
Berikan estimasi effort, arsitektur, dan potensi risiko.
Jawab dengan spesifik dan teknis."""
)

reviewer = ChatCompletionAgent(
    kernel=kernel,
    name="Reviewer",
    instructions="""Kamu adalah project reviewer.
Review output dari analyst dan engineer.
Berikan approval atau feedback untuk perbaikan.
Jika sudah cukup baik, akhiri dengan kata APPROVED."""
)

class ApprovalTermination(TerminationStrategy):
    async def shouldagentterminate(self, agent, history):

        if history:
            last = history[-1]
            return "APPROVED" in last.content.upper()
        return False

chat = AgentGroupChat(
    agents=[analyst, engineer, reviewer],
    terminationstrategy=ApprovalTermination(
        agents=[reviewer],
        maximumiterations=6

    )
)

async def main():
    await chat.addchatmessage(

        ChatMessageContent(
            role=AuthorRole.USER,
            content="Kami ingin membangun sistem rekomendasi produk untuk e-commerce dengan 100K SKU dan 1M users aktif."
        )
    )

    async for message in chat.invoke():
        print(f"\n{'='*50}")
        print(f"[{message.name}]: {message.content}")

asyncio.run(main())

import asyncio
from semantickernel import Kernel
from semantickernel.connectors.ai.openai import (
    OpenAIChatCompletion,
    OpenAITextEmbedding,
)
from semantickernel.memory import SemanticTextMemory, VolatileMemoryStore


kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))

embeddingservice = OpenAITextEmbedding(
    aimodelid="text-embedding-3-small",
    serviceid="embedding"

)

memorystore = VolatileMemoryStore()
memory = SemanticTextMemory(
    storage=memorystore,

    embeddingsgenerator=embeddingservice

)

async def main():
    collection = "companyknowledge"

    await memory.saveinformation(

        collection=collection,
        id="policy1",
        text="Kebijakan cuti tahunan adalah 12 hari kerja per tahun. "
             "Cuti dapat diakumulasi maksimal 6 hari ke tahun berikutnya."
    )

    await memory.saveinformation(

        collection=collection,
        id="policy2",
        text="Jam kerja standar adalah Senin-Jumat, 09:00-18:00 WIB. "
             "Lembur dihitung setelah 8 jam kerja per hari."
    )

    await memory.saveinformation(

        collection=collection,
        id="policy3",
        text="Benefit karyawan meliputi BPJS Kesehatan, BPJS Ketenagakerjaan, "
             "asuransi tambahan, dan tunjangan makan Rp35.000 per hari."
    )

    results = await memory.search(
        collection=collection,
        query="Berapa hari cuti yang didapat karyawan?",
        limit=2
    )

    context = "\n".join([r.text for r in results])

    result = await kernel.invokeprompt(

        f"""Berdasarkan informasi berikut:
{context}

Jawab pertanyaan: Berapa hari cuti yang didapat karyawan dan apakah bisa diakumulasi?"""
    )
    print(result)

asyncio.run(main())

import asyncio
import time
from semantickernel import Kernel
from semantickernel.connectors.ai.openai import OpenAIChatCompletion
from semantickernel.filters import (

    FunctionInvocationContext,
    PromptRenderContext,
)

kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))

@kernel.filter(filtertype="functioninvocation")

async def logfunctionfilter(context: FunctionInvocationContext, next):

    starttime = time.time()
    print(f"[LOG] Calling function: {context.function.name}")
    print(f"[LOG] Arguments: {context.arguments}")

    await next(context)

    elapsed = time.time() - starttime

    print(f"[LOG] Function {context.function.name} completed in {elapsed:.2f}s")
    print(f"[LOG] Result: {str(context.result)[:200]}")

@kernel.filter(filtertype="promptrender")

async def modifypromptfilter(context: PromptRenderContext, next):

    await next(context)
    context.renderedprompt += "\n\nJawab dalam bahasa Indonesia yang formal."
    print(f"[LOG] Rendered prompt length: {len(context.renderedprompt)}")


async def main():
    result = await kernel.invokeprompt("Apa itu neural network?")
    print(f"\nResult: {result}")

asyncio.run(main())

Streaming Responses

Untuk aplikasi real-time, gunakan streaming:

import asyncio
from semantickernel import Kernel

from semantickernel.connectors.ai.openai import OpenAIChatCompletion


kernel = Kernel()
kernel.addservice(OpenAIChatCompletion(
    aimodelid="gpt-4o",
    serviceid="chat"

))

async def main():
    print("Response: ", end="", flush=True)

    async for chunk in kernel.invokepromptstream(

        "Jelaskan 5 langkah dalam machine learning pipeline"
    ):
        print(str(chunk), end="", flush=True)

    print()

asyncio.run(main())

from semantickernel import Kernel

def createkernel(apikey: str, model: str = "gpt-4o") -> Kernel:
    kernel = Kernel()
    kernel.addservice(OpenAIChatCompletion(

        aimodelid=model,

        apikey=apikey,

        serviceid="chat"
    ))
    return kernel

2. Error Handling yang Proper

from semantickernel.exceptions import ServiceResponseException

async def safeinvoke(kernel, prompt):
    try:
        result = await kernel.invokeprompt(prompt)

        return str(result)
    except ServiceResponseException as e:
        print(f"Service error: {e}")
        return None
    except Exception as e:
        print(f"Unexpected error: {e}")
        return None

class FilePlugin:
    @kernelfunction(description="Membaca konten file")
    def readfile(self, path: Annotated[str, "Path file"]) -> str:

        with open(path, "r") as f:
            return f.read()

    @kernelfunction(description="Menulis konten ke file")
    def writefile(

        self,
        path: Annotated[str, "Path file"],
        content: Annotated[str, "Konten yang akan ditulis"]
    ) -> str:
        with open(path, "w") as f:
            f.write(content)
        return f"File written: {path}"

from semantickernel.connectors.ai.openai.promptexecutionsettings import (
    OpenAIChatPromptExecutionSettings,
)

settings = OpenAIChatPromptExecutionSettings(
    serviceid="chat",
    temperature=0.7,
    maxtokens=2000,

    topp=0.9,
)

result = await kernel.invokeprompt(prompt, settings=settings)

import pytest

class TestMathPlugin:
    def setupmethod(self):
        self.plugin = MathPlugin()

    def testadd(self):

        result = self.plugin.add(a=10, b=20)
        assert result == 30

    def testmultiply(self):
        result = self.plugin.multiply(a=5, b=6)
        assert result == 30

    def testpower(self):

        result = self.plugin.power(base=2, exponent=10)
        assert result == 1024

from pydantic import BaseModel, Field
from semantickernel.functions import kernelfunction


class AnalysisResult(BaseModel):
    sentiment: str = Field(description="positive, negative, atau neutral")
    confidence: float = Field(description="Skor kepercayaan 0-1")
    keytopics: list[str] = Field(description="Topik utama yang terdeteksi")
    summary: str = Field(description="Ringkasan singkat")

class AnalysisPlugin:
    @kernelfunction(description="Menganalisis sentimen dan topik dari teks")

    async def analyzetext(
        self,
        text: Annotated[str, "Teks yang akan dianalisis"],
        kernel: Kernel
    ) -> str:
        result = await kernel.invokeprompt(

            f"""Analisis teks berikut dan berikan output dalam format JSON:
sentiment: positive/negative/neutral
confidence: skor 0-1
keytopics: daftar topik utama
summary: ringkasan singkat

Teks: {text}

Output JSON:"""
        )
        return str(result)

Perbandingan dengan Framework Lain

| Fitur | Semantic Kernel | LangChain | LlamaIndex |

|-------|----------------|-----------|------------|

| Plugin System | Native, strongly typed | Tools/Agents | Tools |

| Multi-Provider | Ya | Ya | Ya |

| Memory | Built-in | Add-on | Native |

| Agent Framework | ChatCompletionAgent | AgentExecutor | Agent |

| Enterprise Ready | Sangat Baik | Baik | Baik |

| Learning Curve | Sedang | Rendah-Sedang | Sedang |

| Bahasa | Python, C#, Java | Python, JS | Python, TS |

Kesimpulan

Semantic Kernel adalah framework AI orchestration yang matang dan production-ready dari Microsoft. Dengan arsitektur plugin yang modular, dukungan multi-provider, dan fitur agent yang komprehensif, framework ini sangat cocok untuk membangun aplikasi AI enterprise. Kemampuannya dalam automatic function calling dan multi-agent collaboration membuatnya menjadi pilihan yang kuat untuk project yang membutuhkan integrasi LLM yang terstruktur dan scalable.

Beberapa poin penting yang perlu diingat:

• Mulai dari Kernel dan tambahkan service sesuai kebutuhan
• Gunakan plugin system untuk memisahkan logika bisnis dari prompt
• Manfaatkan automatic function calling untuk workflow yang lebih natural
• Implementasikan filter untuk logging dan monitoring di production
• Pertimbangkan multi-agent pattern untuk tugas yang kompleks
• Selalu test plugin functions secara independen sebelum mengintegrasikan dengan LLM

Dengan fondasi yang kuat dari Microsoft dan komunitas yang terus berkembang, Semantic Kernel merupakan investasi yang baik untuk developer yang ingin membangun aplikasi AI yang robust dan enterprise-grade.