Microsoft Semantic Kernel: LLM Orchestration for .NET & Python

Python Quick Start: Kernel & Semantic Functions

Create a Kernel, add an AI service, define a semantic function, and invoke it with chat history.

pip install semantic-kernel

import asyncio
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAITextEmbedding
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.contents import ChatHistory

async def main():
    # Create the kernel
    kernel = Kernel()

    # Add AI services
    kernel.add_service(OpenAIChatCompletion(
        service_id="gpt4",
        ai_model_id="gpt-4o-mini",
        api_key="YOUR_OPENAI_KEY"
    ))

    # Or use Azure OpenAI
    # from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
    # kernel.add_service(AzureChatCompletion(
    #     service_id="azure_gpt4",
    #     deployment_name="gpt-4o",
    #     endpoint="https://YOUR.openai.azure.com/",
    #     api_key="YOUR_AZURE_KEY"
    # ))

    # Define a semantic function (prompt template)
    summarize_fn = kernel.add_function(
        plugin_name="TextPlugin",
        function_name="summarize",
        prompt="Summarize the following text in 2-3 sentences:\n\n{{$input}}",
        description="Summarizes a text passage"
    )

    result = await kernel.invoke(summarize_fn, input="Semantic Kernel is Microsoft's SDK for integrating LLMs into applications...")
    print(result)

asyncio.run(main())

Plugins: Semantic + Native Functions

Combine LLM semantic functions with regular Python code in a single plugin — the LLM can call both as tools.

from semantic_kernel.functions import kernel_function
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings
import datetime, httpx

class DevToolsPlugin:
    """Plugin with native + semantic functions for developer tools."""

    @kernel_function(name="get_current_date", description="Returns today's date")
    def get_current_date(self) -> str:
        return datetime.date.today().isoformat()

    @kernel_function(name="fetch_url", description="Fetches the content of a URL")
    async def fetch_url(self, url: str) -> str:
        async with httpx.AsyncClient() as client:
            resp = await client.get(url, timeout=10)
            return resp.text[:2000]  # first 2000 chars

    @kernel_function(
        name="generate_commit_message",
        description="Generate a git commit message for a code diff"
    )
    async def generate_commit_message(
        self, kernel: "Kernel", diff: str
    ) -> str:
        prompt = f"Write a concise git commit message for this diff:\n\n{diff}"
        result = await kernel.invoke_prompt(prompt)
        return str(result)

# Register the plugin
kernel.add_plugin(DevToolsPlugin(), plugin_name="DevTools")

# Let the LLM autonomously pick and call tools
settings = OpenAIChatPromptExecutionSettings(
    function_choice_behavior=FunctionChoiceBehavior.Auto()  # LLM decides which tools to call
)

chat_history = ChatHistory()
chat_history.add_user_message("What is today's date and what day of the week is it?")

response = await kernel.invoke_prompt(
    prompt_template_config=None,
    chat_history=chat_history,
    settings=settings
)
print(response)

Memory: Semantic Recall with Vector Stores

Save and retrieve memories using semantic similarity — connects to Chroma, Qdrant, Azure AI Search, and more.

from semantic_kernel.connectors.memory.chroma import ChromaMemoryStore
from semantic_kernel.core_plugins.text_memory_plugin import TextMemoryPlugin

# Add embedding service for memory
kernel.add_service(OpenAITextEmbedding(
    service_id="embedder",
    ai_model_id="text-embedding-3-small",
    api_key="YOUR_OPENAI_KEY"
))

# Use Chroma as the vector memory store
memory_store = ChromaMemoryStore(persist_directory="./sk_memory")

# Register the memory plugin
await kernel.add_plugin(TextMemoryPlugin(memory_store), plugin_name="memory")

# Save facts to memory
await kernel.memory.save_information(
    collection="user_prefs",
    id="pref-1",
    text="The user prefers Python over JavaScript for backend development",
)
await kernel.memory.save_information(
    collection="user_prefs",
    id="pref-2",
    text="The user uses PostgreSQL with pgvector for vector search",
)

# Retrieve semantically similar memories
memories = await kernel.memory.search(
    collection="user_prefs",
    query="What database does the user prefer?",
    limit=2,
    min_relevance_score=0.7
)
for mem in memories:
    print(f"score={mem.relevance:.3f} | {mem.text}")

Semantic Kernel vs LangChain vs LlamaIndex