Semantic Kernel

Microsoft's enterprise-grade SDK for AI orchestration. Planners, skills, and memory for production AI apps.

Core Concepts

Kernel (Central Orchestrator)

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

# Create kernel
kernel = sk.Kernel()

# Add AI service
kernel.add_service(
    OpenAIChatCompletion(
        service_id="gpt4o",
        ai_model_id="gpt-4o",
        api_key="sk-..."
    )
)

# Or multiple services
kernel.add_service(OpenAIChatCompletion(service_id="gpt4o", ai_model_id="gpt-4o", ...))
kernel.add_service(OpenAIChatCompletion(service_id="gpt4o-mini", ai_model_id="gpt-4o-mini", ...))

Plugins (Skills)

from semantic_kernel.functions import kernel_function

class MathPlugin:
    @kernel_function(
        name="add",
        description="Add two numbers"
    )
    def add(self, a: float, b: float) -> float:
        return a + b

    @kernel_function(
        name="multiply",
        description="Multiply two numbers"
    )
    def multiply(self, a: float, b: float) -> float:
        return a * b

# Import plugin
kernel.import_plugin_from_object(MathPlugin(), plugin_name="math")

Functions (Native + Semantic)

# Native function (Python)
@kernel_function(name="get_weather", description="Get weather")
async def get_weather(city: str) -> str:
    return await weather_api.get(city)

# Semantic function (Prompt template)
weather_prompt = """
Get the weather for {{$city}}.
Return only the temperature and conditions.
"""

weather_function = kernel.create_function_from_prompt(
    function_name="weather",
    plugin_name="weather",
    prompt=weather_prompt
)

Planners

Function Calling Planner

from semantic_kernel.planners import FunctionCallingStepwisePlanner

planner = FunctionCallingStepwisePlanner(
    service_id="gpt4o",
    max_iterations=10,
    max_tokens=4000
)

# Execute plan
result = await planner.invoke(
    kernel=kernel,
    goal="Calculate compound interest for $1000 at 5% for 10 years"
)
print(result.final_answer)

Plan Types

Handlebars Planner (New)

from semantic_kernel.planners import HandlebarsPlanner

planner = HandlebarsPlanner()
plan = await planner.create_plan(
    goal="Research and summarize AI trends",
    kernel=kernel
)

# Plan is Handlebars template
# {{#each steps}}
#   {{this.function}}({{this.arguments}})
# {{/each}}

result = await planner.execute_plan(plan, kernel)

Memory

Semantic Memory

from semantic_kernel.memory import (
    SemanticTextMemory,
    VolatileMemoryStore,
    RedisMemoryStore
)
from semantic_kernel.connectors.ai import OpenAITextEmbedding

# Embedding generator
embedding = OpenAITextEmbedding(
    service_id="embedding",
    ai_model_id="text-embedding-3-small",
    api_key="sk-..."
)

# Memory store
store = VolatileMemoryStore()  # Or RedisMemoryStore(...)
memory = SemanticTextMemory(storage=store, embeddings_generator=embedding)

# Save
await memory.save_information(
    collection="facts",
    id="fact-1",
    text="AI agents are autonomous systems."
)

# Search
results = await memory.search(
    collection="facts",
    query="What are AI agents?",
    limit=5,
    min_relevance_score=0.7
)

Chat History

from semantic_kernel.contents import ChatHistory

history = ChatHistory()
history.add_user_message("Hello")
history.add_assistant_message("Hi! How can I help?")

# Pass to kernel
result = await kernel.invoke(
    function=chat_function,
    input="What's the weather?",
    chat_history=history
)

Agents (New: Agent Framework)

Agent Definition

from semantic_kernel.agents import (
    ChatCompletionAgent,
    AssistantAgent,
    GroupChatAgent
)

agent = ChatCompletionAgent(
    service_id="gpt4o",
    name="Assistant",
    instructions="You are a helpful assistant.",
    plugins=[math_plugin, weather_plugin]
)

# Chat
async for message in agent.invoke(messages="What's 2+2?"):
    print(message.content)

Group Chat (Multi-Agent)

from semantic_kernel.agents import GroupChatAgent, GroupChatManager

agents = [
    ChatCompletionAgent(name="Researcher", instructions="Research topics"),
    ChatCompletionAgent(name="Writer", instructions="Write content"),
    ChatCompletionAgent(name="Editor", instructions="Review and edit")
]

manager = GroupChatManager(agents=agents, max_rounds=10)

async for message in manager.invoke("Write an article about AI agents"):
    print(f"{message.name}: {message.content}")

