semantic-kernel

Semantic Kernel abstracts LLM interactions through a unified kernel interface that decouples prompt definitions from specific model implementations. Prompts are defined as semantic functions with templating support (Handlebars/Jinja2), and the kernel routes execution to configurable LLM services (OpenAI, Azure OpenAI, Anthropic, local models) without changing function code. This enables switching between models and providers by configuration alone.

Semantic Kernel allows developers to define semantic functions (LLM-powered functions) that can be stored, retrieved, and executed with automatic context injection from memory systems. Functions are defined via YAML/JSON manifests or Python decorators, and the kernel manages function registration, parameter binding, and memory context enrichment (RAG-style). This creates a unified namespace where functions can reference stored knowledge without explicit retrieval code.

Semantic Kernel abstracts LLM service interactions through pluggable connectors (OpenAI, Azure OpenAI, Anthropic, Ollama, HuggingFace) that implement a common interface. Connectors handle authentication, request formatting, response parsing, and error handling for each provider. This enables switching between providers by changing configuration, and adding new providers by implementing the connector interface without modifying kernel code.

Semantic Kernel can enforce structured outputs from LLMs by specifying JSON schemas and parsing/validating responses against them. The kernel can request LLMs to return JSON (via prompting or function calling), parse the response, and validate it against a schema. This enables type-safe LLM outputs that can be directly used in downstream code without manual parsing or error handling.

Semantic Kernel implements a plugin architecture where native functions (Python code) and semantic functions (LLM-powered) are registered as skills within a unified plugin system. Plugins are discoverable collections of functions that can be composed into multi-step workflows. The kernel handles function resolution, parameter binding, and execution order, enabling complex orchestration patterns like function chaining and conditional branching without explicit workflow DSLs.

Semantic Kernel provides a memory abstraction layer that manages embeddings and vector storage through pluggable connectors (Azure Cognitive Search, Pinecone, Weaviate, in-memory). The kernel automatically handles embedding generation, storage, and retrieval without requiring developers to manage embedding models or vector databases directly. Memory is integrated with semantic functions, enabling automatic context enrichment for RAG patterns.

Semantic Kernel enables LLMs to call native Python functions through a schema-based function calling mechanism. The kernel exposes native functions to the LLM via JSON schemas, the LLM generates function call specifications, and the kernel validates and executes them. This creates a closed loop where LLMs can invoke arbitrary Python code with automatic parameter validation and type coercion, enabling agent patterns where LLMs decide which tools to use.

Semantic Kernel provides a templating engine (Handlebars/Jinja2) for defining prompts with variable placeholders, conditional logic, and filters. Templates support dynamic variable injection from kernel context, memory retrieval, and function outputs. This enables parameterized prompts that adapt to runtime context without string concatenation or manual formatting, reducing prompt injection vulnerabilities and improving maintainability.

Semantic Kernel supports streaming LLM responses at the token level, enabling real-time output display and token counting without buffering entire responses. The kernel provides streaming iterators that yield tokens as they arrive from the LLM service, allowing applications to process responses incrementally. This is critical for user-facing applications requiring low latency and token-based billing calculations.

Semantic Kernel manages conversation history and multi-turn context through a chat history abstraction that tracks messages, roles (user/assistant/system), and metadata. The kernel automatically maintains context across turns, handles token limits by truncating history, and integrates history with semantic functions for context-aware responses. This simplifies building multi-turn conversational agents without manual history management.

Semantic Kernel provides native async/await support throughout its API, enabling non-blocking LLM calls, concurrent function execution, and efficient resource utilization. All kernel operations (LLM calls, memory retrieval, function execution) have async variants, allowing applications to handle multiple requests concurrently without thread pools. This is critical for scalable server-side applications and responsive client applications.

Semantic Kernel includes a planning system that uses LLMs to decompose complex tasks into executable plans (sequences of semantic and native functions). The planner generates plans in a structured format (e.g., YAML), the kernel validates the plan against available functions, and then executes it step-by-step. This enables agents to reason about task decomposition without explicit workflow definition, supporting dynamic planning based on available skills.