CtrlK
Semantic Kernel is a lightweight, open-source software development kit (SDK) created by Microsoft that enables developers to build AI agents, integrate large language models (LLMs) into applications, and orchestrate complex agentic workflows. First released publicly on March 17, 2023, Semantic Kernel provides a model-agnostic abstraction layer that connects application code to AI services from providers such as OpenAI, Azure OpenAI, Google Gemini, Anthropic Claude, Mistral AI, and others. The SDK supports three programming languages: C#, Python, and Java.
Semantic Kernel serves as middleware between enterprise application logic and AI model capabilities. It is used internally by Microsoft to power products such as Microsoft 365 Copilot and is adopted by Fortune 500 companies for production AI workloads. As of March 2026, the project has accumulated over 27,500 stars on GitHub and is licensed under the MIT License.
Microsoft publicly released Semantic Kernel on GitHub on March 17, 2023, during a period of rapid growth in the LLM ecosystem following the launch of ChatGPT in late 2022. The project was developed within Microsoft's AI division as a way to help enterprise developers integrate LLM capabilities into existing codebases without rewriting their applications from scratch.
The SDK was presented at Microsoft BUILD 2023 (May 23-25, 2023), where Microsoft demonstrated how Semantic Kernel could be used to build AI-powered applications and copilot-style experiences. During its first year, the project attracted significant developer interest, reaching over 17,000 GitHub stars, 840,000 NuGet downloads for the C# package, and a Discord community of more than 5,000 members.
The .NET (C#) kernel reached version 1.0 in early 2024, while the Python and Java kernels achieved 1.0 Release Candidate status around the same time. The 1.0 release marked a commitment to API stability and non-breaking changes, giving enterprise users the confidence to build production systems on the framework.
As of early 2026, the .NET package (Microsoft.SemanticKernel) has reached version 1.74.0 on NuGet, reflecting a rapid cadence of incremental releases. The Python package is distributed via PyPI, and the Java packages are available through Maven.
On October 1, 2025, Microsoft announced the Microsoft Agent Framework, a new open-source project that merges the capabilities of Semantic Kernel with AutoGen, Microsoft Research's multi-agent orchestration framework. The Agent Framework combines AutoGen's simple agent abstractions for single- and multi-agent patterns with Semantic Kernel's enterprise-grade features including session-based state management, type safety, filters, telemetry, and extensive model and embedding support.
The Microsoft Agent Framework reached Release Candidate status for both .NET and Python, with a general availability target of Q1 2026. Both Semantic Kernel and AutoGen remain supported as standalone projects, but most new investment from Microsoft is focused on the unified Agent Framework going forward.
Semantic Kernel is built around a central Kernel object that acts as the orchestrator for all AI interactions. The Kernel manages the execution of functions and plugins, handles data flow between components, and provides access to services such as AI model connectors, vector stores, and prompt engineering templates.
The architecture follows a modular, extensible design. Developers only import the packages they need for their specific use case. The framework is organized around several core concepts.
The Kernel is the central object in every Semantic Kernel application. It acts as a dependency injection container and orchestration engine. Developers register AI services, plugins, and configuration with the Kernel, which then coordinates the interactions between these components during execution. When a user request comes in, the Kernel manages the process of sending prompts to AI services, handling function calling requests, invoking the appropriate plugin functions, and returning results.
AI service connectors provide an abstraction layer that exposes multiple AI service types from different providers through a common interface. The supported service modalities include:
| Service modality | Description | C# | Python | Java |
|---|---|---|---|---|
| Chat Completion | Conversational AI interactions (e.g., GPT-4, Claude) | Yes | Yes | Yes |
| Text Generation | Standalone text generation (e.g., Text-Davinci) | Yes | Yes | Yes |
| Text Embeddings | Vector embedding generation | Yes | Yes | Yes |
| Text to Image | Image generation (e.g., DALL-E) | Yes | Yes | No |
| Image to Text | Image captioning and analysis | Yes | No | No |
| Text to Audio | Speech synthesis | Yes | Yes | No |
| Audio to Text | Speech recognition (e.g., Whisper) | Yes | Yes | No |
The following AI providers have official connectors in Semantic Kernel:
| Provider | C# | Python | Java |
|---|---|---|---|
| OpenAI | Yes | Yes | Yes |
| Azure OpenAI | Yes | Yes | Yes |
| Google (Gemini) | Yes | Yes | Yes |
| Anthropic (Claude) | Yes | Yes | No |
| Mistral AI | Yes | Yes | No |
| Amazon Bedrock | Yes | Yes | No |
| Azure AI Inference | Yes | Yes | No |
| Hugging Face | Yes | Yes | No |
| Ollama (local models) | Yes | Yes | No |
| ONNX (local models) | Yes | Yes | No |
| Other OpenAI-compatible APIs | Yes | Yes | Yes |
When an AI service connector is registered with the Kernel, Chat Completion or Text Generation services are used by default for any method calls to the Kernel. This design means developers can swap AI providers without changing application logic.
Plugins are named containers of functions that can be exposed to AI applications and services. They are one of the most important concepts in Semantic Kernel, enabling developers to encapsulate existing APIs and business logic into reusable units that LLMs can invoke through function calling.
Each plugin function includes semantic descriptions of its purpose, inputs, outputs, and side effects. The LLM uses these descriptions to determine which functions to call and with what parameters when processing a user request.
Plugins can be imported from three primary sources:
Within a plugin, functions typically fall into two categories: data retrieval functions (used for retrieval augmented generation scenarios) and task automation functions (used to perform actions in external systems). In enterprise applications, plugins integrate naturally with dependency injection, so a plugin constructor can receive database connections, HTTP clients, and other services.
Early versions of Semantic Kernel included dedicated planner components that used prompts to instruct the AI to choose which functions to invoke. These planners included the SequentialPlanner, BasicPlanner, ActionPlanner, and StepwisePlanner. However, as LLM providers introduced native function calling capabilities (starting with OpenAI models from June 2023 onward), the planning approach in Semantic Kernel evolved.
The Stepwise and Handlebars planners have been deprecated and removed from the Semantic Kernel package. The framework now uses function calling as the primary mechanism for planning and executing tasks. Function calling is a native capability of most modern LLMs, including models from OpenAI, Google, Anthropic, and Mistral.
With function calling, the planning loop works as follows:
Semantic Kernel automates this entire loop, handling the marshaling of requests and responses between the application, the Kernel, and the AI model. Developers enable automatic function calling by setting the FunctionChoiceBehavior to Auto() in their execution settings.
Prompt templates allow developers and prompt engineers to create reusable templates that combine instructions for the AI model with placeholders for user input and calls to plugin functions. Templates can serve two purposes: as starting points for chat completion flows, or as plugin functions themselves that can be invoked by other templates or by the LLM.
Semantic Kernel supports multiple template formats:
| Template format | C# | Python | Java |
|---|---|---|---|
| Semantic Kernel template language | Yes | Yes | Yes |
| Handlebars | Yes | Yes | Yes |
| Liquid | Yes | No | No |
| Jinja2 | No | Yes | No |
Templates can also be serialized in YAML or Prompty format for storage and sharing across teams.
Filters provide a mechanism for executing custom logic before and after specific events during the chat completion flow. Two types of filters are available:
Filters enable enterprise features such as content safety validation, logging, telemetry collection, and request/response modification. They are registered with the Kernel and are invoked automatically during the execution pipeline.
Semantic Kernel provides a unified abstraction for working with vector databases, enabling developers to store and search embeddings for retrieval augmented generation (RAG) and semantic memory scenarios. The Vector Store connectors expose a common interface across different database providers, making it possible to switch between providers without changing application code.
The following vector store connectors are available out of the box for C#:
| Vector store | C# | Python | Java | Maintainer |
|---|---|---|---|---|
| In-Memory | Yes | Yes | Yes | Microsoft |
| Azure AI Search | Yes | Yes | Yes | Microsoft |
| Azure Cosmos DB (MongoDB) | Yes | Yes | No | Microsoft |
| Azure Cosmos DB (NoSQL) | Yes | Yes | No | Microsoft |
| Elasticsearch | Yes | Planned | No | Elastic |
| MongoDB | Yes | Yes | No | Microsoft |
| Pinecone | Yes | Yes | No | Microsoft |
| PostgreSQL | Yes | Yes | Via JDBC | Microsoft |
| Qdrant | Yes | Yes | No | Microsoft |
| Redis | Yes | Yes | Yes | Microsoft |
| SQL Server | Yes | Yes | No | Microsoft |
| SQLite | Yes | Planned | Via JDBC | Microsoft |
| Weaviate | Yes | Yes | No | Microsoft |
| Chroma | Planned | Yes | No | Microsoft |
| Faiss | No | Yes | No | Microsoft |
| Oracle | Yes | Yes | Yes | Oracle |
| Couchbase | Yes | No | No | Couchbase |
Each connector is distributed as a separate package, so developers only include the dependencies they need. Vector Search can be exposed as a plugin to the Kernel, making it available for prompt templates and chat completion models to use during function calling.
The Semantic Kernel Agent Framework provides tools for building modular AI agents with access to plugins, memory, and planning capabilities. An agent in Semantic Kernel is an abstraction that wraps an AI model with a set of instructions, plugins, and configuration, enabling the model to act autonomously on behalf of a user.
Semantic Kernel supports several agent types:
The Agent Orchestration framework enables developers to coordinate multiple agents working together on complex tasks. The framework supports several orchestration patterns:
| Pattern | Description | Use case |
|---|---|---|
| Sequential | Passes results from one agent to the next in a defined order | Step-by-step workflows, pipelines, multi-stage processing |
| Concurrent | Broadcasts a task to all agents, collects results independently | Parallel analysis, independent subtasks, ensemble decision making |
| Handoff | Dynamically passes control between agents based on context or rules | Escalation, fallback, expert handoff scenarios |
| Group Chat | All agents participate in a group conversation, coordinated by a manager | Brainstorming, collaborative problem solving, consensus building |
| Magentic | Group chat-like orchestration inspired by MagenticOne | Complex, generalist multi-agent collaboration |
All orchestration patterns share a unified interface. Developers define agents and their capabilities, create an orchestration by passing the agents, start a runtime, and invoke the orchestration with a task. This unified design allows switching between orchestration patterns without rewriting agent logic.
The Process Framework is a component of Semantic Kernel designed for automating structured business workflows. While the Agent Framework handles dynamic, AI-driven tasks, the Process Framework provides explicit control over workflow execution through a step-based model.
The framework is built on three foundational concepts:
Steps can be code-only, call external APIs, use AI agents through the Agent Framework, incorporate human-in-the-loop interactions, or combine all of these approaches. Steps and processes can be reused across different applications, promoting modularity.
The Process Framework supports two deployment options: local deployment (for running on a single machine or server) and cloud runtimes (using Dapr or Orleans for distributed, scalable scenarios).
Semantic Kernel has first-class support for the Model Context Protocol (MCP), a standard created by Anthropic to enable models, tools, and agents to share context and capabilities across different systems.
Semantic Kernel can act in two roles with MCP:
The SDK supports multiple MCP transport types including stdio, SSE (Server-Sent Events), and Streamable HTTP. MCP support requires Semantic Kernel Python version 1.28.1 or higher. In C#, MCP plugins are available through the MCPStdioPlugin and MCPStreamableHttpPlugin classes.
Key benefits of MCP integration include interoperability (existing Semantic Kernel plugins can be exposed to non-SK applications), content safety (validating tool calls using Semantic Kernel Filters before execution), and observability (collecting tool call logs, traces, and metrics).
Semantic Kernel is available for three programming languages, with the C# SDK having the most complete feature set. The minimum runtime requirements are .NET 10.0+ for C#, Python 3.10+ for Python, and JDK 17+ for Java.
The C# SDK is distributed through NuGet as a collection of modular packages:
| Package | Description |
|---|---|
| Microsoft.SemanticKernel | Main package with everything needed to get started |
| Microsoft.SemanticKernel.Abstractions | Base abstractions for the framework |
| Microsoft.SemanticKernel.Connectors.OpenAI | AI connector for OpenAI |
| Microsoft.SemanticKernel.Connectors.AzureOpenAI | AI connector for Azure OpenAI |
| Microsoft.SemanticKernel.Connectors.Google | AI connector for Google models |
| Microsoft.SemanticKernel.Connectors.MistralAI | AI connector for Mistral AI |
| Microsoft.SemanticKernel.Connectors.HuggingFace | AI connector for Hugging Face |
| Microsoft.SemanticKernel.Connectors.Ollama | AI connector for Ollama (local models) |
| Microsoft.SemanticKernel.Connectors.Onnx | AI connector for ONNX (local models) |
| Microsoft.SemanticKernel.Connectors.Amazon | AI connector for Amazon Bedrock |
| Microsoft.SemanticKernel.Plugins.OpenApi | Plugin loading from OpenAPI specs |
| Microsoft.SemanticKernel.Agents.Abstractions | Abstractions for creating agents |
| Microsoft.SemanticKernel.Agents.OpenAI | Support for OpenAI Assistants API agents |
The Python SDK is distributed as a single package via PyPI:
pip install semantic-kernel
Optional extras can be installed for specific providers:
pip install semantic-kernel[azure]
pip install semantic-kernel[hugging_face]
The [azure] extra installs tested versions of azure-ai-inference, azure-search-documents, azure-core, azure-identity, azure-cosmos, and msgraph-sdk.
The Java SDK is distributed through Maven under the group ID com.microsoft.semantic-kernel. A Bill of Materials (BOM) artifact (semantickernel-bom) is provided for consistent version management. The core packages include semantickernel-api for the public API and semantickernel-connectors-ai-openai for OpenAI integration.
Semantic Kernel was designed with enterprise readiness as a primary goal. Several features support production deployment scenarios.
The SDK supports OpenTelemetry for distributed tracing, logging, and metrics collection. This allows developers to monitor AI interactions, track function call chains, measure latency, and debug issues in production environments. OpenTelemetry support is available in C# and Python.
Filters enable developers to implement content safety checks, input validation, and output moderation at multiple points in the execution pipeline. Function invocation filters can block or modify requests before they reach plugin functions, while prompt rendering filters can enforce content policies before prompts are sent to AI models.
Semantic Kernel integrates with standard dependency injection patterns in each supported language. In C#, the Kernel builder works with Microsoft.Extensions.DependencyInjection. Plugins can receive injected services through their constructors, making it straightforward to integrate with existing enterprise service architectures.
Semantic Kernel is one of several AI orchestration frameworks available to developers. The most common comparison is with LangChain, though each framework has distinct strengths.
| Feature | Semantic Kernel | LangChain | LlamaIndex |
|---|---|---|---|
| Primary languages | C#, Python, Java | Python, JavaScript | Python, TypeScript |
| Developer | Microsoft | LangChain Inc. | LlamaIndex Inc. |
| License | MIT | MIT | MIT |
| Enterprise focus | Strong (Azure integration, telemetry, filters) | Moderate | Moderate |
| Plugin system | Native plugin architecture with DI support | Tools and toolkits | Tools and tool specs |
| Planning approach | Function calling (native LLM feature) | Agents, chains, LangGraph | Agents, query engines |
| Vector store support | 15+ connectors | 20+ integrations | 15+ integrations |
| Multi-agent support | Sequential, concurrent, handoff, group chat, magentic | LangGraph for multi-agent | Limited |
| Cloud alignment | Azure-native | Cloud-agnostic | Cloud-agnostic |
| MCP support | Yes (client and server) | Yes (client) | Limited |
Semantic Kernel is typically the preferred choice for teams working within the Microsoft and Azure ecosystem, building applications in C# or Java, or requiring enterprise features such as built-in telemetry and dependency injection. LangChain tends to be favored by Python-first teams that value a large community and broad integration options. LlamaIndex focuses more specifically on data retrieval and RAG workflows.
using Microsoft.SemanticKernel;
var builder = Kernel.CreateBuilder()
.AddAzureOpenAIChatCompletion(modelId, endpoint, apiKey);
Kernel kernel = builder.Build();
var result = await kernel.InvokePromptAsync("What is artificial intelligence?");
Console.WriteLine(result);
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.functions import kernel_function
class WeatherPlugin:
@kernel_function(description="Gets the weather for a city")
def get_weather(self, city: str) -> str:
return f"The weather in {city} is sunny, 72F."
kernel = Kernel()
kernel.add_service(AzureChatCompletion())
kernel.add_plugin(WeatherPlugin(), plugin_name="Weather")
Semantic Kernel has an active open-source community. The project is hosted on GitHub at microsoft/semantic-kernel for the main C# and Python codebase, with a separate repository at microsoft/semantic-kernel-java for the Java SDK. The community communicates through a Discord server and GitHub Discussions.
Notable community resources include the awesome-semantickernel list on GitHub, which catalogs third-party tools, plugins, and sample projects built with the framework. Microsoft publishes regular updates through the Semantic Kernel blog on devblogs.microsoft.com and presents new features at conferences such as Microsoft BUILD and Microsoft Ignite.