Connectors (AI Services)

Supported Services

Configuration

from semantic_kernel.connectors.ai.open_ai import (
    OpenAIChatCompletion,
    OpenAITextEmbedding
)
from semantic_kernel.connectors.ai.anthropic import AnthropicChatCompletion

# OpenAI
kernel.add_service(OpenAIChatCompletion(
    service_id="gpt4o",
    ai_model_id="gpt-4o",
    api_key="sk-...",
    org_id="org-..."
))

# Azure OpenAI
kernel.add_service(OpenAIChatCompletion(
    service_id="azure-gpt4o",
    ai_model_id="gpt-4o",
    api_key="...",
    endpoint="https://myresource.openai.azure.com",
    deployment_name="gpt-4o",
    api_version="2024-02-01"
))

# Anthropic
kernel.add_service(AnthropicChatCompletion(
    service_id="claude",
    ai_model_id="claude-3-5-sonnet",
    api_key="sk-ant-..."
))

Enterprise Features

Filtering (Safety)

from semantic_kernel.filters import FunctionInvocationFilter

async def safety_filter(context, next):
    if "dangerous" in context.arguments.get("input", ""):
        raise ValueError("Unsafe input detected")
    await next(context)

kernel.add_filter("function_invocation", safety_filter)

Telemetry

from semantic_kernel.telemetry import OpenTelemetry
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

kernel.add_telemetry(OpenTelemetry(
    exporter=OTLPSpanExporter(endpoint="http://otel:4317")
))

Dependency Injection

from semantic_kernel.kernel import Kernel
from semantic_kernel.connectors.ai import ServiceRegistry

# In FastAPI/ASP.NET Core
services.add_singleton(Kernel)
services.add_singleton(ServiceRegistry)

# Inject in controllers
class MyController:
    def __init__(self, kernel: Kernel):
        self.kernel = kernel

Vector Stores

Supported

from semantic_kernel.connectors.memory import (
    PineconeMemoryStore,
    QdrantMemoryStore,
    WeaviateMemoryStore,
    ChromaMemoryStore,
    AzureCognitiveSearchMemoryStore,
    RedisMemoryStore,
    VolatileMemoryStore
)

# Pinecone
store = PineconeMemoryStore(
    api_key="...",
    environment="us-west1-gcp",
    index_name="sk-memory"
)

memory = SemanticTextMemory(storage=store, embeddings_generator=embedding)

Deployment

FastAPI

from fastapi import FastAPI
import semantic_kernel as sk

app = FastAPI()
kernel = sk.Kernel()
# ... configure kernel

@app.post("/chat")
async def chat(request: ChatRequest):
    history = ChatHistory()
    for msg in request.messages:
        if msg.role == "user":
            history.add_user_message(msg.content)
        else:
            history.add_assistant_message(msg.content)

    result = await kernel.invoke(
        function=chat_function,
        input=request.message,
        chat_history=history
    )
    return {"response": str(result)}

Azure Functions

import azure.functions as func
import semantic_kernel as sk

kernel = sk.Kernel()  # Initialize once (global)

async def main(req: func.HttpRequest) -> func.HttpResponse:
    # Use shared kernel
    result = await kernel.invoke(...)
    return func.HttpResponse(str(result))

C# / .NET (Native)

// Kernel
var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion("gpt-4o", apiKey);
var kernel = builder.Build();

// Plugin
kernel.ImportPluginFromObject(new MathPlugin(), "math");

// Planner
var planner = new FunctionCallingStepwisePlanner();
var plan = await planner.CreatePlanAsync(kernel, "Calculate compound interest");
var result = await planner.ExecutePlanAsync(kernel, plan);

// Memory
var memory = new SemanticTextMemory(new VolatileMemoryStore(), embedding);
await memory.SaveInformationAsync("facts", "fact-1", "AI agents are autonomous.");

// Agent
var agent = new ChatCompletionAgent()
{
    Instructions = "You are helpful.",
    Kernel = kernel
};

Related Notes

• Framework Comparison — vs LangGraph, AutoGen
• AutoGen — Microsoft's other framework
• OpenAI Agents SDK — OpenAI's alternative
• Memory Systems — Semantic memory patterns
• Mixture of Experts — Service routing
• Observability — OpenTelemetry integration
• Deployment Architecture — Enterprise deployment

Sources: Semantic Kernel docs (learn.microsoft.com/semantic-kernel), Semantic Kernel GitHub (microsoft/semantic-kernel), Microsoft Learn modules, SK C# and Python samples, Azure AI integration docs.