◆ AI Agent Frameworks

Semantic Kernel

dotnet-1.80.0 open-source

Integrate cutting-edge LLM technology quickly and easily into your apps

source ↗ website ↗ rss ↗ last repo push Aug 20, 2026

var settings = new OllamaPromptExecutionSettings { Think = true };
var result = await kernel.InvokePromptAsync(prompt, new(settings));
var fakeTime = new FakeTimeProvider();
fakeTime.SetUtcNow(new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero));
var timePlugin = new TimePlugin(fakeTime);
kernel.Plugins.AddFromObject(timePlugin);
var settings = new OllamaPromptExecutionSettings { Think = true };
var result = await kernel.InvokePromptAsync("Explain quantum entanglement.", new KernelArguments(settings));
var settings = new OpenAIPromptExecutionSettings
{
    ExtraBody = new { reasoning_effort = "high", parallel_tool_calls = false }
};
from semantic_kernel.core_plugins.http_plugin import HttpPlugin

http_plugin = HttpPlugin(allowed_domains=["api.example.com", "data.internal.corp"])
kernel.add_plugin(http_plugin, plugin_name="http")
from semantic_kernel.core_plugins.http_plugin import HttpPlugin

plugin = HttpPlugin(allowed_domains=["api.example.com", "data.trusted.org"])
var executionSettings = new GeminiPromptExecutionSettings
{
    IncludeThoughts = true
};
var result = await chatService.GetChatMessageContentsAsync(history, executionSettings, kernel);
var executionSettings = new GeminiPromptExecutionSettings
{
    ThinkingConfig = new GeminiThinkingConfig
    {
        ThinkingLevel = ThinkingLevel.High
    }
};
var result = await chatService.GetChatMessageContentsAsync(history, executionSettings, kernel);
kernel.add_plugin(plugin_name='MyPlugin', parent_directory='./plugins', encoding='latin-1')
service = BedrockChatCompletion(model_id='anthropic.claude-v2', model_provider='anthropic')
var plugin = AgentKernelPluginFactory.CreateFromAgents("AgentTools", agentA, agentB);
kernel.Plugins.Add(plugin);
using Microsoft.SemanticKernel;

ChatMessageContent skContent = new(AuthorRole.Assistant, "Hello!");
var meaiContent = skContent.ToAIContent();
merged_args = KernelArguments(foo='bar') | KernelArguments(baz='qux')
result = await kernel.invoke(my_function, merged_args)
using Microsoft.SemanticKernel.Connectors.Google;

var metadata = GeminiKernelFunctionMetadataExtensions.ToGeminiFunctionMetadata(function.Metadata);
from semantic_kernel.kernel_arguments import KernelArguments

base = KernelArguments(city='Seattle', unit='metric')
overrides = KernelArguments(unit='imperial', verbose=True)
merged = base | overrides
# merged: {city: 'Seattle', unit: 'imperial', verbose: True}
var textSearch = new VectorStoreTextSearch<MyRecord>(vectorStore, embeddingGenerator);
settings = OpenAIChatPromptExecutionSettings(extra_body={"reasoning_effort": "high"})
await process.start(kernel=kernel, initial_event=start_event, max_supersteps=20)
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    extra_body={'reasoning_effort': 'high', 'store': True}
)
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    extra_body={"reasoning_effort": "high", "data_sources": []}
)
from semantic_kernel import Kernel

original_kernel = Kernel()
# ... register plugins, services, etc.
cloned_kernel = original_kernel.clone()
cloned_kernel.add_plugin(extra_plugin)
var braveConnector = new BraveConnector(apiKey: "<your-brave-api-key>");
var webSearchPlugin = new WebSearchEnginePlugin(braveConnector);
kernel.ImportPluginFromObject(webSearchPlugin, "WebSearch");
async def handle_intermediate(message):
    print(f'Intermediate: {message}')

async for response in agent.invoke(
    thread=thread,
    on_intermediate_message=handle_intermediate,
):
    print(response)
var settings = new OpenAIPromptExecutionSettings
{
    WebSearchEnabled = true
};
var result = await kernel.InvokePromptAsync("What happened in the news today?", new(settings));
var vectorStore = new SqlServerVectorStore("Server=myserver;Database=mydb;Trusted_Connection=True;");
response = await agent.get_response(chat_history)
agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    instructions="Answer questions about the world.",
    plugins=[SamplePlugin()],
)
from semantic_kernel.agents.autogen.autogen_conversable_agent import AutoGenConversableAgent

cathy_autogen_agent = AutoGenConversableAgent(conversable_agent=cathy)
joe_autogen_agent = AutoGenConversableAgent(conversable_agent=joe)

async for content in cathy_autogen_agent.invoke(
    recipient=joe_autogen_agent, message="Tell me a joke about the stock market.", max_turns=3
):
    print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
var agent = new ChatCompletionAgent
{
    Name = "Analyst",
    Instructions = "You are a data analyst.",
    RoleOverride = AuthorRole.System
};
async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(
        credential=creds,
        conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
    ) as client,
):
    # Operational code here
# From the repo root
python python/samples/getting_started_with_agents/azure_ai_agent/step1_azure_ai_agent.py
chat_service = OpenAIChatCompletion(service_id=service_id, instruction_role="developer")
var settings = new GeminiPromptExecutionSettings
{
    CachedContent = "cachedContents/my-cached-system-prompt"
};
var result = await kernel.InvokePromptAsync(prompt, new KernelArguments(settings));
var settings = new OpenAIPromptExecutionSettings
{
    Store = true,
    Metadata = new Dictionary<string, string> { { "session", "abc123" } }
};
from semantic_kernel.connectors.ai.open_ai import OpenAIPromptExecutionSettings

settings = OpenAIPromptExecutionSettings(
    store="my-response-store",
    metadata={"session_id": "abc123", "user": "alice"}
)

result = await kernel.invoke_prompt(
    prompt="Summarize the following document.",
    settings=settings
)
var settings = new GeminiPromptExecutionSettings
{
    AudioTimestamp = true
};
var result = await kernel.InvokeAsync(audioToTextFunction, new KernelArguments(settings));
// Wrap an SK IChatCompletionService as an ME.AI IChatClient
IChatClient chatClient = kernel.GetRequiredService<IChatCompletionService>().AsChatClient();
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    parallel_tool_calls=False
)
await foreach (var response in agent.InvokeStreamingAsync(thread))
{
    Console.WriteLine(response.Content);
}
from semantic_kernel.connectors.ai.google_ai import GoogleAIChatCompletion

chat_service = GoogleAIChatCompletion(
    gemini_model_id="gemini-1.5-pro",
    api_key="<your-google-ai-api-key>"
)
var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
var memoryPlugin = new TextMemoryPlugin(memory, jsonSerializerOptions: options);
kernel.ImportPluginFromObject(memoryPlugin);
await foreach (var update in kernel.InvokeStreamingAsync<StreamingChatMessageContent>(function, arguments))
{
    if (update.Items.OfType<StreamingFunctionCallUpdateContent>().Any())
    {
        // Handle incremental function call content in real time
        foreach (var callUpdate in update.Items.OfType<StreamingFunctionCallUpdateContent>())
            Console.Write(callUpdate.Arguments);
    }
}
var executionSettings = new AzureOpenAIPromptExecutionSettings
{
    AzureChatExtensionsOptions = new AzureChatExtensionsOptions
    {
        Extensions = { new AzureSearchChatExtensionConfiguration { ... } }
    }
};
public class MyPlugin
{
    [KernelFunction]
    internal string GetSecret(string key) => _vault.Get(key);
}
var embeddingService = new OpenAITextEmbeddingGenerationService(
    modelId: "text-embedding-3-small",
    apiKey: "<your-api-key>",
    dimensions: 256
);
from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior

filter = {"excluded_plugins": ["ChatBot"]}
req_settings.function_call_behavior = FunctionCallBehavior.EnableFunctions(auto_invoke=True, filters=filter)
from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior

req_settings.function_call_behavior = FunctionCallBehavior.AutoInvokeKernelFunctions()
builder.AddOpenAITextEmbeddingGeneration(
    modelId: "text-embedding-3-small",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY"),
    dimensions: 512);
var strategy = new KernelFunctionSelectionStrategy(selectionFunction, kernel);
var chat = new AgentGroupChat(agentA, agentB)
{
    ExecutionSettings = new AgentGroupChatSettings
    {
        SelectionStrategy = strategy
    }
};
from semantic_kernel import Kernel
from semantic_kernel.functions import kernel_function

class MyPlugin:
    @kernel_function(name="greet", description="Greet a user")
    def greet(self, name: str) -> str:
        return f"Hello, {name}!"

kernel = Kernel()
kernel.add_plugin(MyPlugin(), plugin_name="MyPlugin")
var plugin = await kernel.ImportPluginFromApiManifestAsync(
    pluginName: "MyMultiApiPlugin",
    filePath: "./plugins/myPlugin/apimanifest.json",
    new ApiManifestPluginParameters());
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    auto_invoke_kernel_functions=True,
    max_auto_invoke_attempts=5
)
result = await kernel.invoke_prompt(prompt, settings=settings)
var settings = new OpenAIPromptExecutionSettings
{
    ResponseFormat = "json_object"
};
var result = await kernel.InvokePromptAsync(prompt, new(settings));
builder.Services.AddSingleton<OpenAIClient>(sp => new OpenAIClient(new Uri(endpoint), new AzureKeyCredential(apiKey)));
builder.Services.AddAzureOpenAIChatCompletion(deploymentName: "gpt-4");
from semantic_kernel.connectors.ai.open_ai import OpenAITextPromptExecutionSettings
from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig

config = PromptTemplateConfig(
    template="Classify the sentiment: {{$input}}",
    token_selection_biases={1234: -100, 5678: 50}
)

Summary

Semantic Kernel is an open-source model-agnostic SDK that lets developers build and orchestrate AI agents and multi-agent systems. It is MIT licensed and functions as a library imported into code, supporting Python, .NET, and Java runtimes. The SDK is intended for application developers building intelligence workflows, and its documentation positions it alongside the Microsoft Agent Framework. The project has maintained active development with stable APIs and a commitment to long-term support.

Integrate cutting-edge LLM technology quickly and easily into your apps

What Semantic Kernel answers

Which programming languages can I use with this framework?

Python, .NET, and Java runtimes are supported

Can I connect to different AI models?

It supports connection to various models including OpenAI, Azure OpenAI, and Hugging Face

What operating systems can run this?

The SDK supports Windows, macOS, and Linux

Does it handle connecting multiple agents together?

It provides tools for orchestrating multi-agent workflows

Is there a specific version required for each language?

Python requires version 3.10 or newer, .NET requires 10.0 or newer, and Java requires JDK 17 or newer

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

dotnet-1.80.0 Aug 18, 2026 · issue 002

Gemini connector now honors FunctionChoiceBehavior function lists; MEVD providers migrated with redirect READMEs.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.80.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.80.0
```
- ›The Gemini connector now correctly respects the FunctionChoiceBehavior function list, ensuring only specified functions are offered to the model during tool-calling.
- ›Removes migrated .NET Memory-Enhanced Vector Database (MEVD) providers from the main package and adds redirect READMEs pointing to their new locations.
python-1.44.1 Aug 6, 2026 · issue -013

Semantic Kernel Python 1.44.1 adds MCP tool approval callback for Azure AI Agent and skips colliding MCP tool names.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.44.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.44.1
```
- ›Adds MCP tool approval callback for Azure AI Agent, enabling programmatic review and approval of MCP tool invocations before execution.
- ›Skips MCP tools and prompts whose normalized names collide, preventing silent conflicts when multiple MCP sources expose identically named tools.
- ›Encodes OpenAPI server variable values to handle special characters in server URL construction.
└──▷ BREAKING ON UPGRADE
- !The MCP tool approval callback for Azure AI Agent is marked as a breaking change — existing Azure AI Agent setups using MCP tools may require updates to accommodate the new callback interface.
python-1.44.1 Aug 6, 2026 · issue 002

Semantic Kernel python-1.44.1 adds MCP tool approval callbacks for Azure AI Agent and skips colliding MCP tool/prompt names.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.44.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.44.1
```
- ›Adds MCP tool approval callback support for Azure AI Agent, enabling human-in-the-loop control over which MCP tools an agent is allowed to invoke.
- ›Skips MCP tools and prompts whose normalized names collide, preventing silent overwrites when multiple MCP sources expose identically named surfaces.
- ›Encodes OpenAPI server variable values to handle special characters in server URLs correctly.
└──▷ BREAKING ON UPGRADE
- !The MCP tool approval callback addition for Azure AI Agent is marked as a breaking change — existing Azure AI Agent setups using MCP tools may require updates to accommodate the new callback interface.
dotnet-1.79.0 Aug 6, 2026 · issue -013

Semantic Kernel 1.79.0 adds Ollama thinking support and TimeProvider injection for deterministic testing
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.79.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.79.0
```
└──▷ USE IT
Enable Ollama's extended thinking/reasoning mode when executing a prompt, useful for tasks requiring chain-of-thought output.
csharp
```
var settings = new OllamaPromptExecutionSettings { Think = true };
var result = await kernel.InvokePromptAsync(prompt, new(settings));
```
Inject a fake TimeProvider into TimePlugin so unit tests get deterministic timestamps instead of the real wall clock.
csharp
```
var fakeTime = new FakeTimeProvider();
fakeTime.SetUtcNow(new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero));
var timePlugin = new TimePlugin(fakeTime);
kernel.Plugins.AddFromObject(timePlugin);
```
- ›Adds Think property to OllamaPromptExecutionSettings, enabling extended thinking/reasoning mode for Ollama-backed prompts.
- ›Adds TimeProvider injection to TimePlugin, enabling deterministic time-based testing by supplying a custom or fake clock.
- ›Rejects mixed-separator UNC paths in file plugins, enforcing stricter path validation.
└──▷ BREAKING ON UPGRADE
- !Upgrades Prompty.Core to 2.0.0-beta.3; the commit is marked [BREAKING] — projects depending on the previous Prompty.Core version may require migration.
dotnet-1.79.0 Aug 6, 2026 · issue 002

Semantic Kernel dotnet-1.79.0 adds Ollama Think property support and TimeProvider injection into TimePlugin.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.79.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.79.0
```
└──▷ USE IT
Enable extended (chain-of-thought) reasoning for an Ollama model call by setting the Think property.
csharp
```
var settings = new OllamaPromptExecutionSettings { Think = true };
var result = await kernel.InvokePromptAsync("Explain quantum entanglement.", new KernelArguments(settings));
```
- ›Adds Think property to OllamaPromptExecutionSettings for controlling extended reasoning in Ollama completions.
- ›Adds TimeProvider injection support to TimePlugin, enabling deterministic time values in tests and custom scenarios.
- ›Encodes OpenAPI server variable values, improving correctness when constructing request URLs from OpenAPI specs.
└──▷ BREAKING ON UPGRADE
- !Upgrades Prompty.Core dependency to 2.0.0-beta.3; projects using the Prompty integration may experience breaking changes from this major pre-release bump.
python-1.44.0 Jul 7, 2026 · issue -043

Semantic Kernel Python 1.44.0 hardens MCP tool filtering, OpenAPI server validation, and request handling.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.44.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.44.0
```
- ›Enforces excluded_functions on the MCP tool invocation path, ensuring excluded tools cannot be called even when reached through MCP.
- ›Adds OpenAPI server URL validation to catch misconfigured or untrusted server targets before requests are dispatched.
- ›Defaults MCP SSE server samples to loopback with host validation, reducing exposure from unintended network interfaces.
- ›Hardens OpenAPI operation path handling for more consistent operation selection and request targeting.
└──▷ BREAKING ON UPGRADE
- !Runtime handling has been updated in a breaking change ([Breaking] Update runtime handling); existing code relying on the previous runtime behaviour may require updates on upgrade to 1.44.0.
python-1.43.1 Jun 17, 2026 · issue -063

Semantic Kernel Python 1.43.1 adds function_choice_behavior support to Azure AI and OpenAI Assistant agents.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.43.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.43.1
```
- ›Adds function_choice_behavior support to Azure AI and OpenAI Assistant agents, enabling tool-call control for agent interactions.
dotnet-1.77.0 May 28, 2026 · issue -083

Semantic Kernel dotnet-1.77.0 enables server URL validation for OpenAPI plugins and ships Agent Framework 1.0-compatible migration samples.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.77.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.77.0
```
- ›Enables default-on server URL validation for OpenAPI plugins, adding a security guardrail that checks server URLs before requests are made.
- ›Publishes Agent Framework 1.0-compatible migration samples and updates, aligning Semantic Kernel Agent Framework usage with the 1.0 release.
python-1.42.0 May 14, 2026 · issue -097

Semantic Kernel Python 1.42.0 ships MCP improvements and OpenAPI path parameter encoding.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.42.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.42.0
```
- ›Improves Model Context Protocol (MCP) support with unspecified enhancements to the MCP integration.
- ›Adds percent-encoding for OpenAPI path parameters in the OpenAPI connector.
dotnet-1.76.0 May 11, 2026 · issue -100

Semantic Kernel dotnet-1.76.0 adds ImageContent support in tool results and ExtraBody in OpenAI execution settings.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.76.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.76.0
```
└──▷ USE IT
Pass vendor-specific or experimental OpenAI API fields without waiting for first-class SDK support.
csharp
```
var settings = new OpenAIPromptExecutionSettings
{
    ExtraBody = new { reasoning_effort = "high", parallel_tool_calls = false }
};
```
- ›Adds ExtraBody property to OpenAIPromptExecutionSettings to pass arbitrary extra fields to the OpenAI API request body.
- ›Supports ImageContent in tool/function results, enabling connectors to return image data from tool calls.
- ›Adds deny-by-default AllowedUploadDirectories configuration to CloudDrivePlugin to restrict upload paths.
dotnet-1.75.0 Apr 29, 2026 · issue -112

Semantic Kernel .NET 1.75.0 adds Vertex AI embedding dimensions support and read-only vector store property interfaces.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.75.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.75.0
```
- ›Adds dimensions parameter support to Vertex AI embedding services in .NET, enabling control over output embedding size.
- ›Introduces read-only property interfaces on CollectionModel/builder, giving callers a stable, immutable view of vector store collection metadata.
- ›Updates .NET SQL Server vector search to use the latest VECTOR_SEARCH() syntax.
- ›Applies FunctionChoiceBehavior filters to OpenAI responses agent tools in Python, so function selection constraints are now respected in agent workflows.
python-1.41.2 Apr 8, 2026 · issue -133

Semantic Kernel Python 1.41.2 adds FunctionChoiceBehavior filter support in OpenAI responses agent tools.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.41.2 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.41.2
```
- ›Applies FunctionChoiceBehavior filters when building tool lists for OpenAI responses agents, ensuring function inclusion/exclusion rules are respected at invocation time.
dotnet-1.74.0 Mar 20, 2026 · issue -152

Semantic Kernel .NET 1.74.0 adds server URL validation for OpenAPI plugins, LINQ-based text search, and migrates DALL-E to gpt-image-1.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.74.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.74.0
```
- ›Adds AllowedDirectories deny-by-default configuration to DocumentPlugin to restrict file system access at the plugin level.
- ›Adds server URL validation options for OpenAPI plugins to control which remote endpoints plugins are permitted to call.
- ›Adds LINQ-based text search feature for .NET, enabling structured query expressions against text search providers.
- ›Migrates .NET image generation support from deprecated DALL-E models to gpt-image-1.
- ›Adds Python support for the new OpenAI text-to-image model.
+1 moreshow less
- ›Updates OpenAI to 2.9.1, Azure.AI.OpenAI to 2.9.0-beta.1, Azure.AI.Projects to 2.0.0-beta.2, and Microsoft.Extensions.AI* to 10.4.0.
└──▷ BREAKING ON UPGRADE
- !WebFileDownloadPlugin security defaults have been hardened — existing permissive configurations will be restricted on upgrade.
- !DocumentPlugin now uses a deny-by-default AllowedDirectories policy — plugins with previously unrestricted directory access will be blocked on upgrade.
vectordata-dotnet-10.1.0 Mar 20, 2026 · issue -152

Semantic Kernel .NET gains LINQ-based text search, OpenAPI server URL validation, and DALL-E to gpt-image-1 migration
└──▷ GET THIS VERSION
```
$ git clone --branch vectordata-dotnet-10.1.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-10.1.0
```
- ›Adds AllowedDirectories deny-by-default configuration to DocumentPlugin, hardening file-system access controls out of the box.
- ›Adds server URL validation options for OpenAPI plugins to restrict which hosts plugins are permitted to call.
- ›Migrates .NET DALL-E image generation from deprecated models to gpt-image-1.
- ›Adds LINQ-based text search support for .NET vector data queries.
- ›Adds support for the new OpenAI text-to-image model in the Python SDK.
+1 moreshow less
- ›Updates OpenAI SDK to 2.9.1, Azure.AI.OpenAI to 2.9.0-beta.1, Azure.AI.Projects to 2.0.0-beta.2, and Microsoft.Extensions.AI* to 10.4.0.
└──▷ BREAKING ON UPGRADE
- !WebFileDownloadPlugin security defaults are hardened — existing setups that relied on the previous permissive defaults will break on upgrade.
- !DocumentPlugin now uses a deny-by-default AllowedDirectories policy — any directory not explicitly listed will be blocked after upgrade.
python-1.41.0 Mar 13, 2026 · issue -158

Semantic Kernel Python 1.41.0 adds support for the new OpenAI text-to-image model.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.41.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.41.0
```
- ›Adds support for the new OpenAI text-to-image model in the Python SDK.
dotnet-1.73.0 Mar 4, 2026 · issue -167

Semantic Kernel .NET adds SQL Server approximate vector search, DateTime type support across MEVD providers, and PostgreSQL pgvector auto-install.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.73.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.73.0
```
- ›Adds approximate vector search support for SQL Server in the MEVD (Memory and Embedding Vector Database) layer.
- ›Adds support for DateTime, DateTimeOffset, DateOnly, and TimeOnly types across MEVD providers.
- ›Handles automatic installation of pgvector extension on PostgreSQL for MEVD setups.
- ›Makes PostgreSQL schema nullable in MEVD, enabling more flexible collection definitions.
- ›Adds validation for mismatched collection keys in MEVD providers to catch configuration errors early.
+1 moreshow less
- ›Updates Microsoft.Extensions.AI dependencies to 10.3.0 and OpenAI SDK to 2.8.0.
└──▷ BREAKING ON UPGRADE
- !SupportsMultipleKeys has been removed from the MEVD layer.
vectordata-dotnet-10.0.1 Mar 4, 2026 · issue -167

Semantic Kernel vector data adds SQL Server approximate vector search, DateTime type support, and pgvector auto-install for PostgreSQL.
└──▷ GET THIS VERSION
```
$ git clone --branch vectordata-dotnet-10.0.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-10.0.1
```
- ›Adds approximate vector search support for SQL Server in the MEVD provider (Microsoft.SemanticKernel.Connectors.SqlServer).
- ›Supports DateTime, DateTimeOffset, DateOnly, and TimeOnly types across MEVD providers.
- ›Handles automatic installation of the pgvector extension on PostgreSQL during collection setup.
- ›Makes the PostgreSQL schema parameter nullable in MEVD, allowing schema-less configurations.
- ›Adds validation for mismatched collection key types in MEVD providers.
+1 moreshow less
- ›Deduplicates embedding generation management across MEVD providers.
└──▷ BREAKING ON UPGRADE
- !Removes SupportsMultipleKeys from MEVD providers — code referencing this property will fail to compile.
python-1.40.0 Mar 2, 2026 · issue -169

Semantic Kernel Python 1.40.0 adds support for (Azure) OpenAI realtime audio models.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.40.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.40.0
```
- ›Adds support for OpenAI and Azure OpenAI realtime audio models in the Python SDK.
vectordata-dotnet-10.0.0 Feb 19, 2026 · issue -179

Semantic Kernel vector data adds SQL Server hybrid search, score threshold support, key auto-generation, and PostgreSQL DateTime/hybrid search improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch vectordata-dotnet-10.0.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-10.0.0
```
└──▷ USE IT
Restrict outbound HTTP calls from an SK Python agent to a known set of domains.
python
```
from semantic_kernel.core_plugins.http_plugin import HttpPlugin

http_plugin = HttpPlugin(allowed_domains=["api.example.com", "data.internal.corp"])
kernel.add_plugin(http_plugin, plugin_name="http")
```
- ›Implements ScoreThreshold support across MEVD providers, letting callers filter vector search results to only those meeting a minimum similarity score.
- ›Adds hybrid search to the SQL Server MEVD provider, combining vector and keyword search in a single query.
- ›Adds hybrid search to the PostgreSQL MEVD provider.
- ›Implements key auto-generation in MEVD, allowing records to be inserted without manually supplying a key.
- ›Supports .Any(x => x.Contains(...)) expressions in MEVD filter translation, enabling substring-in-collection filter queries.
+18 moreshow less
- ›Introduces FilterTranslatorBase to unify and deduplicate filter translation logic across MEVD providers.
- ›Improves Cosmos NoSQL MEVD provider with refined key, partition key, and point-read handling.
- ›Upgrades the MEVD MongoDB driver to v3.51.
- ›Adds FunctionChoiceBehavior support to the Google Gemini connector.
- ›Adds ThinkingLevel parameter to GeminiThinkingConfig for Gemini 3.0+ thinking budget control.
- ›Adds IncludeThoughts parameter to the Google connector for accessing Gemini reasoning/thought content.
- ›Adds ThoughtSignature support for Gemini function calling.
- ›Adds CachedContentTokenCount and ThoughtsTokenCount to Gemini usage metadata.
- ›Switches the Google Gemini connector to the official Google.GenAI IChatClient implementation.
- ›Migrates the Python Google connector to the new Google GenAI SDK.
- ›Adds a new Oracle connector for the Python Semantic Kernel vector store.
- ›Adds allowed_domains to HttpPlugin in Python to restrict outbound HTTP requests by domain allowlist.
- ›Adds directory allowlist configuration (allowed_directory) for SessionsPythonTool file access controls.
- ›Adds file upload security controls to SessionsPythonPlugin.
- ›Adds class validation for Dapr Runtime step loading in Python.
- ›Upgrades the Python ONNX connector to use the 0.9.0 runtime.
- ›Enables argument-type retention in handoff orchestration for .NET agents.
- ›Adds DriverInfo metadata to the Python MongoDB connector.
dotnet-1.71.0 Feb 16, 2026 · issue -182

Semantic Kernel .NET adds SQL Server and PostgreSQL hybrid search, score threshold filtering, and MEVD key auto-generation.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.71.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.71.0
```
- ›Adds score threshold support to the Memory/Vector DB (MEVD) layer, letting callers filter results below a minimum relevance score.
- ›Supports .Any(x => x.Contains(...)) expressions in MEVD vector store filters.
- ›Implements hybrid search for SQL Server via the MEVD connector.
- ›Implements hybrid search for PostgreSQL via the MEVD connector.
- ›Maps DateTime fields to timestamptz on PostgreSQL in the MEVD layer.
+2 moreshow less
- ›Adds key auto-generation to the MEVD layer, removing the need to supply record keys manually.
- ›Introduces FilterTranslatorBase to the MEVD layer, providing a shared base for building filter translators across connectors.
python-1.39.4 Feb 10, 2026 · issue -188

Semantic Kernel Python 1.39.4 refines filtering behavior.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.39.4 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.39.4
```
- ›Refines filtering behavior in the Python SDK.
python-1.39.3 Feb 2, 2026 · issue -196

Semantic Kernel Python 1.39.3 adds domain allowlisting for HttpPlugin and directory allowlists for SessionsPythonTool file access.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.39.3 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.39.3
```
└──▷ USE IT
Restrict an HttpPlugin instance to only fetch from trusted domains, preventing SSRF-style abuse in agent workflows.
python
```
from semantic_kernel.core_plugins.http_plugin import HttpPlugin

plugin = HttpPlugin(allowed_domains=["api.example.com", "data.trusted.org"])
```
- ›Adds allowed_domains parameter to HttpPlugin to restrict which domains the plugin may fetch from.
- ›Adds directory allowlist configuration to SessionsPythonTool to control which directories the tool can access for file operations.
- ›Adds class validation for Dapr Runtime step loading in process orchestration.
dotnet-1.70.0 Jan 23, 2026 · issue -206

Semantic Kernel dotnet-1.70.0 adds ThoughtSignature support for Gemini function calling and switches to Google's official GenAI IChatClient.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.70.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.70.0
```
- ›Adds ThoughtSignature support for Gemini function calling in the .NET SDK, surfacing model reasoning metadata during tool use.
- ›Switches the .NET Gemini integration to the official Google.GenAI IChatClient implementation.
dotnet-1.69.0 Jan 19, 2026 · issue -210

Semantic Kernel dotnet-1.69.0 adds FunctionChoiceBehavior support to the Google Gemini connector.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.69.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.69.0
```
- ›Adds FunctionChoiceBehavior support to the Google Gemini connector, enabling function/tool calling control for Gemini-backed chat completions.
python-1.39.1 Jan 15, 2026 · issue -214

Semantic Kernel Python adds an Oracle vector store connector and improves in-memory vector store filtering.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.39.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.39.1
```
- ›Adds a new Oracle connector for Semantic Kernel's vector store, including collection support via add_collection_to_all for Oracle.
- ›Improves filtering logic for in-memory vector stores.
- ›Adds DriverInfo metadata to the MongoDB connector.
dotnet-1.68.0 Dec 3, 2025 · issue -257

Semantic Kernel dotnet-1.68.0 adds Gemini reasoning content access, ThinkingLevel config, and OpenAIResponseAgent tool controls.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.68.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.68.0
```
└──▷ USE IT
Access Gemini's chain-of-thought reasoning content alongside the final response.
csharp
```
var executionSettings = new GeminiPromptExecutionSettings
{
    IncludeThoughts = true
};
var result = await chatService.GetChatMessageContentsAsync(history, executionSettings, kernel);
```
Tune reasoning depth for Gemini 3.0+ models by setting ThinkingLevel in GeminiThinkingConfig.
csharp
```
var executionSettings = new GeminiPromptExecutionSettings
{
    ThinkingConfig = new GeminiThinkingConfig
    {
        ThinkingLevel = ThinkingLevel.High
    }
};
var result = await chatService.GetChatMessageContentsAsync(history, executionSettings, kernel);
```
- ›Adds IncludeThoughts parameter to the Google Connector to expose Gemini reasoning/chain-of-thought content in responses.
- ›Adds ThinkingLevel parameter to GeminiThinkingConfig for controlling reasoning depth on Gemini 3.0+ models.
- ›Adds support for custom ToolChoice and ParallelToolCallsEnabled options in OpenAIResponseAgent.
- ›Enables argument type retention in handoff orchestration.
- ›Upgrades target framework to .NET 10.
+1 moreshow less
- ›Adds an OpenAPI tool call migration sample for AzureOpenAI.
python-1.39.0 Nov 26, 2025 · issue -264

Semantic Kernel Python migrates Google integration to the new Google GenAI SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.39.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.39.0
```
- ›Migrates the Google integration to the new Google GenAI SDK, replacing the previous SDK backend.
python-1.38.0 Nov 11, 2025 · issue -279

Semantic Kernel Python 1.38.0 adds an af_tool bridge for kernel_functions and upgrades the Onnx Connector to 0.9.0.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.38.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.38.0
```
- ›Adds af_tool bridge for kernel_functions, enabling integration between the af_tool interface and Semantic Kernel kernel functions.
- ›Upgrades the Onnx Connector to use version 0.9.0.
dotnet-1.67.0 Nov 3, 2025 · issue -287

Semantic Kernel dotnet-1.67.0 adds binary embeddings for PostgreSQL, BinaryContent for Gemini, Guid key support, and a VoiceChat console demo.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.67.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.67.0
```
- ›Adds BinaryEmbedding support to the PostgreSQL Memory Vector Store (MEVD) connector.
- ›Supports DateTimeOffset and string arrays in the SQL Server MEVD connector.
- ›Switches the SQL Server MEVD connector from JSON to the native binary SqlVector type for vector storage.
- ›Adds Guid key type support across all MEVD key types.
- ›Supports MemoryExtensions.Contains in LINQ-based MEVD filters.
+9 moreshow less
- ›Adds CachedContentTokenCount and ThoughtsTokenCount fields to Gemini usage metadata.
- ›Supports BinaryContent in the Gemini connector.
- ›Adds adapters to expose Semantic Kernel agents as AIAgent (Microsoft.Extensions.AI) instances.
- ›Adds kernel function arguments and results to execute-tool telemetry spans.
- ›Updates the ModelContextProtocol dependency to 0.4.0-preview.3.
- ›Adds a .NET VoiceChat console demo implementing a Microphone → VAD → STT → Chat → TTS → Speaker pipeline.
- ›Adds Agent Framework migration samples.
- ›Adds conformance tests for multi-vector records in MEVD.
- ›Supports CollectionExistsAsync with Redis Alpine.
python-1.37.0 Sep 16, 2025 · issue -334

Semantic Kernel Python 1.37.0 adds an NVIDIA chat completion AI connector.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.37.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.37.0
```
- ›Adds NvidiaChatCompletion AI connector, enabling NVIDIA-hosted models as a chat completion backend in Semantic Kernel pipelines.
dotnet-1.65.0 Sep 10, 2025 · issue -340

Semantic Kernel dotnet-1.65.0 adds Deep Research Tool for AzureAIAgent, reasoning support for OpenAI Responses Agents, and new AnnotationContent fields.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.65.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.65.0
```
- ›Adds container_id and filename fields to the AnnotationContent class in the Python library.
- ›Adds Deep Research Tool support for AzureAIAgent in the Python connector.
- ›Adds reasoning support for OpenAI Responses Agents (GPT-5, o4-mini, o3) in the Python library.
- ›Adds framework name into the UserAgent header for the Bedrock integration in Python.
- ›Adds thread message ID exposure during streaming for AzureAIAgent in Python.
python-1.36.1 Sep 2, 2025 · issue -348

Semantic Kernel Python 1.36.1 adds Deep Research Tool support, reasoning for OpenAI Responses Agents, and richer AnnotationContent fields.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.36.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.36.1
```
- ›Adds container_id and filename fields to the AnnotationContent class for richer annotation metadata.
- ›Adds AzureAIAgent Deep Research Tool support for long-horizon research workflows.
- ›Surfaces AzureAIAgent thread message IDs during streaming responses.
dotnet-1.64.0 Aug 27, 2025 · issue -354

Semantic Kernel .NET adds 'minimal' reasoning effort support and stable APIs for OpenAI/Azure connectors.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.64.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.64.0
```
- ›Adds support for 'minimal' reasoning effort level for Azure and OpenAI connectors, giving practitioners a third tier alongside existing effort options.
- ›Promotes previously experimental items to stable (removes experimental flags) in the .NET SDK.
- ›Adds input and output attributes to invoke_agent OpenTelemetry spans for richer observability of agent calls.
└──▷ BREAKING ON UPGRADE
- !Updated encoding logic in prompt templates changes how template arguments are encoded; existing prompts relying on prior encoding behavior may render differently — see the Semantic Kernel blog post for migration details.
dotnet-1.63.0 Aug 20, 2025 · issue -361

Semantic Kernel .NET 1.63.0 adds Guid/ObjectId key support for MongoDB and enriches OpenAPI parameter schemas.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.63.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.63.0
```
- ›Adds support for Guid and ObjectId key types in the MongoDB Connector, expanding the range of document ID formats usable with the vector store integration.
- ›Adds OpenAPI parameter descriptions to their JSON schemas, improving function metadata surfaced to the kernel when importing OpenAPI plugins.
python-1.35.3 Aug 14, 2025 · issue -363

Semantic Kernel Python 1.35.3 adds arguments and results attributes to execute tool spans for richer tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.35.3 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.35.3
```
- ›Adds arguments and results attributes to the execute tool span, exposing tool call inputs and outputs in tracing telemetry.
dotnet-1.62.0 Aug 12, 2025 · issue -363

Semantic Kernel .NET 1.62.0 adds ONNX provider/CUDA support, HttpClient injection for Azure OpenAI text-to-image, and A2A SDK integration.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.62.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.62.0
```
- ›Adds HttpClient parameter to AddAzureOpenAITextToImage method, enabling custom HTTP client injection for Azure OpenAI text-to-image calls.
- ›AddOpenAIEmbeddingGenerator now respects HttpClient.BaseAddress for endpoint resolution, enabling proxy and custom endpoint scenarios.
- ›Adds execution provider support to the ONNX connector, including a CUDA sample, enabling GPU-accelerated local inference.
- ›Updates the A2A agent integration to use the latest A2A .NET SDK.
- ›Magentic orchestration now returns the last agent message when limits are reached.
python-1.35.1 Aug 5, 2025 · issue -363

Semantic Kernel Python 1.35.1 adds AzureAI MCP tool streaming, Bedrock model provider param, and plugin encoding support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.35.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.35.1
```
└──▷ USE IT
Specify a file encoding when loading a plugin from disk, useful for non-UTF-8 prompt template files.
python
```
kernel.add_plugin(plugin_name='MyPlugin', parent_directory='./plugins', encoding='latin-1')
```
Pass a model provider when configuring a Bedrock-backed service, enabling provider-specific routing.
python
```
service = BedrockChatCompletion(model_id='anthropic.claude-v2', model_provider='anthropic')
```
- ›Adds tool_call_id as a required parameter for string-based tool messages in ChatHistory, enforcing correct message threading.
- ›Adds ability to specify encoding when adding a plugin via add_plugin.
- ›Adds model_provider parameter for Bedrock model configuration.
- ›Supports AzureAI agent MCP tools for both streaming and non-streaming invocations.
- ›Improved MCP connect flow with additional samples.
+4 moreshow less
- ›Arguments are now passed through when creating agents from specs.
- ›Input and output attributes are now included in invoke_agent spans for observability.
- ›Magentic orchestration now returns the last agent message when orchestration limits are reached.
- ›Adds a mixed agent orchestration sample demonstrating combined orchestration patterns.
└──▷ BREAKING ON UPGRADE
- !The tool_call_id parameter is now required for string-based tool messages in ChatHistory; code that omits this parameter will break.
dotnet-1.61.0 Jul 24, 2025 · issue -364

Semantic Kernel .NET 1.61.0 adds implicit agent plugin support, JsonElement handling for OpenAPI, OAuth MCP access, and a Gemini API key header move.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.61.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.61.0
```
└──▷ USE IT
Register a set of agents as callable tools inside a kernel so an orchestrating agent can invoke them by name without manual wrapping.
csharp
```
var plugin = AgentKernelPluginFactory.CreateFromAgents("AgentTools", agentA, agentB);
kernel.Plugins.Add(plugin);
```
- ›Adds AgentKernelPluginFactory.CreateFromAgents with direct implicit support for agents, removing the need to manually wrap agents as plugins.
- ›Supports JsonElement as a parameter type for OpenAPI plugins, enabling richer schema-driven tool invocation.
- ›Moves Google Gemini API key transport from the URL query string to the x-goog-api-key HTTP header for improved credential hygiene.
- ›Adds a sample demonstrating OAuth-based access to a protected MCP server.
- ›Adds a new agent orchestration sample that demonstrates mixing different agent types in a single workflow.
+1 moreshow less
- ›Updates GettingStarted examples to use M.E.AI.ChatClient as the primary chat interface.
└──▷ BREAKING ON UPGRADE
- !FoundryProcessBuilder and its associated files have been removed — code referencing FoundryProcessBuilder will not compile.
python-1.35.0 Jul 15, 2025 · issue -364

Semantic Kernel Python 1.35.0 adds gpt-image-1 support and partial result emission for the magentic orchestration pattern.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.35.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.35.0
```
- ›Adds support for gpt-image-1 model integration.
- ›Emits partial results for the magentic orchestration pattern when retrieving the final result, if one is available.
- ›Introduces message cache usage in agent orchestrations to improve efficiency.
- ›Improves exception handling in orchestration flows.
dotnet-1.60.0 Jul 8, 2025 · issue -364

Semantic Kernel .NET 1.60.0 adds Retrieval API plugin, SK-to-MEAI content converters, ChatSystem/DeveloperPrompt support, and promotes AI connectors out of experimental.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.60.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.60.0
```
└──▷ USE IT
Convert a Semantic Kernel ChatMessageContent to a MEAI content primitive for interop with Microsoft.Extensions.AI consumers.
csharp
```
using Microsoft.SemanticKernel;

ChatMessageContent skContent = new(AuthorRole.Assistant, "Hello!");
var meaiContent = skContent.ToAIContent();
```
- ›Adds ChatSystem and DeveloperPrompt properties to AzureOpenAIPromptExecutionSettings and OpenAIPromptExecutionSettings for ChatClients, enabling system and developer prompt injection at the settings level.
- ›Adds Filter support to TextSearchProvider, allowing callers to narrow text search results programmatically.
- ›Exposes conversion helpers from SK content types to Microsoft.Extensions.AI (MEAI) content primitives, bridging SK's ChatMessageContent and related types to MEAI's content model.
- ›Adds a Retrieval API Plugin to CAPs (Copilot Agent Plugins), surfacing retrieval as a first-class plugin capability.
- ›Removes the SKEXP0070 experimental attribute from non-GA AI connectors, graduating them to stable API surface.
+3 moreshow less
- ›Python: Adds support for the gpt-image-1 model in the OpenAI connector.
- ›Python: Emits partial results for the Magentic orchestration pattern when retrieving a final result, if a partial is available.
- ›Python: Introduces message caching in agent orchestrations to reduce redundant LLM calls.
vectordata-dotnet-9.7.0 Jul 8, 2025 · issue -364

Semantic Kernel vectordata-dotnet-9.7.0 adds a Retrieval API plugin, SK-to-MEAI content conversion helpers, A2A agent support, ONNX ChatClient extensions, and more.
└──▷ GET THIS VERSION
```
$ git clone --branch vectordata-dotnet-9.7.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-9.7.0
```
└──▷ USE IT
Use the new | merge operator on KernelArguments in Python to combine argument sets before invoking a kernel function.
python
```
merged_args = KernelArguments(foo='bar') | KernelArguments(baz='qux')
result = await kernel.invoke(my_function, merged_args)
```
- ›Adds Filter support to TextSearchProvider for scoped vector text search queries.
- ›Exposes conversion helpers from SK Contents to MEAI (Microsoft.Extensions.AI) content primitives, easing interop between SK and MEAI pipelines.
- ›Adds ChatSystem/DeveloperPrompt support to {Azure}OpenAIPromptExecutionSettings for ChatClient-based usage.
- ›Adds ONNX ChatClient extensions, enabling ONNX-backed models to be used via the ChatClient abstraction.
- ›Adds the Retrieval API Plugin to Conversational AI Primitives (CAPs).
+19 moreshow less
- ›Exposes GeminiKernelFunctionMetadataExtensions for working with Gemini function metadata.
- ›Adds AIContext to OpenAIResponseAgent, enriching agent response context.
- ›Introduces an initial A2A (Agent-to-Agent) agent implementation for .NET.
- ›Adds streaming support to agent orchestrations in .NET.
- ›Removes the SKEXP0070 experimental attribute from non-GA AI Connectors, promoting them toward stable status.
- ›Makes Gemini MaxTokens optional when not provided, aligning with other connector behaviors.
- ›Allows Kernel to be mutable by AgentChatCompletions.
- ›Introduces support for response modalities and audio options in AzureClientCore.
- ›Updates CosmosNoSql to the latest SDK and updates FullTextScore syntax.
- ›Enables clients to remove the safe_prompt attribute from JSON in Mistral connector requests.
- ›Python: Adds support for gpt-image-1 image generation model.
- ›Python: Supports structured outputs with Ollama.
- ›Python: Adds | and |= operators for KernelArguments.
- ›Python: Adds agent response callbacks that provide full invocation context.
- ›Python: Introduces Python vector store support (preview).
- ›Python: Adds streaming (pseudo-stream) support for Copilot Studio invoke_stream.
- ›Python: Emits partial results for the Magentic pattern when retrieving the final result, if available.
- ›Python: Adds message cache usage in agent orchestrations.
- ›Python: Adds operationId validation in OpenAPI spec parsing.
dotnet-1.59.0 Jul 1, 2025 · issue -364

Semantic Kernel .NET 1.59.0 adds web/file search sample, exposes GeminiKernelFunctionMetadataExtensions, and lets clients remove the safe_prompt attribute from JSON.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.59.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.59.0
```
└──▷ USE IT
Access Gemini function metadata directly via the newly public extensions class.
csharp
```
using Microsoft.SemanticKernel.Connectors.Google;

var metadata = GeminiKernelFunctionMetadataExtensions.ToGeminiFunctionMetadata(function.Metadata);
```
- ›Exposes GeminiKernelFunctionMetadataExtensions publicly, making Gemini function metadata utilities available to library consumers.
- ›Enables clients to remove the safe_prompt attribute from JSON in Mistral/compatible connector requests.
- ›Adds a sample demonstrating how to use web and file search together with Semantic Kernel agents.
- ›Ignores unknown response item types instead of throwing, improving forward-compatibility with evolving model response schemas.
dotnet-1.58.0 Jun 25, 2025 · issue -365

Semantic Kernel .NET 1.58.0 adds A2A agent support, streaming orchestrations, audio modalities, and ONNX ChatClient extensions.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.58.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.58.0
```
- ›Adds AzureClientCore support for response modalities and audio options, enabling multimodal (including audio) responses from Azure OpenAI.
- ›Adds ONNX ChatClient extensions for local on-device inference via the ONNX runtime.
- ›Introduces initial A2A (Agent-to-Agent) agent implementation for multi-agent interoperability.
- ›Adds AIContext support to OpenAIResponseAgent, enriching agent context handling.
- ›Adds streaming support to agent orchestrations, allowing intermediate results to surface in real time.
+4 moreshow less
- ›Allows Kernel to be mutable by AgentChatCompletions, enabling dynamic kernel configuration during agent chat sessions.
- ›Changes ChatCompletionAgent to emit intermediate messages as soon as they are available, reducing latency in streaming scenarios.
- ›Makes MaxTokens optional for Gemini models when not provided, removing a previously required parameter.
- ›Updates CosmosNoSql vector store to the latest SDK with updated FullTextScore syntax.
python-1.34.0 Jun 25, 2025 · issue -365

Semantic Kernel Python 1.34.0 adds Ollama structured outputs, vector stores preview, and KernelArgument merge operators.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.34.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.34.0
```
└──▷ USE IT
Merge two sets of kernel arguments using the new | operator instead of manually copying keys.
python
```
from semantic_kernel.kernel_arguments import KernelArguments

base = KernelArguments(city='Seattle', unit='metric')
overrides = KernelArguments(unit='imperial', verbose=True)
merged = base | overrides
# merged: {city: 'Seattle', unit: 'imperial', verbose: True}
```
- ›Supports | and |= merge operators for KernelArgument, enabling dict-style merging of kernel arguments.
- ›Adds structured output support for Ollama chat completion.
- ›Introduces vector stores preview for Python.
- ›Adds agent response callbacks that provide full context to callers.
- ›Adds pseudo-streaming support via invoke_stream for Copilot-style agents.
+2 moreshow less
- ›Adds operationId validation when parsing OpenAPI specs.
- ›Adds an Azure AI Foundry local sample demonstrating local model usage.
vectordata-dotnet-9.6.0 Jun 16, 2025 · issue -365

Semantic Kernel vectordata-dotnet-9.6.0 adds Ollama ChatClient extensions, AIContextProvider, CopilotStudioAgent, OpenAI Response Agent, hybrid search, and more.
└──▷ GET THIS VERSION
```
$ git clone --branch vectordata-dotnet-9.6.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-9.6.0
```
- ›Adds AIContextProvider support to Semantic Kernel (.NET), enabling dynamic context injection into chat completions via AIContextProvider implementations, with logging now included.
- ›Introduces CopilotStudioAgent (.NET) for agent interactions with Microsoft Copilot Studio.
- ›Adds new OpenAIResponseAgent (.NET) backed by the OpenAI Responses API.
- ›Implements OnnxRuntimeGenAIChatCompletionService on top of OnnxRuntimeGenAIChatClient (.NET), enabling local ONNX model chat completions.
- ›Adds Ollama ChatClient extension methods for the .NET KernelBuilder.
+23 moreshow less
- ›Adds usage metadata reporting to the ChatClientChatCompletionService adapter (.NET).
- ›Adds ChatHistoryAgentThread to multi-agent orchestration (.NET), enabling shared thread history across agents.
- ›Adds hybrid search support to the text search store (.NET).
- ›Adds Summary property to the OpenApiOperation model class (.NET).
- ›Adds Labels field to Gemini API requests (.NET).
- ›Adds token usage reporting to responses for the Bedrock connector (.NET).
- ›Adds contextual function selection to Semantic Kernel (.NET).
- ›Exposes ToJson() method on FoundryProcessBuilder (.NET).
- ›Adds audio and binary tag support to the chat prompt parser (.NET).
- ›Adds Foundry workflow management client (.NET).
- ›Supports Declarative Spec for OpenAIAssistantAgent and OpenAIResponsesAgent (Python).
- ›Adds BingGroundingTool parameter configuration support (Python), allowing customization of Bing search parameters.
- ›Includes Bing Grounding Tool call results in invoke_stream responses (Python).
- ›Adds file handling support to BinaryContent for the OpenAI Responses API (Python).
- ›Adds Bing custom search tool content support (Python).
- ›Adds streaming agent response callback in agent orchestrations (Python).
- ›Emits token usage with streaming chat completion agent responses (Python).
- ›Adds WebRTC support for Azure OpenAI Realtime (Python).
- ›Supports structured outputs with Azure AI inference chat completion (Python).
- ›Normalizes MCP function names to allowed tool-calling values (Python).
- ›Removes Kusto and DuckDB vector store providers (.NET).
- ›Removes planner-related code and samples (.NET and Python).
- ›Switches all .NET Agents instances of SendMessage to PublishMessage.
└──▷ BREAKING ON UPGRADE
- !All .NET Agents usages of SendMessage are renamed to PublishMessage; existing code calling SendMessage on agent instances will break.
- !The Kusto and DuckDB vector store providers are removed from .NET; projects depending on these packages must migrate to an alternative provider.
- !Python planner-related code and samples are removed; any code referencing planner APIs will break.
dotnet-1.56.0 Jun 10, 2025 · issue -365

Semantic Kernel .NET 1.56.0 adds OpenAI Response Agent, CopilotStudioAgent, OnnxRuntimeGenAI chat client, and audio/binary chat prompt support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.56.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.56.0
```
- ›Introduces CopilotStudioAgent for .NET Agents, enabling integration with Microsoft Copilot Studio.
- ›Adds OpenAIResponseAgent — a new agent type backed by the OpenAI Responses API.
- ›Implements OnnxRuntimeGenAIChatCompletionService on top of OnnxRuntimeGenAIChatClient, bringing local ONNX Runtime GenAI models into the chat completion abstraction.
- ›Adds usage metadata support for ChatClientChatCompletionService adapter, surfacing token/usage telemetry when using IChatClient-backed completions.
- ›Adds support for audio and binary tags in the chat prompt parser, enabling multimodal prompt construction.
+5 moreshow less
- ›Removes obsoleted planner classes, cleaning up the planners that were previously marked obsolete.
- ›Removes obsoleted code for agent abstractions, trimming previously deprecated agent APIs.
- ›Allows hyphens in function names, expanding the valid character set for kernel plugin functions.
- ›Reorganizes MEVD (Memory/Embedding Vector Database) projects for cleaner package structure.
- ›Optimizes and cleans up the SqliteVec vector store provider.
└──▷ BREAKING ON UPGRADE
- !Planners have been removed; any code referencing the previously obsoleted planner classes will break on upgrade.
- !Obsoleted agent abstraction code has been removed; previously deprecated agent APIs no longer exist.
python-1.33.0 Jun 10, 2025 · issue -365

Semantic Kernel Python 1.33.0 adds Bing custom search, BinaryContent file handling for OpenAI Responses API, and streaming token usage emission.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.33.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.33.0
```
- ›Adds file handling support to BinaryContent for the OpenAI Responses API.
- ›Adds Bing custom search tool content support.
- ›Emits token usage data with streaming chat completion agents.
- ›Normalizes MCP function names to allowed tool-calling values for compatibility.
- ›Removes the model info check in Bedrock connectors, broadening model compatibility.
+1 moreshow less
- ›Adds a chat completion agent code interpreter sample.
└──▷ BREAKING ON UPGRADE
- !All planner-related code and samples have been fully removed from the package; any code relying on Semantic Kernel planners will break on upgrade.
python-1.32.2 Jun 4, 2025 · issue -365

Semantic Kernel Python 1.32.2 adds streaming agent response callbacks and custom httpx client timeout support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.32.2 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.32.2
```
- ›Supports custom httpx client timeout when not using a custom client, allowing fine-grained control over request timing.
- ›Adds streaming agent response callback support in agent orchestrations.
dotnet-1.55.0 Jun 3, 2025 · issue -365

Semantic Kernel dotnet-1.55.0 adds Foundry workflow management, ChatHistoryAgentThread, contextual function selection, hybrid search, and MCP SDK update.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.55.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.55.0
```
- ›Adds ChatHistoryAgentThread to multi-agent support, enabling agents to share and reference a common chat history thread.
- ›Adds Labels field to Gemini request payloads for annotating inference calls.
- ›Adds hybrid search support to the text search store, combining vector and keyword search.
- ›Adds token usage reporting to responses from the Bedrock connector.
- ›Adds logging to AIContextProvider implementations for observability.
+4 moreshow less
- ›Adds Foundry workflow management client for orchestrating AI Foundry workflows.
- ›Adds contextual function selection capability to Semantic Kernel.
- ›Updates to the latest MCP (Model Context Protocol) SDK.
- ›Updates Handoff Orchestration in .NET Agents.
python-1.32.1 Jun 3, 2025 · issue -365

AzureAIAgent dependencies now bundled in the base semantic-kernel package
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.32.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.32.1
```
- ›Bundles AzureAIAgent required dependencies into the base pip install semantic-kernel package, eliminating the need for a separate extras install.
python-1.32.0 May 28, 2025 · issue -366

Semantic Kernel Python 1.32.0 adds structured outputs for Azure AI inference and Declarative Spec support for OpenAI agents.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.32.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.32.0
```
- ›Adds missing fields to AzureAIAgentSettings for more complete agent configuration.
- ›Allows configuration of parameters for BingGroundingTool.
- ›Includes Bing Grounding Tool call results in invoke_stream responses.
- ›Relaxes agent invocation methods to allow positional or keyword arguments for messages.
- ›Supports structured outputs with Azure AI inference chat completion.
+1 moreshow less
- ›Supports Declarative Spec for OpenAIAssistantAgent and OpenAIResponsesAgent.
dotnet-1.54.0 May 22, 2025 · issue -366

Semantic Kernel .NET 1.54.0 adds AIContextProvider support and a Summary property on OpenApiOperation.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.54.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.54.0
```
- ›Adds AIContextProvider support to Semantic Kernel, enabling context injection into AI interactions.
- ›Adds Summary property to the OpenApiOperation model class, exposing operation summaries from OpenAPI specs.
- ›Removes the Kusto and DuckDB integrations from the .NET SDK.
└──▷ BREAKING ON UPGRADE
- !The Kusto and DuckDB integrations have been removed from the .NET SDK; any code depending on these packages will break on upgrade.
dotnet-1.53.0 May 20, 2025 · issue -366

Semantic Kernel .NET 1.53.0 exposes ToJson on FoundryProcessBuilder, integrates MEAI Abstractions, and updates the Azure Foundry Agent SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.53.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.53.0
```
- ›Exposes ToJson method on FoundryProcessBuilder, allowing serialization of a Foundry process definition to JSON.
- ›Integrates Semantic Kernel with MEAI (Microsoft Extensions for AI) Abstractions, enabling interoperability with the MEAI abstraction layer.
- ›Updates the Azure Foundry Agent SDK backing AzureAIAgent, with GA Foundry Projects (created on or after May 19th, 2025) now accessed via endpoint URI instead of connection-string.
└──▷ BREAKING ON UPGRADE
- !Developers using AzureAIAgent must now target a GA Azure AI Foundry Project. Projects created before May 19th, 2025 are accessed via a connection-string; projects created on or after May 19th, 2025 are accessed via their endpoint URI — existing code pointing to pre-GA projects will require migration per the Azure Agent Foundry GA Migration Guide.
python-1.31.0 May 19, 2025 · issue -366

Semantic Kernel Python 1.31.0 adds Magentic multi-agent orchestration and WebRTC support for Azure OpenAI Realtime.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.31.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.31.0
```
- ›Adds Magentic multi-agent orchestration strategy, enabling coordinated multi-agent workflows via the new MagenticOrchestration pattern.
- ›Adds WebRTC support for Azure OpenAI Realtime, enabling real-time audio/video communication through the Azure OpenAI Realtime connector.
- ›Preserves citation title in AnnotationContent from Azure AI Foundry annotations.
└──▷ BREAKING ON UPGRADE
- !Planners have been marked deprecated and all related items removed — any code relying on Semantic Kernel planners will break on upgrade.
dotnet-1.52.0 May 19, 2025 · issue -366

Semantic Kernel dotnet-1.52.0 adds Magentic multi-agent orchestration and MEVD feature updates for .NET, plus Magentic orchestration and planner deprecation for Python.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.52.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.52.0
```
- ›Adds Magentic Agent Orchestration for .NET (Microsoft.SemanticKernel.Agents) enabling multi-agent coordination via the Magentic pattern.
- ›Adds Magentic multi-agent orchestration support for Python, aligning orchestration capabilities across both SDK surfaces.
- ›Updates .NET codebase to the latest MCP (Model Context Protocol) NuGet package, keeping MCP integration current.
- ›Updates Microsoft.Extensions.AI dependency to its stable release version in the .NET SDK.
- ›Ships MEVD (Memory and Vector Data) Feature Branch 3 for .NET, advancing the vector/memory subsystem.
+5 moreshow less
- ›Updates the Foundry process builder to the latest format in .NET.
- ›Removes HTTPS validation requirements in AzureClientCore, allowing more flexible Azure endpoint configurations.
- ›Python now preserves Citation Title in AnnotationContent from Azure AI Foundry annotations.
- ›Python adds validation for missing or unexpected parameters received from models.
- ›Python planners are marked deprecated and all related items removed from the codebase.
└──▷ BREAKING ON UPGRADE
- !Python planners are deprecated and all related planner items have been removed — code relying on Python planner classes will break on upgrade.
vectordata-dotnet-9.5.0 May 19, 2025 · issue -366

Semantic Kernel vectordata-dotnet-9.5.0 adds Magentic agent orchestration, MCP Streamable HTTP, Copilot Studio Agent, and IEmbeddingGenerator support for VectorStoreTextSearch.
└──▷ GET THIS VERSION
```
$ git clone --branch vectordata-dotnet-9.5.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout vectordata-dotnet-9.5.0
```
└──▷ USE IT
Use the M.E.AI IEmbeddingGenerator abstraction with VectorStoreTextSearch instead of the now-obsolete ITextEmbeddingGenerator.
csharp
```
var textSearch = new VectorStoreTextSearch<MyRecord>(vectorStore, embeddingGenerator);
```
Pass vendor-specific parameters through to the OpenAI chat API without waiting for first-class SDK support.
python
```
settings = OpenAIChatPromptExecutionSettings(extra_body={"reasoning_effort": "high"})
```
Cap the number of supersteps a Python SK process may execute to prevent runaway loops.
python
```
await process.start(kernel=kernel, initial_event=start_event, max_supersteps=20)
```
- ›Adds IEmbeddingGenerator support to VectorStoreTextSearch in .NET, enabling use of the M.E.AI embedding abstraction for vector text search.
- ›Adds extra_body attribute to OpenAIChat settings in Python for passing arbitrary extra parameters to the OpenAI chat API.
- ›Adds max_supersteps parameter for callers to control process execution limits in Python processes.
- ›Introduces Magentic multi-agent orchestration pattern for .NET Agents, enabling LLM-driven dynamic agent selection and coordination.
- ›Introduces Copilot Studio Agent for Python, enabling integration with Microsoft Copilot Studio as an agent provider.
+17 moreshow less
- ›Adds support for MCP Streamable HTTP transport in Python, expanding Model Context Protocol connectivity options.
- ›Adds URL citation support on Azure Agent in .NET.
- ›Adds support for BinaryContent in the .NET OpenAI Connector.
- ›Supports Declarative Agent Spec for ChatCompletionAgent and AzureAIAgent in Python.
- ›Adds FoundryProcessBuilder for Local Runtime in .NET, enabling local execution of Foundry processes.
- ›Graduates Plugins.Core package from alpha to preview in .NET.
- ›Removes the experimental attribute from stable OpenAPI API in .NET, marking it generally available.
- ›Removes the experimental attribute from core plugins in .NET.
- ›Removes the [MEVD] experimental flag from the GetService method in .NET.
- ›Adds multi-agent orchestration patterns (Concurrent, Sequential, Group Chat, Handoff) for Python.
- ›Introduces Process State Management support in Python.
- ›Serializes Python code execution results as a typed object in .NET (SessionsPythonPlugin updates).
- ›Migrates the Python code interpreter C# plugin to the latest Azure code interpreter API version.
- ›Marks ITextEmbeddingGenerator as obsolete in .NET (superseded by IEmbeddingGenerator).
- ›Removes the Functions.Markdown package from .NET.
- ›Removes math and wait plugins from .NET.
- ›Marks Python planners as deprecated and removes all related items.
└──▷ BREAKING ON UPGRADE
- !add_chat_message is removed from AzureAIAgent and OpenAIAssistantAgent in Python following its deprecation notice.
- !The Functions.Markdown package is removed from .NET; projects depending on it will fail to build.
- !Math and wait plugins are removed from .NET; code referencing them will break.
- !Python planners are deprecated and all related items are removed; code using planners will break.
dotnet-1.51.0 May 16, 2025 · issue -366

Semantic Kernel .NET 1.51.0 adds FoundryProcessBuilder for local runtime and multi-agent orchestration support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.51.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.51.0
```
- ›Adds FoundryProcessBuilder for local runtime process execution in .NET.
- ›Adds .NET Agent Orchestration support, enabling coordination of multiple agents.
- ›Obsoletes ITextEmbeddingGenerator in .NET, signaling a migration path away from the interface.
dotnet-1.50.0 May 14, 2025 · issue -366

Semantic Kernel .NET 1.50.0 adds URL citation support for Azure Agents and serialized Python code execution results.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.50.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.50.0
```
- ›Adds URL citation support on AzureAgent in .NET, surfacing source links from Azure AI agent responses.
- ›Serializes Python code execution results in .NET, making interpreter output available as structured data.
- ›Updates Microsoft.Extensions.AI (MEAI) dependency and migrates away from deprecated schema APIs.
python-1.30.0 May 14, 2025 · issue -366

Semantic Kernel Python 1.30.0 adds Copilot Studio Agent, MCP Streamable HTTP, and four multi-agent orchestration patterns
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.30.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.30.0
```
└──▷ USE IT
Pass custom OpenAI request body fields (e.g. reasoning effort or provider-specific params) through to the API without subclassing.
python
```
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    extra_body={'reasoning_effort': 'high', 'store': True}
)
```
- ›Adds extra_body attribute to OpenAI Chat settings, enabling pass-through of arbitrary request body fields to the OpenAI API.
- ›Introduces CopilotStudioAgent, a new agent type for integrating with Microsoft Copilot Studio.
- ›Ports the Agent Runtime into the SK repo, enabling local multi-agent execution without an external runtime dependency.
- ›Adds support for MCP Streamable HTTP transport alongside the existing transports.
- ›Adds multi-agent orchestration: ConcurrentOrchestration and SequentialOrchestration patterns for coordinating agent pipelines.
+5 moreshow less
- ›Adds multi-agent orchestration: GroupChatOrchestration pattern for round-robin or moderated group agent conversations.
- ›Adds multi-agent orchestration: HandoffOrchestration pattern for dynamic agent-to-agent task delegation.
- ›Adds Declarative Agent Spec support for ChatCompletionAgent and AzureAIAgent, enabling agents to be defined from a spec document.
- ›Supports callers passing in max_supersteps for process invocations, giving finer control over process execution depth.
- ›Surfaces streaming code interpreter responses and handles Bing Grounding results in AzureAIAgent.
└──▷ BREAKING ON UPGRADE
- !Removes add_chat_message from AzureAIAgent and OpenAIAssistantAgent per prior deprecation notice.
dotnet-1.49.0 May 8, 2025 · issue -366

Semantic Kernel .NET 1.49.0 adds IEmbeddingGenerator support in vector search, graduates Plugins.Core to preview, and introduces BinaryContent in OpenAI.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.49.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.49.0
```
└──▷ USE IT
Pass arbitrary provider-specific fields through OpenAI chat completions in Python without subclassing the settings object.
python
```
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    extra_body={"reasoning_effort": "high", "data_sources": []}
)
```
- ›Adds IEmbeddingGenerator support to VectorStoreTextSearch, enabling the Microsoft.Extensions.AI embedding abstraction as a drop-in source for vector store text search.
- ›Supports BinaryContent in the .NET OpenAI Connector, allowing binary payloads to be passed through OpenAI requests.
- ›Graduates Microsoft.SemanticKernel.Plugins.Core package from 'alpha' to 'preview' status, signalling increased API stability.
- ›Removes the experimental attribute from core plugins in Plugins.Core, making them part of the stable surface.
- ›Migrates the Python code interpreter C# plugin (SessionsPythonPlugin) to the latest Azure code interpreter API version.
+7 moreshow less
- ›Updates SessionsPythonPlugin with additional capabilities alongside the API migration.
- ›Adds extra_body attribute to Python OpenAI Chat settings, enabling pass-through of arbitrary request body fields.
- ›Introduces the Copilot Studio Agent in the Python SDK, adding a new agent type for Microsoft Copilot Studio integration.
- ›Ports the Python Agent Runtime to the SK repo, making it available directly within the Semantic Kernel Python distribution.
- ›Removes the Functions.Markdown package from the .NET distribution.
- ›Removes the math and wait built-in plugins from the .NET distribution.
- ›Adds cancellation token support and custom header injection to HTTP requests in the .NET layer.
└──▷ BREAKING ON UPGRADE
- !The Functions.Markdown package has been removed and is no longer available in the .NET distribution.
- !The math and wait plugins have been removed from the .NET distribution; code referencing them will break on upgrade.
- !Python: add_chat_message has been removed from AzureAIAgent and OpenAIAssistantAgent per its deprecation notice.
dotnet-1.48.0 Apr 29, 2025 · issue -367

Semantic Kernel .NET 1.48.0 adds Gemini thinking budget config, UserSecurityContext, OpenAPI operation selector, OpenTelemetry for Azure AI Inference, and graduates the Liquid prompt template package.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.48.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.48.0
```
- ›Adds UserSecurityContext to AzureOpenAIPromptExecutionSettings for passing user security context through Azure OpenAI prompt execution.
- ›Introduces Gemini Thinking Budget Configuration for controlling reasoning token budgets in Google Gemini integrations.
- ›Adds an OpenAPI operation selector, enabling callers to filter or choose which OpenAPI operations are exposed as kernel functions.
- ›Adds OpenTelemetry support for Azure AI Inference, bringing tracing and metrics parity to the Azure AI Inference connector.
- ›Graduates Microsoft.SemanticKernel.PromptTemplates.Liquid from experimental to stable, making the Liquid prompt template engine production-ready.
+4 moreshow less
- ›Updates MCP integration to 0.1.0-preview.11, including details and support for remote MCP SSE servers and authentication.
- ›Updates AgentFactory implementations to handle existing agents, enabling reuse of previously created agent instances.
- ›Removes the experimental attribute from the stable OpenAPI API surface, formally stabilizing those APIs.
- ›Adds a streaming retry filter example demonstrating how to implement retry logic for streaming kernel invocations.
└──▷ BREAKING ON UPGRADE
- !SK planners are now marked obsolete and will generate compiler warnings in consuming code.
python-1.29.0 Apr 28, 2025 · issue -367

Semantic Kernel Python 1.29.0 adds Brave search, kernel cloning, process state management, and richer agent polling and metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.29.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.29.0
```
└──▷ USE IT
Clone a fully configured kernel (plugins, services, filters) to create an isolated variant without re-registering everything from scratch.
python
```
from semantic_kernel import Kernel

original_kernel = Kernel()
# ... register plugins, services, etc.
cloned_kernel = original_kernel.clone()
cloned_kernel.add_plugin(extra_plugin)
```
- ›Adds RunPollingOptions at the run-level for AzureAIAgent, OpenAIAssistantAgent, and OpenAIResponsesAgent, and moves RunPollingOptions import to base level alongside continue during invoke tool calls support.
- ›Returns thread_id and run_id in agent response metadata, giving callers direct access to run identifiers from agent invocations.
- ›Adds Brave search capability as a new plugin/connector in the Python SDK.
- ›Adds kernel.clone() (clone a kernel) to programmatically duplicate a configured Kernel instance.
- ›Adds Process State Management support for stateful multi-step process workflows.
dotnet-1.47.0 Apr 17, 2025 · issue -367

Semantic Kernel .NET 1.47.0 adds SK-agent-as-MCP-tool exposure, MCP tool consumption by agents, Brave search, and .yml prompt support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.47.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.47.0
```
└──▷ USE IT
Use Brave Search as the web search backend via the new BraveConnector in WebSearchPlugin.
csharp
```
var braveConnector = new BraveConnector(apiKey: "<your-brave-api-key>");
var webSearchPlugin = new WebSearchEnginePlugin(braveConnector);
kernel.ImportPluginFromObject(webSearchPlugin, "WebSearch");
```
- ›Adds BraveConnector to WebSearchPlugin, enabling Brave Search as a web search backend alongside existing providers.
- ›Enables SK agents to be exposed as MCP tools (SK agent as MCP tool), letting other MCP clients call Semantic Kernel agents via the Model Context Protocol.
- ›Enables SK agents to consume MCP tools (Use Mcp tools by SK agents), so agents can invoke any MCP-compatible tool server.
- ›Adds support for .yml file extensions (in addition to .yaml) when loading prompt templates in the C# SDK.
- ›Adds support for relative file references in Prompty prompt files, allowing prompts to reference other assets by relative path.
+8 moreshow less
- ›Adds type property to API documentation and schema definitions for improved JSON schema conformance.
- ›Adds plugin description propagation (add plugin description) so plugin-level descriptions are included in tool metadata.
- ›Adds RetainArgumentTypes option to agent arguments, preserving strong typing when passing arguments through ModelContextProtocolPlugin.
- ›Adds an MCP sampling sample demonstrating how to use MCP sampling with Semantic Kernel agents.
- ›Updates OpenTelemetry GenAI semantic attributes to align with the latest GenAI conventions.
- ›Updates Qdrant integration to the latest Qdrant SDK version.
- ›Uses dependency injection (DI) to manage prompt, resource, and resource template definitions in the MCP server layer.
- ›Removes SingleAuthorizationHeaderPolicy, consolidating authorization header handling.
└──▷ BREAKING ON UPGRADE
- !SingleAuthorizationHeaderPolicy has been removed; any code that referenced or registered this policy will break on upgrade.
python-1.28.1 Apr 17, 2025 · issue -367

Semantic Kernel Python 1.28.1 expands MCP integration with prompt, sampling, and agent-as-server support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.28.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.28.1
```
- ›Adds MCP prompt and sampling support to Semantic Kernel's MCP integration.
- ›Enables creating an MCP server directly from a Semantic Kernel agent.
dotnet-1.46.0 Apr 11, 2025 · issue -367

Semantic Kernel dotnet-1.46.0 adds declarative agents, exposes kernel function metadata, and graduates stable APIs from experimental.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.46.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.46.0
```
- ›Adds declarative agents support via the new Feature declarative agents capability, enabling agent definitions without imperative code.
- ›Exposes the underlying MethodInfo from KernelFunction, giving callers direct access to the reflected method for inspection or invocation.
- ›Removes [Experimental] flags from previously preview APIs, promoting them to stable surface in the public contract.
- ›Adds a React sample app demonstrating SK Process Cloud Events integration.
- ›Adds samples for MCP Resources and Resource Templates, showing how to surface and consume typed resource endpoints from an MCP server.
+6 moreshow less
- ›Adds a structured output example combining Azure OpenAI with Function Calling.
- ›Adds a document-generation gRPC sample for the SK Process framework.
- ›Extends the MCP sample to show consuming MCP Tools from within an Agent.
- ›Enables dependency injection (DI) for SK plugins in the MCP demo server.
- ›Updates WebFileDownloadPlugin, HttpPlugin, and FileIOPlugin with new capabilities.
- ›Bumps AWSSDK to 4.0.0-preview.13 and Microsoft.Extensions.AI to 9.4.0-preview.
python-1.28.0 Apr 11, 2025 · issue -367

Semantic Kernel Python 1.28.0 adds MCP Server support, Auto Function Invocation Filters for agents, and multimodal Kernel Functions from Prompt.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.28.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.28.0
```
- ›Exposes Semantic Kernel as a Model Context Protocol (MCP) Server, letting external MCP clients invoke SK kernel functions directly.
- ›Adds Auto Function Invocation Filter support for AzureAIAgent and OpenAIAssistantAgent, enabling pre/post-invocation hooks on auto-called functions.
- ›Enables KernelFunction creation from prompts that include image and audio content, extending multimodal support to prompt-based function definitions.
- ›Adds a sample demonstrating the GitHub MCP Server integrated with AzureAIAgent as a practical MCP + agent usage pattern.
- ›Allows Semantic Kernel settings objects to be instantiated directly without requiring environment-variable or file-based configuration.
python-1.27.0 Apr 3, 2025 · issue -367

Semantic Kernel Python 1.27.0 adds Agents-as-Kernel-Functions, an OpenAI Responses Agent, SQL Connector, and MCP server plugin support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.27.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.27.0
```
└──▷ USE IT
Receive intermediate agent messages during a long-running agent invocation, e.g. to stream tool-call progress to a UI.
python
```
async def handle_intermediate(message):
    print(f'Intermediate: {message}')

async for response in agent.invoke(
    thread=thread,
    on_intermediate_message=handle_intermediate,
):
    print(response)
```
- ›Adds on_intermediate_message callback to the Agent abstraction, enabling callers to receive streamed intermediate messages during agent invocation.
- ›Introduces the OpenAIResponsesAgent class, a new agent type backed by the OpenAI Responses API.
- ›Supports using an MCP (Model Context Protocol) server as a Semantic Kernel plugin, allowing MCP-exposed tools to be called as kernel functions.
- ›Introduces the SQL Connector, enabling vector store and data retrieval operations against SQL databases.
- ›Allows Agents to be used directly as Kernel Functions, composing agent invocations inside kernel pipelines.
+1 moreshow less
- ›Adds AzureAIAgent structured outputs support, enabling schema-constrained responses from Azure AI agents.
dotnet-1.45.0 Apr 3, 2025 · issue -367

Semantic Kernel .NET 1.45.0 adds audio I/O for OpenAI, Tavily integration, MCP samples, and agent API improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.45.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.45.0
```
- ›Adds OnIntermediateMessage callback (renamed from OnNewMessage) to receive notifications for all agent messages during invocation.
- ›Adds audio input and output support for OpenAI chat completions.
- ›Adds Tavily search integration as a new plugin/connector.
- ›Adds ChatHistoryAgent (marked experimental) as a new agent type.
- ›Adds agent-specific parameters support via new overloads in the common agent invoke API.
+7 moreshow less
- ›Adds invoke overloads accepting a plain string message or no message, enabling simpler agent calls.
- ›Adds Qdrant CRUD datetime support for datetime-typed vector store record fields.
- ›Adds OpenAPI server URL override hierarchy support for OpenAPI-based plugins.
- ›Adds MCP (Model Context Protocol) server/client sample and MCP prompt sample demonstrating client and server interop.
- ›Adds hybrid search sample and moves hybrid search tests to updated project structure.
- ›Removes Agent preview suffix, promoting the Agent API to non-preview status.
- ›Merges KernelAgent functionality into Agent.cs, consolidating the agent base class.
└──▷ BREAKING ON UPGRADE
- !The OnNewMessage callback is renamed to OnIntermediateMessage; any code referencing OnNewMessage will break.
- !KernelAgent.cs is removed and its functionality merged into Agent.cs; any direct references to KernelAgent will break.
python-1.26.1 Mar 25, 2025 · issue -368

Semantic Kernel Python 1.26.1 introduces a unified agent invocation API with AgentThread and AgentResponseItem across all agent types.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.26.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.26.1
```
- ›Adds AgentThread base class with create() and delete() methods to manage conversation thread lifecycle across all agent types (AzureAIAgent, ChatCompletionAgent, OpenAIAssistantAgent, AzureAssistantAgent, BedrockAgent, AutoGenConversableAgent).
- ›Agent methods get_response(...), invoke(...), and invoke_stream(...) now return AgentResponseItem[ChatMessageContent], exposing a message attribute (type TMessage) and a thread attribute (type AgentThread).
- ›Renames the message keyword argument on get_response(...), invoke(...), and invoke_stream(...) to messages, now accepting str | ChatMessageContent | list[str | ChatMessageContent].
- ›Consolidates all agent import paths under semantic_kernel.agents, enabling a single from semantic_kernel.agents import AzureAIAgent, ChatCompletionAgent, OpenAIAssistantAgent, AzureAssistantAgent, BedrockAgent, AutoGenConversableAgent import.
- ›Adds Copilot Studio Agents and Copilot Studio Skill demos.
└──▷ BREAKING ON UPGRADE
- !The message keyword argument on get_response(...), invoke(...), and invoke_stream(...) is renamed to messages; existing call sites using message= will break.
- !Agent response objects are now AgentResponseItem[ChatMessageContent] instead of plain ChatMessageContent; code that unpacks or type-checks the return value directly will break.
dotnet-1.43.0 Mar 25, 2025 · issue -368

Semantic Kernel .NET 1.43.0 adds Aspire integration for agents, a Structured Data Plugin, web search in OpenAI settings, and Ollama vision support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.43.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.43.0
```
└──▷ USE IT
Enable web search on an OpenAI chat completion call so the model can retrieve live information.
csharp
```
var settings = new OpenAIPromptExecutionSettings
{
    WebSearchEnabled = true
};
var result = await kernel.InvokePromptAsync("What happened in the news today?", new(settings));
```
- ›Adds WebSearchEnabled (and related options) to OpenAIPromptExecutionSettings to enable web search support for OpenAI-backed prompts.
- ›Adds a Structured Data Plugin supporting query and CRUD operations against structured data sources.
- ›Ports the Pinecone connector to use the Pinecone.Client library in the Memory/Embedding Vector Database (MEVD) layer.
- ›Adds support for configuring embedding dimensions in Google AI embeddings generation.
- ›Integrates the Agent Framework with .NET Aspire for agent observability and orchestration.
+1 moreshow less
- ›Adds an Ollama ChatCompletion with Vision sample demonstrating multimodal input via Ollama.
python-1.25.0 Mar 18, 2025 · issue -368

Semantic Kernel Python 1.25.0 adds an NVIDIA embedding connector for vector generation.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.25.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.25.0
```
- ›Adds an NVIDIA Embedding Connector, enabling NVIDIA-hosted embedding models as a vector generation backend in Semantic Kernel pipelines.
dotnet-1.42.0 Mar 18, 2025 · issue -368

Semantic Kernel .NET 1.42.0 adds YAML plugin import, Mistral document passing, HuggingFace batch embeddings, and more connector enhancements.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.42.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.42.0
```
└──▷ USE IT
Use the SQL Server vector store with a connection string for safe concurrent access across threads.
csharp
```
var vectorStore = new SqlServerVectorStore("Server=myserver;Database=mydb;Trusted_Connection=True;");
```
- ›Adds SqlServerVectorStore support for accepting a connection string directly, enabling thread-safe usage of the SQL Server vector store connector.
- ›Adds functionality to create and import plugins with YAML-defined functions.
- ›Adds support for passing a document to Mistral AI chat model requests.
- ›Adds batch embedding generation support to the HuggingFace connector.
- ›Allows an HttpClient instance to be passed in when building an AzureOpenAI client from a service collection.
+4 moreshow less
- ›Promotes several OpenAPI APIs out of experimental status.
- ›Adds step uninitialization hooks for Steps in the Processes Local Runtime.
- ›Switches Postgres and SQL Server vector store packages to preview, and moves experimental designation to memory-store-only artifacts.
- ›Unifies collection deletion and creation APIs across MEVD (Memory and Embedding Vector Database) connectors.
└──▷ BREAKING ON UPGRADE
- !The KernelAIFunction name separator is reverted to use a dash, which may affect existing code relying on the previous separator.
python-1.24.1 Mar 13, 2025 · issue -368

Semantic Kernel Python 1.24.1 adds a Pinecone vector store connector.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.24.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.24.1
```
- ›Adds a Pinecone connector for vector store integration.
python-1.24.0 Mar 11, 2025 · issue -368

Semantic Kernel Python 1.24.0 adds a Faiss vector store connector and agent_id support for AzureAIAgent.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.24.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.24.0
```
- ›Supports agent_id as an identifier for AzureAIAgent in addition to assistant_id, enabling retrieval of existing Azure AI agents by their agent ID.
- ›Introduces the Faiss Connector for vector similarity search via the semantic-kernel Python library, adding FAISS as a supported vector store backend.
dotnet-1.41.0 Mar 11, 2025 · issue -368

Semantic Kernel .NET 1.41.0 adds AWS Bedrock text embeddings, HTTP request option access, Cloud Events abstractions, and public Bedrock agent clients.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.41.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.41.0
```
- ›Adds mechanism to access HTTP request options, exposing lower-level control over outbound calls made by the kernel.
- ›Implements text embedding generation support for AWS Bedrock, extending the Bedrock connector beyond inference to embeddings.
- ›Makes Bedrock agent clients required and public, enabling direct programmatic access to the underlying AWS Bedrock agent client objects.
- ›Publishes Cloud Events abstractions for processing and publishing events, introducing a new eventing surface to the .NET SDK.
- ›Adds missing Ollama Connector Aspire-friendly extensions, enabling Aspire-integrated registration of the Ollama connector.
+4 moreshow less
- ›Applies a JSON converter for exceptions when serializing chat history, improving structured serialization of ChatHistory containing exception data.
- ›Exposes ChatMessageContent.Content property by removing EditorBrowsable(EditorBrowsableState.Never), making it fully accessible in IDE tooling.
- ›March 2025 VectorData updates bring new capabilities to the vector data layer.
- ›Adds .NET 9 formatting support across the SDK.
python-1.23.0 Mar 6, 2025 · issue -368

Semantic Kernel Python adds experimental RealtimeClients for OpenAI WebSockets, WebRTC, and Azure OpenAI WebSockets.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.23.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.23.0
```
- ›Introduces experimental RealtimeClients for OpenAI over WebSockets and WebRTC, and for Azure OpenAI over WebSockets, enabling low-latency real-time AI interactions from Python.
python-1.22.0 Feb 28, 2025 · issue -369

Semantic Kernel Python 1.22.0 adds get_response API, AutoGen 0.2 integration, and new vector store connectors for Cosmos DB and Chroma.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.22.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.22.0
```
└──▷ USE IT
Get a single agent response without managing threads or streams — useful for simple request/response workflows.
python
```
response = await agent.get_response(chat_history)
```
Construct an agent with plugins inline to avoid boilerplate kernel setup.
python
```
agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    instructions="Answer questions about the world.",
    plugins=[SamplePlugin()],
)
```
Wrap an AutoGen 0.2 ConversableAgent for use inside the Semantic Kernel agent framework.
python
```
from semantic_kernel.agents.autogen.autogen_conversable_agent import AutoGenConversableAgent

cathy_autogen_agent = AutoGenConversableAgent(conversable_agent=cathy)
joe_autogen_agent = AutoGenConversableAgent(conversable_agent=joe)

async for content in cathy_autogen_agent.invoke(
    recipient=joe_autogen_agent, message="Tell me a joke about the stock market.", max_turns=3
):
    print(f"# {content.role} - {content.name or '*'}: '{content.content}'")
```
- ›Adds agent.get_response(chat_history) method as a simpler alternative to invoke and invoke_stream for retrieving a single agent response.
- ›Adds plugins parameter to agent constructors (e.g. ChatCompletionAgent) so plugins can be passed directly at construction time without manually building a kernel.
- ›Adds AutoGenConversableAgent class in semantic_kernel.agents.autogen.autogen_conversable_agent to wrap AutoGen 0.2 ConversableAgent objects for use within the SK agent ecosystem.
- ›Introduces AzureCosmosDBforMongoDB vector store and collection connector.
- ›Introduces a Chroma connector built on the new vector store design.
+1 moreshow less
- ›Adds a feature decorator supporting experimental and release-candidate decoration of SK APIs.
└──▷ BREAKING ON UPGRADE
- !Enhancements to AzureAssistantAgent and OpenAIAssistantAgent introduce breaking changes for users upgrading from versions prior to 1.22.0 — consult the migration guide at https://learn.microsoft.com/semantic-kernel/support/migration/agent-framework-rc-migration-guide?pivots=programming-language-python.
dotnet-1.40.0 Feb 28, 2025 · issue -369

Semantic Kernel .NET adds OpenAPI parameter support for schema-only definitions and promotes several Agents packages.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.40.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.40.0
```
- ›Adds support for OpenAPI parameters defined with a JSON schema but without an explicit type field, broadening compatibility with non-standard OpenAPI specs.
- ›Promotes .Net Agents experimental metadata toward graduation, signaling stable API surfaces for agent-based workflows.
- ›Marks Agents.OpenAI package with a preview suffix, making its pre-release status explicit in NuGet.
dotnet-1.39.0 Feb 25, 2025 · issue -369

Semantic Kernel dotnet-1.39.0 adds prompt execution settings to AutoFunctionInvocationContext, Process Framework with Aspire demo, and OpenAI/Azure AI tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.39.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.39.0
```
- ›Adds PromptExecutionSettings to AutoFunctionInvocationContext, giving function invocation filters access to the active execution settings at invocation time.
- ›Introduces the Process Framework with an Aspire demo, enabling orchestration of multi-step AI processes.
- ›Adds distributed traces for OpenAI Assistant and Azure AI agent channels, surfacing observability into agent communication.
- ›Updates the Agents templating pattern in .Net Agents, aligning agent prompt construction with current Semantic Kernel conventions.
- ›Changes Agents.Abstractions to depend on SemanticKernel.Abstractions instead of SemanticKernel.Core, reducing the package dependency footprint for agent abstractions.
dotnet-1.38.0 Feb 20, 2025 · issue -369

Semantic Kernel 1.38.0 adds AWS Bedrock Agent, role-override for ChatCompletionAgent, and a max completion tokens parameter for Azure OpenAI.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.38.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.38.0
```
└──▷ USE IT
Override the role that a ChatCompletionAgent uses when emitting its messages, useful when the downstream model expects a specific role.
csharp
```
var agent = new ChatCompletionAgent
{
    Name = "Analyst",
    Instructions = "You are a data analyst.",
    RoleOverride = AuthorRole.System
};
```
- ›Adds BedrockAgent to the .NET SDK, integrating AWS Bedrock Agent as a first-class agent type.
- ›Adds role-override support for ChatCompletionAgent, allowing callers to specify a non-default message role for agent turns.
- ›Adds a max completion tokens override parameter to the Azure OpenAI connector (AzureOpenAIPromptExecutionSettings).
- ›Promotes AllowStrictSchemaAdherence property out of experimental status, making it a stable API.
- ›Adds an option to disable automatic HTML decoding in Handlebars templates.
+1 moreshow less
- ›Removes the obsolete VolatileVectorStore and all references to it.
└──▷ BREAKING ON UPGRADE
- !VolatileVectorStore has been removed; any code referencing it will fail to compile after upgrading.
python-1.21.1 Feb 14, 2025 · issue -369

Semantic Kernel Python 1.21.1 adds Crew.AI as a plugin and a new AzureAIAgent.create_client convenience method.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.21.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.21.1
```
└──▷ USE IT
Create an Azure AI Agent client using the new AzureAIAgent.create_client class method instead of constructing AIProjectClient manually.
python
```
async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(
        credential=creds,
        conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
    ) as client,
):
    # Operational code here
```
- ›Adds AzureAIAgent.create_client class method for creating an AIProjectClient directly on the agent, replacing the previous construction pattern.
- ›Adds Crew.AI as a plugin, enabling Crew.AI agents to be called as Semantic Kernel plugins.
python-1.21.0 Feb 12, 2025 · issue -369

Semantic Kernel Python 1.21 adds Azure AI Agent Service, Bedrock Agent, MongoDB Atlas store, and Postgres vector search.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.21.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.21.0
```
└──▷ TRY IT
Connect an Azure AI Agent to a Semantic Kernel plugin for your first end-to-end agent workflow.
```
$ # From the repo root
python python/samples/getting_started_with_agents/azure_ai_agent/step1_azure_ai_agent.py
```
- ›Adds AzureAIAgent integration via the Azure AI Agent Service, enabling Semantic Kernel plugins to back Azure AI Agents — see getting_started_with_agents/azure_ai_agent.
- ›Adds BedrockAgent integration, exposing AWS Bedrock agents within the Semantic Kernel agent framework — see samples/concepts/agents/bedrock_agent.
- ›Adds vector search support to the Postgres connector.
- ›Implements a MongoDB Atlas vector store connector.
- ›Allows the Azure AI Inference connector to target Azure AI Services resources (not only standalone inference endpoints).
+5 moreshow less
- ›Allows factory callbacks to be registered in the process framework, enabling dynamic step construction via ProcessBuilder.
- ›Adds ndarray support for binary content initializations.
- ›Adds experimental Python 3.13 support.
- ›Introduces allowed content-type filtering in the chat history channel receive path, with a new mixed-chat image sample.
- ›Removes the default value of parallel_tool_calls following the bump to the newer openai package.
└──▷ BREAKING ON UPGRADE
- !The default value of parallel_tool_calls has been removed from the openai package integration; callers that relied on the previous default may see changed behavior after upgrading.
dotnet-1.37.0 Feb 12, 2025 · issue -369

Semantic Kernel .NET 1.37.0 updates OpenAI connectors to 2.2.0-beta.1 and migrates Prompty support to prompty.core
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.37.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.37.0
```
- ›Updates {Azure}OpenAI connectors to the latest 2.2.0-beta.1 SDK release.
- ›Migrates Prompty support to use the prompty.core package.
- ›Adds Copilot agent plugins demo samples.
dotnet-1.36.1 Feb 7, 2025 · issue -369

Semantic Kernel 1.36.1 adds audio content support for the Gemini connector.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.36.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.36.1
```
- ›Adds audio content capabilities to the Gemini connector, enabling audio input/output handling via AudioContent in .NET.
dotnet-1.36.0 Feb 4, 2025 · issue -369

Semantic Kernel .NET 1.36.0 adds CrewAI plugin, graduates OpenAPI package, and introduces agent content allow-lists with improved tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.36.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.36.0
```
- ›Introduces ChatCompletionAgent allow-list of supported content types, letting callers restrict which content kinds the agent may process.
- ›Adds a CrewAI plugin integration, enabling Semantic Kernel agents to interoperate with CrewAI workflows.
- ›Graduates the OpenAPI package out of preview, making Microsoft.SemanticKernel.Plugins.OpenApi a stable dependency.
- ›Adds distributed traces for Agent invocations, surfacing per-call observability data in connected tracing backends.
- ›Updates agent logs to include the agent name, making multi-agent log streams easier to distinguish.
+1 moreshow less
- ›Updates chat history reducers to include the system message when truncating history.
python-1.20.0 Jan 29, 2025 · issue -370

Semantic Kernel Python 1.20.0 adds chat history reducers, prompt template config for agents, and an instruction_role parameter for reasoning models.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.20.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.20.0
```
└──▷ USE IT
Use instruction_role='developer' when targeting OpenAI reasoning models so that system messages are sent as developer-role messages.
python
```
chat_service = OpenAIChatCompletion(service_id=service_id, instruction_role="developer")
```
- ›Adds instruction_role keyword argument to OpenAIChatCompletion and AzureChatCompletion, converting AuthorRole.SYSTEM messages to AuthorRole.DEVELOPER before sending to the model — enabling correct behavior with reasoning models like o1.
- ›Replaces ChatCompletionAgent's execution_settings constructor parameter with KernelArguments(settings=<execution_settings>), enabling use of the AI Service Selector inside ChatCompletionAgent.
- ›Adds Chat History Reducer support, allowing agents and chat completion flows to summarize or truncate history, including preservation of FunctionCallContent and FunctionResultContent items.
- ›Adds prompt template config and KernelArguments support for ChatCompletionAgent and AssistantAgent, aligning Python agent templating with the .NET Agent Framework.
- ›Adds Deepseek service support in concept samples, demonstrating integration with the Deepseek model provider.
└──▷ BREAKING ON UPGRADE
- !The ChatCompletionAgent execution_settings constructor parameter has been removed; pass execution settings via KernelArguments(settings=<execution_settings>) instead.
dotnet-1.35.0 Jan 28, 2025 · issue -370

Semantic Kernel dotnet-1.35.0 adds Azure AI Agent support, Ollama/Aspire integration, cloud-event scaffolding, and Gemini cached-content settings.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.35.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.35.0
```
└──▷ USE IT
Cache a large system prompt with Gemini to avoid re-processing it on every call, reducing latency and token cost.
csharp
```
var settings = new GeminiPromptExecutionSettings
{
    CachedContent = "cachedContents/my-cached-system-prompt"
};
var result = await kernel.InvokePromptAsync(prompt, new KernelArguments(settings));
```
- ›Adds CachedContent property to GeminiPromptExecutionSettings for controlling Gemini prompt caching behavior.
- ›Adds Azure AI Agent support via the Agents package (#10134), enabling Azure AI Foundry-hosted agents alongside existing agent types.
- ›Adds Ollama extension for improved .NET Aspire integration experience.
- ›Introduces SK Process Cloud Events publish interface abstractions and scaffolding, enabling cloud-event-driven process orchestration.
- ›Moves IChatHistoryReducer from the Agents package into core SK packages, broadening its availability across the library.
+2 moreshow less
- ›Updates ChatPromptParser to support zero-or-more text parts per message instead of a single value, enabling richer multi-part chat prompt construction.
- ›Adds improved auto-recovery logic for Azure OpenAI models under transient failures.
dotnet-1.34.0 Jan 22, 2025 · issue -370

Semantic Kernel dotnet-1.34.0 adds Base64 image support for MistralAI, structured output schema for Google Gemini, and async streaming for Bedrock Converse.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.34.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.34.0
```
- ›Adds support for Base64 encoded images in MistralAI connector, enabling inline image payloads without external URLs.
- ›Adds structured outputs (response schema) support for Google Gemini, allowing callers to constrain model responses to a defined schema.
- ›Adds async support for ConverseStreamResponse in the AWS Bedrock connector to avoid thread blocking during streaming.
- ›Adds a request index to streamed function call update content, enabling callers to correlate parallel streamed tool calls.
python-1.19.0 Jan 22, 2025 · issue -370

Semantic Kernel Python 1.19.0 adds DEVELOPER role support for OpenAI o1 models and agent invocation tracing spans.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.19.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.19.0
```
- ›Adds agent invocation spans for observability tracing of agent calls.
- ›Supports the DEVELOPER role for OpenAI o1 models, enabling o1-compatible message construction.
python-1.18.0 Jan 7, 2025 · issue -370

Semantic Kernel Python 1.18.0 removes the deprecated OpenAI plugin and improves Azure assistant agent settings and retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.18.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.18.0
```
- ›Improves Azure assistant agent settings and retrieval operations.
- ›Removes the deprecated OpenAI plugin, aligning the Python library with the .NET version.
└──▷ BREAKING ON UPGRADE
- !The OpenAI plugin has been removed. Any code that relied on it will break on upgrade.
dotnet-1.33.0 Jan 7, 2025 · issue -370

Semantic Kernel 1.33.0 adds strict mode for OpenAI, a Postgres vector store, OpenAPI response factory, and name-based agent strategies.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.33.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.33.0
```
└──▷ USE IT
Attach metadata and a store reference to a prompt execution request, useful for tracing or persisting prompt state.
csharp
```
var settings = new OpenAIPromptExecutionSettings
{
    Store = true,
    Metadata = new Dictionary<string, string> { { "session", "abc123" } }
};
```
- ›Adds store and metadata properties to OpenAIPromptExecutionSettings for controlling prompt execution context.
- ›Adds strict mode support for OpenAI function calling via OpenAIPromptExecutionSettings.
- ›Adds a factory for customizing OpenAPI plugin responses, enabling per-operation response transformation.
- ›Adds PostgresVectorStore memory connector for vector similarity search backed by PostgreSQL.
- ›Adds support for name-based KernelFunctionSelectionStrategy and KernelFunctionTerminationStrategy in .NET Agents, allowing strategies to be resolved by function name.
+5 moreshow less
- ›Adds InnerContent metadata support to the Amazon Bedrock connector, exposing raw provider response data.
- ›Adds support for DateTime parameters in tools used with the Assistants API.
- ›Adds REST API operation URL, payload, and header customization via RestApiOperationRunner.
- ›Adds support for media types with parameters in REST API operation handling.
- ›Enables Mermaid flowchart code generation and image generation from flowcharts in Process framework.
python-1.17.1 Dec 19, 2024 · issue -371

Semantic Kernel Python 1.17.1 adds Ollama streaming tool calls, new OpenAI execution settings, and a per-request tool limit.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.17.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.17.1
```
└──▷ USE IT
Attach a response store reference and custom metadata to an OpenAI prompt execution call.
python
```
from semantic_kernel.connectors.ai.open_ai import OpenAIPromptExecutionSettings

settings = OpenAIPromptExecutionSettings(
    store="my-response-store",
    metadata={"session_id": "abc123", "user": "alice"}
)

result = await kernel.invoke_prompt(
    prompt="Summarize the following document.",
    settings=settings
)
```
- ›Adds store and metadata properties to OpenAIPromptExecutionSettings for richer prompt execution control.
- ›Enables streaming tool calls for the Ollama integration.
- ›Introduces a function_invoke_attempt index included with Streaming Chat Message Content (CMC) for tracking per-function invocation attempts.
- ›Adds agent name field regex validation to enforce naming constraints on agents.
- ›Includes the sessions plugin status key in the plugin return value.
+1 moreshow less
- ›Adds tool limit adjustment per request via TaoChenOSU's contribution.
dotnet-1.32.0 Dec 9, 2024 · issue -371

Semantic Kernel .NET 1.32.0 adds Structured Outputs in prompts, declarative agents, MistralAI image content, and a Gemini MIME-type parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.32.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.32.0
```
- ›Adds responseMimeType parameter to GeminiPromptExecutionSettings for explicit control over output MIME type.
- ›Adds Structured Outputs support in prompts, enabling schema-constrained LLM responses directly from prompt templates.
- ›Adds declarative agents support, allowing agents to be defined and loaded declaratively.
- ›Adds image content support for MistralAI function calling.
- ›Adds OpenAPI operations filtering, with new samples demonstrating how to selectively expose API operations.
python-1.17.0 Dec 5, 2024 · issue -371

Semantic Kernel Python 1.17.0 graduates filters and adds streaming usage-data yield for chat completions.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.17.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.17.0
```
- ›Graduates filters out of experimental status, adding an exception when a duplicate filter is added during registration.
- ›Yields StreamingChatMessageContent directly when usage data is available during streaming chat completion responses.
dotnet-1.31.0 Nov 27, 2024 · issue -372

Semantic Kernel .NET 1.31.0 promotes Filters out of experimental and adds implicit JsonElement-to-primitive conversion for SLM function calling.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.31.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.31.0
```
- ›Adds implicit conversion from JsonElement string values to primitives, enabling function calling with small language models (SLMs) that return string-typed JSON arguments.
- ›Removes experimental flags from the Filters API, making IFunctionFilter, IPromptFilter, and related filter interfaces stable for production use.
- ›Adds Azure OpenAI API version 2024-09-01-preview as a supported preview version.
python-1.16.0 Nov 21, 2024 · issue -372

Semantic Kernel Python 1.16.0 adds Azure AI Inference tracing and promotes the OpenAPI plugin to preview.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.16.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.16.0
```
- ›Adds Azure AI Inference tracing SDK integration for observability into Azure AI Inference calls.
- ›Promotes the OpenAPI plugin to preview status, signaling increased stability for production use.
dotnet-1.30.0 Nov 19, 2024 · issue -372

Semantic Kernel .NET 1.30.0 adds Map Step for Processes, AdditionalMessages and IAutoFunctionInvocationFilter for OpenAIAssistantAgent, and Copilot Agent Plugin support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.30.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.30.0
```
- ›Adds IAutoFunctionInvocationFilter support for OpenAIAssistantAgent, enabling auto-function invocation filtering in agent workflows.
- ›Adds AdditionalMessages support for OpenAIAssistantAgent to pass extra messages when invoking an assistant run.
- ›Adds incomplete status to the termination check for OpenAIAssistantAgent, so runs that end with an incomplete status are handled correctly.
- ›Introduces Map Step feature for .NET Processes, enabling fan-out/fan-in parallel step execution within a process.
- ›Adds support for Copilot Agent Plugins in .NET, allowing plugins authored for Microsoft Copilot to be imported and used.
+7 moreshow less
- ›Adds a document-transformation mechanism for OpenAPI (part 2), enabling programmatic modification of OpenAPI documents before plugin import.
- ›Makes OpenAPI model collection properties modifiable after construction, giving callers runtime control over OpenAPI model state.
- ›Promotes the Microsoft.SemanticKernel.Plugins.OpenApi package from experimental to preview status.
- ›Removes the experimental flag from FunctionResult.RenderedPrompt, making the rendered-prompt property stable API.
- ›Adds logging improvements in OpenAPI plugins for better observability of plugin HTTP interactions.
- ›Simplifies Process framework step implementation and function-event resolution for steps with a single function.
- ›Adds OnFunctionError event support in the .NET Processes framework for structured error handling within steps.
└──▷ BREAKING ON UPGRADE
- !Kernel events have been removed from .NET (Kernel events API is no longer available).
python-1.15.0 Nov 15, 2024 · issue -372

Semantic Kernel Python 1.15.0 adds audio I/O, Azure Cosmos DB NoSQL vector store, Google Search, and vector search across Weaviate, Redis, CosmosDB, and Qdrant.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.15.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.15.0
```
- ›Adds Azure Cosmos DB NoSQL Vector Store and Collection implementation, enabling vector storage and retrieval against CosmosDB NoSQL.
- ›Adds vector search to CosmosDB NoSQL Collections, Weaviate (including support for unnamed vectors), Redis collections, and Qdrant Collection.
- ›Introduces Google Search as a Text Search implementation.
- ›Adds audio-to-text capability for speech transcription workflows.
- ›Adds text-to-audio capability for speech synthesis workflows.
+1 moreshow less
- ›Adds the Dapr Runtime for Processes, enabling Dapr-backed process orchestration.
dotnet-1.29.0 Nov 13, 2024 · issue -372

Semantic Kernel .NET 1.29.0 promotes Liquid templates, adds Ollama function calling, and stabilizes VectorStore and agent serialization APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.29.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.29.0
```
- ›Promotes Liquid prompt template support from experimental to preview status.
- ›Adds function calling support to the MS AI Ollama connector.
- ›Removes the experimental flag from VectorStore implementations, marking them stable.
- ›Removes the experimental attribute from the new function calling model classes, marking them stable.
- ›Adds AgentChat serialization support for persisting and restoring agent chat state.
+4 moreshow less
- ›Moves OpenAPI extensions to the SemanticKernel namespace.
- ›Introduces part 1 of an OpenAPI parameter resolution mechanism.
- ›Updates the MS AI Azure Inference connector.
- ›Adds an example of OpenAI Realtime API usage.
└──▷ BREAKING ON UPGRADE
- !Obsolete filter classes have been removed; code referencing them will fail to compile after upgrading.
dotnet-1.28.0 Nov 7, 2024 · issue -372

Semantic Kernel 1.28.0 adds OpenAI image detail level support, OpenAPI security scheme access, multi-server parsing, and Dapr complex-type serialization.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.28.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.28.0
```
- ›Adds support for the OpenAI image detail level property in image content.
- ›Exposes the security scheme and requirement for OpenAPI functions, giving callers access to auth metadata on imported API operations.
- ›Supports parsing multiple servers from an OpenAPI document.
- ›Adds complex type serialization support for Dapr events and messages in the Process Framework.
- ›Simplifies event emission in Process Framework steps.
└──▷ BREAKING ON UPGRADE
- !OpenAPI model classes are renamed (see commit #9595) — existing code referencing the old class names will break on upgrade.
- !OpenAPI model classes are now marked experimental — code that was previously using them without suppressing experimental warnings may now produce build errors or warnings under strict configurations.
python-1.14.0 Nov 7, 2024 · issue -372

Semantic Kernel Python 1.14.0 adds vector and text search plus in-memory vector search support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.14.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.14.0
```
- ›Adds vector and text search capability to the Semantic Kernel Python library, with Azure AI Search hotel concept samples demonstrating implementation.
- ›Adds vector search support to the In Memory collection, enabling local in-process similarity search without an external vector store.
dotnet-1.27.0 Nov 5, 2024 · issue -372

Semantic Kernel 1.27.0 adds audio timestamp granularities, process-level error handling, and richer KernelFunction metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.27.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.27.0
```
└──▷ USE IT
Retrieve word- and segment-level timestamps from an audio transcription when using Gemini, useful for building subtitle generators or spoken-word search indexes.
csharp
```
var settings = new GeminiPromptExecutionSettings
{
    AudioTimestamp = true
};
var result = await kernel.InvokeAsync(audioToTextFunction, new KernelArguments(settings));
```
- ›Adds AudioTimestamp property to GeminiPromptExecutionSettings to control audio timestamp output for Gemini models.
- ›Adds Audio-to-Text Timestamp Granularities support for OpenAI and AzureOpenAI audio transcription.
- ›Exposes the REST API operation and operation path in KernelFunction.Metadata, giving plugins richer introspection over the underlying HTTP surface.
- ›Adds process-level error handler support in SK Processes (Processes State Management Part 2), enabling structured error recovery in multi-step process graphs.
- ›Improves logging for the function calls processor and KernelFunction, making agent execution traces more observable.
dotnet-1.26.0 Oct 31, 2024 · issue -373

Semantic Kernel 1.26.0 adds AWS Bedrock connector, parallel function calls, ME.AI bidirectional adapters, and Native AOT support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.26.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.26.0
```
└──▷ USE IT
Interop between Semantic Kernel services and Microsoft.Extensions.AI consumers using the new bidirectional adapters.
csharp
```
// Wrap an SK IChatCompletionService as an ME.AI IChatClient
IChatClient chatClient = kernel.GetRequiredService<IChatCompletionService>().AsChatClient();
```
- ›Adds ParallelFunctionCalls option to control parallel function call execution in .NET.
- ›Adds a streaming flag to filter context models, enabling streaming-aware filtering.
- ›Adds Amazon AWS Bedrock connector for .NET, expanding model provider integrations.
- ›Enables bidirectional adapters between Semantic Kernel and Microsoft.Extensions.AI interfaces.
- ›Adds GenericDataModel support to the Pinecone VectorStore connector.
+5 moreshow less
- ›Allows any key type when using a custom collection factory in VectorStore.
- ›Adds Native AOT support for .NET.
- ›Adds state management support to Processes (Part 1), enabling stateful process steps.
- ›Facilitates parallel execution of LocalProcess in .NET Processes.
- ›Updates Azure AI Inference to beta.2.
python-1.13.0 Oct 31, 2024 · issue -373

Semantic Kernel Python 1.13.0 adds Ollama tool call and image content support plus parallel tool call control for OpenAI.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.13.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.13.0
```
└──▷ USE IT
Disable parallel tool calls in an OpenAI chat completion request to force sequential tool execution.
python
```
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    parallel_tool_calls=False
)
```
- ›Adds parallel_tool_calls attribute to OpenAI chat prompt execution settings, enabling control over whether OpenAI calls tools in parallel during a completion.
- ›Adds support for Ollama tool calls and image content, bringing multimodal and function-calling capabilities to the Ollama connector.
- ›Allows callers to specify pre-existing file IDs when creating an assistant, avoiding redundant file uploads.
python-1.12.0 Oct 24, 2024 · issue -373

Semantic Kernel Python 1.12.0 adds ONNX and AWS Bedrock connectors, PostgreSQL vector store, process framework, and structured output support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.12.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.12.0
```
- ›Adds 'low' severity level to the ContentFilterResultSeverity enum, expanding content filter granularity.
- ›Adds a new ONNX connector for local model inference via the Semantic Kernel connector interface.
- ›Adds a new AWS Bedrock connector for integrating Bedrock-hosted models.
- ›Adds Vector Store support to the PostgreSQL connector.
- ›Adds OpenAI Structured Output response_format support for constrained, schema-driven completions.
+3 moreshow less
- ›Adds streaming code output for OpenAI Assistants, surfacing code interpreter results in real time.
- ›Adds ability to specify a default timeout for the Assistant polling operation.
- ›Introduces the Python process framework for orchestrating multi-step agent processes.
dotnet-1.25.0 Oct 23, 2024 · issue -373

Semantic Kernel .NET 1.25.0 adds Pinecone vector search, MongoDB memory connector, SQL Server vector support, concurrent parallel function calls, and streaming tool call output.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.25.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.25.0
```
- ›Adds vector search support to the Pinecone connector for .NET.
- ›Adds a MongoDB connector implementation for the new memory/vector design in .NET.
- ›Adds SQL Server vector support (Dm/sqlserver/vector) for .NET.
- ›Invokes parallel function calls concurrently in .NET, enabling parallel tool execution in a single inference turn.
- ›Scopes step IDs to a process in .NET Processes, reducing cross-process ID collisions.
+9 moreshow less
- ›Supports shared runtime code for .NET Processes.
- ›Emits streaming function call content for the Assistant Agent in .NET.
- ›Adds server URLs to additional properties in .NET OpenAPI/connector metadata.
- ›Adds the ability to specify a default timeout for polling operations in the Python SDK.
- ›Returns streaming tool call output to the caller in the Python SDK.
- ›Improves vector search query in the Azure CosmosDB NoSQL connector for .NET.
- ›Adds image-to-text support to the RAG sample for .NET.
- ›Adds .NET samples showing interop with LangChain-ingested data.
- ›Adds an example for retrieving citations from a 'chat with data' response in .NET.
dotnet-1.24.1 Oct 18, 2024 · issue -373

Semantic Kernel dotnet-1.24.1 adds a SQLite vector store connector and JSON Schema generation for .NET Processes.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.24.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.24.1
```
- ›Adds SQLite connector for the new memory/vector store design (Microsoft.SemanticKernel.Connectors.Sqlite or equivalent vectordata implementation).
- ›.NET Processes now generates JSON Schema from a Type directly, replacing manual schema definition.
dotnet-1.24.0 Oct 17, 2024 · issue -373

Semantic Kernel .NET adds a Dapr runtime backend for the Process framework.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.24.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.24.0
```
- ›Adds a Dapr runtime for the Processes framework, enabling distributed, durable process orchestration via Dapr.
dotnet-1.23.0 Oct 17, 2024 · issue -373

Semantic Kernel .NET 1.23.0 adds new Process error handling, fluent edge building, VectorStore search, ONNX and Bedrock connectors, and CreateFromType factory methods.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.23.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.23.0
```
- ›Adds OnError event handling exposure in .NET Processes via Expose OnError Event Handling, enabling structured error routing within process graphs.
- ›Adds fluent edge building API for .NET Processes, allowing process step connections to be defined with a fluent builder pattern.
- ›Adds CreateFromType and CreateMetadataFromType static factory methods for constructing kernel function metadata from CLR types.
- ›Adds AddVectorStoreTextSearch support for service IDs on dependencies, allowing named DI registrations to be resolved for text search services.
- ›Adds collection registration methods for the InMemory vector store connector, enabling IVectorStore collection lifecycle management in-process.
+14 moreshow less
- ›Removes the class constraint from VectorStore record generics, allowing value types and non-reference types as vector store records.
- ›Removes the notnull constraint from the generic data model for vector records.
- ›Adds default index kind and distance function defaults for the Azure CosmosDB MongoDB connector.
- ›Adds default index kind and distance function defaults for the Azure CosmosDB NoSQL connector.
- ›Adds getting-started samples for Text Search, covering InMemory, Qdrant, and Google text search integrations.
- ›Adds vector search RAG sample demonstrating retrieval-augmented generation with the VectorStore abstraction.
- ›Moves VectorStore abstractions and VolatileVectorStore to updated package locations in preparation for stable release.
- ›Adds OpenAI support to the RAG sample.
- ›Makes the endpoint parameter in AddHuggingFaceChatCompletion optional.
- ›Adds backward compatibility and data migration examples for VectorStore record schemas.
- ›Adds Python Bedrock connector for Amazon Bedrock model access.
- ›Adds Python ONNX connector for local ONNX model inference.
- ›Adds low severity level to the Python ContentFilterResultSeverity enum.
- ›Adds process abstractions and core builders updated in preparation for Dapr runtime support.
dotnet-1.22.0 Oct 8, 2024 · issue -373

Semantic Kernel 1.22.0 adds sub-process support, code-interpreter streaming, usage metadata, and richer ITextToImageService abstractions.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.22.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.22.0
```
- ›Adds optional version parameter to Azure OpenAI API connectors, allowing callers to pin a specific API version per request.
- ›Expands ITextToImageService abstractions to support ExecutionSettings, enabling per-call generation configuration.
- ›Adds token usage and other metadata to Assistant agent responses for cost and observability tracking.
- ›Adds usage metadata to OpenAI streaming chunks, surfacing token counts during streamed completions.
- ›Implements generic data model support for the Weaviate connector, matching the generic data model pattern available in other vector store connectors.
+7 moreshow less
- ›Supports sub-processes in the Process Framework, enabling nested process composition.
- ›Includes code and output generated by the code-interpreter tool in streaming output for agent runs.
- ›Adds lazy step initialization to the Process Framework.
- ›Improves mapper efficiency for Pinecone and Redis hashsets.
- ›Improves mapping efficiency for Qdrant by removing the JSON intermediary layer.
- ›Updates OpenAI connector to 2.0.0-beta.12 and Azure OpenAI connector to 2.0.0-beta.6.
- ›Updates Azure/OpenAI connectors to 2.1.0-beta.1.
└──▷ BREAKING ON UPGRADE
- !Gemini connector no longer throws an exception on invalid responses — previously raised exceptions are suppressed, which may change error-handling behavior in code that caught those exceptions.
python-1.11.0 Oct 2, 2024 · issue -373

Semantic Kernel Python 1.11.0 adds streaming support for OpenAI Assistants and improved Anthropic function calling.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.11.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.11.0
```
- ›Adds streaming support for OpenAI Assistants, enabling real-time token-by-token output from assistant runs.
- ›Updates Anthropic function calling to support latest function-calling capabilities in the Anthropic integration.
python-1.10.1 Sep 30, 2024 · issue -374

Semantic Kernel Python 1.10.1 makes azure-identity a default dependency and adds a Guided Conversations sample.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.10.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.10.1
```
- ›Promotes azure-identity to a default (non-optional) dependency, removing the need for manual installation when using Azure-backed services.
- ›Adds a Guided Conversations sample (v0.1.0) demonstrating structured multi-turn conversation workflows.
python-1.10.0 Sep 26, 2024 · issue -374

Semantic Kernel Python 1.10.0 adds DefaultAzureCredential auth, OpenAI json_schema response format, and streaming token usage.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.10.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.10.0
```
- ›Supports DefaultAzureCredential authentication for Azure Resources in Azure OpenAI connectors.
- ›Supports DefaultAzureCredential authentication for AzureAI Inference connectors.
- ›Supports all auth options for Azure AI Search.
- ›Adds json_schema response format support for OpenAI completions.
- ›Exposes token usage data in streaming content responses.
dotnet-1.21.1 Sep 25, 2024 · issue -374

Semantic Kernel .NET 1.21.1 adds generic data model support for the Azure Cosmos DB NoSQL connector.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.21.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.21.1
```
- ›Adds generic data model support to the Azure CosmosDB NoSQL connector, enabling flexible schema-less document operations without predefined entity types.
dotnet-1.21.0 Sep 25, 2024 · issue -374

Semantic Kernel .NET 1.21.0 adds Process orchestration, Agent prompt templates, generic CosmosDB MongoDB model support, and polymorphic chat serialization.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.21.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.21.0
```
└──▷ USE IT
Invoke an OpenAI Assistant agent in streaming mode without supplying an initial message list, now that messages is optional.
csharp
```
await foreach (var response in agent.InvokeStreamingAsync(thread))
{
    Console.WriteLine(response.Content);
}
```
- ›Adds messages parameter as optional for OpenAIAssistantAgent.InvokeStreamingAsync, removing the requirement to supply a message list on every streaming invocation.
- ›Supports prompt templates for .NET Agents, enabling KernelFunction-based agent definitions to accept structured prompt template inputs.
- ›Updates KernelFunction-based strategies for AgentGroupChat with revised behavior.
- ›Supports polymorphic serialization of ChatMessageContent and its derived classes.
- ›Adds generic data model support for the Azure CosmosDB MongoDB vector store connector.
+1 moreshow less
- ›Adds Feature Processes support for .NET, enabling structured multi-step process orchestration within Semantic Kernel.
└──▷ BREAKING ON UPGRADE
- !The Redis hash-set vector store prefix default is switched to true; existing setups that relied on the previous default of false will address keys differently after upgrade.
dotnet-1.20.0 Sep 17, 2024 · issue -374

Semantic Kernel 1.20.0 adds OpenAI Structured Outputs, a new function-calling model, generic vector-store data models, and Prompty file providers for .NET.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.20.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.20.0
```
- ›Adds FunctionCallContent exception handling consistency improvements to the function-calling pipeline.
- ›Introduces OpenAI Structured Outputs support (Option 1 and Option 2) for the OpenAI and Azure OpenAI connectors.
- ›Adds a new function-calling model for .NET (PR #8811), providing an updated API surface for invoking kernel functions.
- ›Adds generic data model and mapper for the Azure AI Search vector store connector, enabling schema-free document storage and retrieval.
- ›Adds generic data model mapper for Qdrant vector store connector.
+4 moreshow less
- ›Adds generic data model support for the Redis vector store connector.
- ›Adds dotnet Prompty file providers, enabling loading of .prompty prompt files directly from the filesystem.
- ›Removes float64 from supported vector types in the Qdrant connector, aligning with Qdrant's supported formats.
- ›Adds streaming support and additional assistant options for .NET Agents.
└──▷ BREAKING ON UPGRADE
- !The Qdrant connector no longer supports float64 as a vector element type; embeddings using float64 will need to be migrated to a supported type.
python-1.9.0 Sep 16, 2024 · issue -374

Semantic Kernel Python 1.9.0 adds Mistral AI function calling support and new abstract AI connector methods.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.9.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.9.0
```
- ›Adds Mistral AI function calling support via the MistralAI AI connector, enabling tool/plugin invocation through Mistral models.
- ›Introduces new abstract methods on the AI Connector base class, expanding the interface for implementing custom AI service connectors.
- ›Adds a parallel function calling sample demonstrating concurrent tool invocation across AI services.
dotnet-1.19.0 Sep 10, 2024 · issue -374

Semantic Kernel .NET 1.19 adds Azure AI Inference and Ollama connectors, streaming for OpenAIAssistantAgent, and Azure Credential support for Cognitive Services.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.19.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.19.0
```
- ›Adds new Azure AI Inference connector, enabling chat and embedding calls through the Azure AI Inference API (#7963).
- ›Adds new Ollama connector for local model inference via Ollama.
- ›Adds streaming support for OpenAIAssistantAgent and AgentChat in the .NET Agents framework.
- ›Switches Azure Cognitive Services authentication from API keys to Azure Credentials (token-based auth).
- ›Adds new Weaviate connector implementing the new memory/vector store design.
+2 moreshow less
- ›Adds ONNX demo and concept samples illustrating local inference with Microsoft.ML.OnnxRuntimeGenAI.
- ›Removes obsolete support for OpenAI ChatGPT plugins.
dotnet-1.18.2 Sep 4, 2024 · issue -374

Semantic Kernel .NET 1.18.2 adds Azure Cosmos DB connectors, data URI image support in chat templates, and OpenAPI server-variable support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.18.2 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.18.2
```
- ›Adds ImageContent support for data URIs in ChatPromptParser, enabling chat prompt templates to embed base64-encoded images directly.
- ›Adds JSON serializer options and user-agent string passthrough from vector store options down to underlying connectors via Vector Store options.
- ›Adds support for OpenAPI descriptions that use server variables, expanding the range of OpenAPI specs Semantic Kernel can consume.
- ›Adds Azure Cosmos DB for MongoDB connector implementing the new memory/vector-store design.
- ›Adds Azure Cosmos DB for NoSQL connector implementing the new memory/vector-store design.
+2 moreshow less
- ›Promotes OpenAI V2 and Assistants V2 integrations to general availability (GA) for .NET.
- ›Adds F# script samples (.fsx) including a Hugging Face chat completion demo under the Demos folder.
python-1.8.0 Aug 22, 2024 · issue -375

Semantic Kernel Python 1.8.0 adds OpenTelemetry metrics instrumentation to the kernel.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.8.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.8.0
```
- ›Adds metrics instrumentation to the kernel, exposing counters, histograms, and observable gauges via OpenTelemetry for observability into kernel operations.
dotnet-1.17.2 Aug 21, 2024 · issue -375

Semantic Kernel 1.17.2 adds Azure CosmosDB MongoDB and NoSQL vector store connectors, server-variable OpenAPI support, and agent chat improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.17.2 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.17.2
```
- ›Adds Azure CosmosDB for MongoDB connector implementing the new vector memory store design (Microsoft.SemanticKernel.Connectors.AzureCosmosDBMongoDB).
- ›Adds Azure CosmosDB for NoSQL connector implementing the new vector memory store design (Microsoft.SemanticKernel.Connectors.AzureCosmosDBNoSQL).
- ›Allows JsonSerializerOptions and user-agent string to be passed through vector store options down to the underlying client.
- ›Adds support for OpenAPI descriptions that include server variables, enabling dynamic base-URL resolution at runtime.
- ›Adds OpenAPI customization hooks for fine-grained control over how OpenAPI operations are mapped to kernel functions.
+5 moreshow less
- ›Maps OpenAPI parameter types to KernelParameterMetadata for richer parameter introspection in OpenAPI-backed functions.
- ›Introduces 'Root' agent selection for .NET Agents, enabling explicit designation of the starting agent in multi-agent scenarios.
- ›Adds Reset support for AgentChat, allowing conversation state to be cleared without recreating the chat instance.
- ›Adds a classifiable KernelFunction logger for structured, filterable logging of kernel function invocations.
- ›Allows chat history mutation from auto-function invocation filters in the MistralAI connector.
python-1.7.0 Aug 21, 2024 · issue -375

Semantic Kernel Python 1.7.0 adds instrumentation to kernel functions with logging, tracing, and Application Insights monitoring.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.7.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.7.0
```
- ›Adds instrumentation (logs and traces) to kernel functions, with a sample application for monitoring via Application Insights.
python-1.6.0 Aug 20, 2024 · issue -375

Semantic Kernel Python 1.6.0 adds agent group chat and chat reset capabilities.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.6.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.6.0
```
- ›Introduces agent group chat functionality, enabling multiple agents to participate in a shared conversation.
- ›Introduces agent chat reset functionality, allowing an agent chat session to be cleared and restarted.
dotnet-1.17.1 Aug 7, 2024 · issue -375

Semantic Kernel .NET Agents gain a ChatHistory Reducer Pattern for managing conversation history.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.17.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.17.1
```
- ›Introduces the ChatHistory Reducer Pattern for .NET Agents, enabling controlled reduction of chat history passed to agents during multi-turn conversations.
dotnet-1.17.0 Aug 7, 2024 · issue -375

Semantic Kernel dotnet-1.17.0 adds VectorStore abstractions with 5 sample implementations and an AI Model Router demo.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.17.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.17.0
```
- ›Adds VectorStore abstractions and 5 sample implementations, enabling pluggable vector storage backends for retrieval-augmented workflows.
- ›Moves VectorStore dependency-injection extensions to the core namespace, making them available without extra package references.
- ›Adds an AI Model Router demo showing how to route prompts across multiple AI models within the same Semantic Kernel pipeline.
- ›Adds metadata identification of assistant code-interpreter responses in the .NET Agents framework, surfacing interpreter output distinctly from chat completions.
python-1.5.0 Aug 7, 2024 · issue -375

Semantic Kernel Python 1.5.0 adds new memory stores and vector store data models including a Pandas-backed store.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.5.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.5.0
```
- ›Adds new memory stores and collections, including a Pandas-backed memory store and new vector store data model support.
python-1.4.0 Aug 5, 2024 · issue -375

Semantic Kernel Python 1.4.0 adds Google AI, Vertex AI, Mistral AI embeddings, OpenAI Assistant Agent, and OpenTelemetry support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.4.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.4.0
```
└──▷ USE IT
Use the new Google AI connector to power a chat completion workflow with a Gemini model and function calling.
python
```
from semantic_kernel.connectors.ai.google_ai import GoogleAIChatCompletion

chat_service = GoogleAIChatCompletion(
    gemini_model_id="gemini-1.5-pro",
    api_key="<your-google-ai-api-key>"
)
```
- ›Adds OpenTelemetry integration for distributed tracing and observability within Semantic Kernel Python workflows.
- ›Adds a Google AI connector with function-calling support, enabling Gemini models as chat completion backends.
- ›Adds a Vertex AI connector with function-calling support for Google Cloud-hosted model endpoints.
- ›Introduces a non-chat, non-streaming OpenAIAssistantAgent class for stateful assistant interactions, including samples and tests.
- ›Adds a Mistral AI embedding connector, expanding vector/embedding generation options beyond OpenAI.
dotnet-1.16.1 Jul 23, 2024 · issue -376

Semantic Kernel .NET 1.16.1 adds GenAI support to ONNX connector and enriches auto function invocation filter context.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.16.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.16.1
```
- ›Adds GenAI support to Connectors.Onnx, enabling local ONNX model inference through the standard Semantic Kernel GenAI pipeline.
- ›Adds additional data to the AutoFunctionInvocationFilterContext to give filter implementations richer context when intercepting automatic function calls.
- ›Adds AgentChat serialization support, enabling agent conversation state to be persisted and restored.
- ›Adds Assistant V2 support for Agents, aligning the agent framework with the OpenAI Assistants v2 API.
- ›Adds Agent History Propagation so conversation history is shared across agents in multi-agent scenarios.
+1 moreshow less
- ›Handles missing operationId fields in OpenAPI specs so connectors no longer fail when specs omit that field.
python-1.3.0 Jul 23, 2024 · issue -376

Semantic Kernel Python 1.3.0 adds a standalone chat completion agent, Ollama SDK migration, and Azure AI Inference application ID support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.3.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.3.0
```
- ›Adds application_id support for the Azure AI Inference connector.
- ›Introduces the single, non-group chat completion agent class with concept samples.
- ›Migrates the Ollama integration to the official Ollama Python SDK.
- ›Adds singular get methods to kernel collections for retrieving individual items without iterating.
- ›Improves JSON schema generation for Union and Optional type annotations in kernel functions.
dotnet-1.16.0 Jul 16, 2024 · issue -376

Semantic Kernel 1.16.0 adds NexusRaven function calling, OpenAPI-as-plugin-description, Kernel-free OpenAPI plugin creation, and graduated Filters API.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.16.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.16.0
```
└──▷ USE IT
Pass custom JSON serialization options to TextMemoryPlugin when your memory store uses non-default naming or converters.
csharp
```
var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
var memoryPlugin = new TextMemoryPlugin(memory, jsonSerializerOptions: options);
kernel.ImportPluginFromObject(memoryPlugin);
```
- ›Enables creating a KernelPlugin from an OpenAPI spec without requiring a Kernel instance, simplifying plugin instantiation in DI and test scenarios.
- ›Uses the OpenAPI description field as the default plugin description when importing OpenAPI-based plugins.
- ›Graduates the Filters API from experimental to stable, making prompt and function invocation filters production-ready.
- ›Adds dynamic logging methods to the .NET Agents framework.
- ›Supports custom JsonSerializerOptions passed to TextMemoryPlugin for serialization control.
+4 moreshow less
- ›Adds a sample demonstrating function calling with the NexusRaven model.
- ›Adds a sample showing the model thought process for each function call.
- ›Improves DuckDBMemoryStore.RemoveBatchAsync performance by using arrays instead of lists.
- ›Improves Pinecone.RemoveBatchFromNamespaceAsync performance.
python-1.2.0 Jul 9, 2024 · issue -376

Semantic Kernel Python 1.2.0 adds Mistral AI chat, Azure Model-as-a-Service connector, and cross-model function calling abstraction.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.2.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.2.0
```
- ›Introduces FunctionChoiceBehavior, a new function-calling abstraction that enables function calling for models beyond OpenAI (the existing FunctionCallBehavior continues to work but migration is encouraged).
- ›Adds a new Azure Model-as-a-Service connector to the Python SDK.
- ›Adds support for function calling via the Azure AI Inference connector.
- ›Adds Mistral AI Chat Completion support.
dotnet-1.15.1 Jul 3, 2024 · issue -376

Semantic Kernel 1.15.1 adds streaming for ChatCompletionAgent, Gemini system-message support, and single-agent OpenAIAssistantAgent invocation.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.15.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.15.1
```
- ›Adds cancellation token support to filter context types.
- ›Adds streaming support for ChatCompletionAgent in the Agents framework.
- ›Enables single-agent / no-chat invocation of OpenAIAssistantAgent.
- ›Supports direct logger association with an Agent.
- ›Adds Gemini support for system messages and removes message-order limitations.
+4 moreshow less
- ›Supports loading native functions from YAML files.
- ›Adds SQL Server JSON support for memory connectors (Dm/sqlserver/json).
- ›Adds batch delete query optimization in the SQLite memory connector.
- ›Adds plugin selection example using vector search.
python-1.1.2 Jun 24, 2024 · issue -377

Semantic Kernel Python 1.1.2 adds a custom service selector sample and automatic .env file fallback for service configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.1.2 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.1.2
```
- ›Defaults to a relative .env file when no env_file is configured, removing the need to explicitly set a path for local development.
- ›Adds a custom service selector sample demonstrating how to implement and register a custom selector for AI service routing.
dotnet-1.15.0 Jun 19, 2024 · issue -377

Semantic Kernel 1.15.0 adds OpenAPI request interception, function-call streaming, multi-result support, and FrugalGPT cost-optimization examples.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.15.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.15.0
```
└──▷ USE IT
Stream a chat completion that includes tool/function calls, processing each chunk as it arrives.
csharp
```
await foreach (var update in kernel.InvokeStreamingAsync<StreamingChatMessageContent>(function, arguments))
{
    if (update.Items.OfType<StreamingFunctionCallUpdateContent>().Any())
    {
        // Handle incremental function call content in real time
        foreach (var callUpdate in update.Items.OfType<StreamingFunctionCallUpdateContent>())
            Console.Write(callUpdate.Arguments);
    }
}
```
- ›Adds mechanism to modify HttpRequestMessage for OpenAPI calls via KernelFunctionMetadata, enabling per-request header or body manipulation before dispatch.
- ›Supports function call content classes for the AI streaming API, enabling real-time parsing of tool-call responses in streaming mode.
- ›Adds NopPromptTemplateFactory implementation for cases where prompt templating should be bypassed entirely.
- ›Adds support for multiple chat and text results returned from a single Kernel invocation.
- ›Adds support for dall-e-3 model in the OpenAIImageGeneration class.
+5 moreshow less
- ›Supports assistant tool content generation in the .NET Agents framework.
- ›Adds examples demonstrating FrugalGPT techniques for LLM cost and performance optimization.
- ›Adds example showing how to retrieve the list of function calls inside an auto function invocation filter.
- ›Adds version identifier to CodeInterpreter API calls.
- ›Graduates Kernel Contents classes out of experimental status.
python-1.1.0 Jun 13, 2024 · issue -377

Semantic Kernel Python 1.1.0 adds image content support in chat messages.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.1.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.1.0
```
- ›Adds support for image content in chat messages, enabling multimodal inputs to be handled natively in the library.
dotnet-1.14.0 Jun 4, 2024 · issue -377

Semantic Kernel .NET 1.14.0 adds Prompty template API, AzureChatExtensionsOptions, Fluid-based Liquid templates, and streaming termination results.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.14.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.14.0
```
└──▷ USE IT
Configure Azure OpenAI chat extensions (e.g. Azure Search grounding) using the new AzureChatExtensionsOptions property instead of the deprecated WithData pattern.
csharp
```
var executionSettings = new AzureOpenAIPromptExecutionSettings
{
    AzureChatExtensionsOptions = new AzureChatExtensionsOptions
    {
        Extensions = { new AzureSearchChatExtensionConfiguration { ... } }
    }
};
```
- ›Adds AzureChatExtensionsOptions property to the Azure OpenAI connector for configuring chat extensions (deprecates the previous WithData classes).
- ›Adds API to create a PromptTemplateConfig directly from a Prompty template file.
- ›Updates LiquidPromptTemplate to use the Fluid rendering engine instead of Scriban.
- ›Streaming API now returns the result of the function executed immediately before termination, rather than discarding it.
- ›Includes request metadata in KernelException when a response cannot be deserialized, improving error diagnostics.
python-1.0.4 Jun 3, 2024 · issue -377

Semantic Kernel Python 1.0.4 adds Bing Custom Search support and async template rendering.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.0.4 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.0.4
```
- ›Adds async support for template rendering, enabling non-blocking prompt template evaluation in async Python applications.
- ›Adds Bing Custom Search integration via the Bing connector, supporting scoped web search within defined custom search instances.
- ›Introduces Pydantic settings configuration, allowing connector and service settings to be managed through Pydantic-based config models.
python-1.0.0 May 21, 2024 · issue -378

Semantic Kernel Python SDK hits 1.0.0 with Azure Cosmos DB for NoSQL memory connector and JSON schema handling.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.0.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.0.0
```
- ›Adds a memory connector for Azure Cosmos DB for NoSQL, enabling vector/memory storage backed by Cosmos DB.
- ›Adds JSON schema handling for OpenAPI and Memory Connectors, with both tagged as experimental.
dotnet-1.13.0 May 20, 2024 · issue -378

Semantic Kernel 1.13.0 adds Azure Cosmos DB NoSQL and Azure SQL/SQL Server vector memory connectors, logprobs support, and streaming tool call diagnostics.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.13.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.13.0
```
- ›Adds logprobs property to OpenAIPromptExecutionSettings for retrieving log-probability output from OpenAI models.
- ›New memory connector for Azure Cosmos DB for NoSQL (#6148).
- ›New memory store implementation using Azure SQL / SQL Server with vector search support.
- ›Enables CreateFromType / CreateFromObject to work with closed generic types.
- ›Includes streaming tool call information in model diagnostics.
+4 moreshow less
- ›Traces ChatHistory and PromptExecutionSettings in IChatCompletionServices for observability.
- ›Includes request info in HttpOperationException for richer error context.
- ›Adds MistralAI to the Application Insights sample.
- ›New summarization and translation evaluation examples using Filters.
python-1.0.0rc1 May 17, 2024 · issue -378

Semantic Kernel Python 1.0.0rc1 introduces pre- and post-function filters for hooking into function execution.
└──▷ GET THIS VERSION
```
$ git clone --branch python-1.0.0rc1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.0.0rc1
```
- ›Adds a filters system that lets developers hook into pre- and post-function execution to inject logging, validation, authentication, or other custom behaviors around kernel function calls.
dotnet-1.12.0 May 16, 2024 · issue -378

Semantic Kernel .NET 1.12.0 adds MistralAI connector, OTel model diagnostics for streaming, and MistralClient activity tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.12.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.12.0
```
└──▷ USE IT
Expose an internal helper method as a kernel function without making it public.
csharp
```
public class MyPlugin
{
    [KernelFunction]
    internal string GetSecret(string key) => _vault.Get(key);
}
```
- ›Adds AllowDangerouslySetContent (renamed surface) for controlling content safety boundaries in kernel operations.
- ›Adds OTel model diagnostics support for streaming APIs, extending observability to streaming call paths.
- ›Adds model diagnostics to non-streaming APIs for OpenTelemetry-based tracing of LLM calls.
- ›Adds MistralAI connector, enabling Semantic Kernel to target MistralAI models as a first-class backend.
- ›Adds OpenTelemetry activities to MistralClient for distributed tracing of Mistral calls.
+4 moreshow less
- ›Increases auto-invoke and in-flight tool calling hard-coded limits, unlocking higher-parallelism agentic workloads.
- ›Allows [KernelFunction] attribute on non-public methods, broadening which methods can be exposed as kernel functions.
- ›Graduates previously experimental features to stable APIs.
- ›Adds multitargeting to .NET libraries, supporting multiple .NET target frameworks in a single package.
└──▷ BREAKING ON UPGRADE
- !The content-safety flag is renamed to AllowDangerouslySetContent; any code referencing the prior name will break on upgrade.
python-0.9.9b1 May 16, 2024 · issue -378

Semantic Kernel Python 0.9.9b1 adds Pydantic Settings for secrets, a new kernel function decorator, and enhanced OpenAPI plugin parameter handling.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.9b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.9b1
```
- ›Introduces Pydantic Settings support for managing secrets, keys, and configurations — reads environment variables or falls back to a .env file path; key, deployment_name, endpoint, and api_version remain available as optional parameters on Text, Chat, and Embedding classes.
- ›Adds a new @kernel_function decorator for defining kernel functions, including lambda function support.
- ›Adds @experimental class and function decorator to mark APIs as experimental.
- ›Adds function_name and plugin_name properties to function call and function call result objects.
- ›Allows the OpenAPI runner to accept a custom HTTP client.
+1 moreshow less
- ›Enhances OpenAPI plugin to correctly form per-operation parameters, ensuring required parameters are sent during automatic function calling.
└──▷ BREAKING ON UPGRADE
- !The complete method has been renamed to get_ (exact new name not fully specified in release notes — verify before upgrading any code calling complete).
dotnet-1.11.1 May 10, 2024 · issue -378

Semantic Kernel 1.11.1 adds a Sessions Code Interpreter Core Plugin and a dimensions property on the OpenAI embedding service constructor.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.11.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.11.1
```
└──▷ USE IT
Specify a custom embedding dimension when constructing the OpenAI embedding service, useful when targeting models that support multiple output sizes (e.g. text-embedding-3-small at 256 dims).
csharp
```
var embeddingService = new OpenAITextEmbeddingGenerationService(
    modelId: "text-embedding-3-small",
    apiKey: "<your-api-key>",
    dimensions: 256
);
```
- ›Adds dimensions property to the OpenAI embedding service constructor, allowing callers to specify embedding vector size at instantiation.
- ›Adds a Sessions (Code Interpreter) Core Plugin and accompanying demo project for executing code in sandboxed Azure Container Apps sessions.
- ›Improves the Azure Cosmos DB for MongoDB connector with additional capability enhancements.
python-0.9.8b1 May 9, 2024 · issue -378

Semantic Kernel Python adds FunctionCallBehavior API, ACA Code Interpreter plugin, and retires three legacy planners.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.8b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.8b1
```
└──▷ USE IT
Restrict auto-invoked function calls to exclude a specific plugin, replacing manual tool_choice/tools wiring.
python
```
from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior

filter = {"excluded_plugins": ["ChatBot"]}
req_settings.function_call_behavior = FunctionCallBehavior.EnableFunctions(auto_invoke=True, filters=filter)
```
Enable fully automatic kernel function invocation with a single call, no manual tool configuration needed.
python
```
from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior

req_settings.function_call_behavior = FunctionCallBehavior.AutoInvokeKernelFunctions()
```
- ›Adds FunctionCallBehavior class to semantic_kernel.connectors.ai.function_call_behavior with methods FunctionCallBehavior.EnableFunctions(auto_invoke=True, filters=filter) and FunctionCallBehavior.AutoInvokeKernelFunctions(), settable via req_settings.function_call_behavior, replacing the need to manually specify tool_choice and tools in prompt execution settings.
- ›Adds filters parameter to FunctionCallBehavior.EnableFunctions() supporting dict keys such as excluded_plugins to control which plugins are exposed to the model.
- ›Adds the ACA Python Sessions (Code Interpreter) Core Plugin, enabling sandboxed remote code execution via Azure Container Apps sessions.
└──▷ BREAKING ON UPGRADE
- !The Basic, Action, and Stepwise planners have been removed; only the Sequential and Function Calling Stepwise planners remain available.
dotnet-1.11.0 May 8, 2024 · issue -378

Semantic Kernel .NET 1.11.0 adds Prompty support, request/response metadata on REST calls, dimensions control for OpenAI embeddings, and a netstandard2.0 ONNX connector.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.11.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.11.0
```
└──▷ USE IT
Control the output embedding dimensionality when registering an OpenAI embedding service, to match a vector store's required size.
csharp
```
builder.AddOpenAITextEmbeddingGeneration(
    modelId: "text-embedding-3-small",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY"),
    dimensions: 512);
```
- ›Adds RequestUri and Payload properties to RestApiOperationResponse, exposing the outbound request URI and body for inspection after REST API plugin calls.
- ›Adds dimensions property to OpenAI embedding generation services, allowing callers to control output embedding size.
- ›Adds netstandard2.0 build target to Microsoft.SemanticKernel.Connectors.Onnx, enabling use in .NET Standard 2.0 projects.
- ›Merges Prompty feature branch to main, adding native support for the Prompty format in Semantic Kernel.
- ›Adds agent logging (Agent Logging) for structured observability of agent execution.
+6 moreshow less
- ›Adds agent aggregator / complex chat pattern, enabling multi-agent orchestration scenarios.
- ›Adds RegexTerminationStrategy tweaks, improving agent conversation termination control.
- ›Adds example of semantic caching with Filters, demonstrating how to layer caching via the filter pipeline.
- ›Adds example of retry logic using Filters, demonstrating fault-tolerance patterns via the filter pipeline.
- ›Adds function invocation approval demo app, illustrating human-in-the-loop gating of kernel function calls.
- ›Adds Azure AI Content Safety and Prompt Shields demo application, showcasing content moderation integration.
python-0.9.7b1 May 6, 2024 · issue -378

Semantic Kernel Python adds FunctionCallContent/FunctionResultContent types, embedding dimensions support, and drops Python <3.10
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.7b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.7b1
```
- ›Introduces FunctionCallContent and FunctionResultContent content types for structured function-calling support inside ChatMessageContent, replacing flat message representations.
- ›Extends ChatMessageContent to hold one or more content items simultaneously, enabling mixed TextContent and function-call content in a single message.
- ›Refactors OpenAI classes to parse and emit FunctionCallContent and related new content types directly, removing the now-redundant OpenAIChatMessageContent and AzureChatMessageContent classes.
- ›Adds caller identity as a user-agent header on HTTP requests to Astra DB's Data API.
- ›Reorganizes samples into samples/getting_started (notebooks), samples/concepts (kernel syntax examples by topic), and a new root-level prompt_template_samples folder.
└──▷ BREAKING ON UPGRADE
- !ChatRole is renamed to AuthorRole — any code referencing ChatRole will break.
- !OpenAIChatMessageContent and AzureChatMessageContent are removed — code importing or instantiating these classes will break.
- !Support for Python 3.8 and 3.9 is dropped; the minimum required version is now Python 3.10.
- !import_plugin_from_object is replaced by add_plugin — existing calls to import_plugin_from_object will break.
dotnet-1.10.0 Apr 29, 2024 · issue -379

Semantic Kernel .NET 1.10.0 adds KernelFunction agent strategies, a new Filter API, and Azure Cosmos DB Mongo vCore memory integration.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.10.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.10.0
```
└──▷ USE IT
Use a KernelFunction to drive agent selection in a multi-agent chat, replacing hard-coded round-robin logic.
csharp
```
var strategy = new KernelFunctionSelectionStrategy(selectionFunction, kernel);
var chat = new AgentGroupChat(agentA, agentB)
{
    ExecutionSettings = new AgentGroupChatSettings
    {
        SelectionStrategy = strategy
    }
};
```
- ›Adds new Filter API (d0de9a01) replacing deprecated filter context classes, enabling cleaner pipeline interception.
- ›Adds KernelFunctionSelectionStrategy and KernelFunctionTerminationStrategy for agent orchestration, letting agents use KernelFunction-based logic to select speakers and determine termination conditions.
- ›Integrates Azure Cosmos DB Mongo vCore as a memory store, expanding vector/semantic memory backend options.
- ›Enhances the legacy agents package with improved function-calling argument handling.
dotnet-1.9.0 Apr 24, 2024 · issue -379

Semantic Kernel .NET 1.9.0 adds OpenAI Assistant Agent support, XML tag chat prompts, and Google connector API version selection.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.9.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.9.0
```
- ›Adds Google connector API version selection, enabling callers to target a specific Google API version from the connector configuration.
- ›Introduces the OpenAI Assistant Agent, adding a new agent type backed by the OpenAI Assistants API.
- ›Supports XML tags in chat prompts, allowing prompt templates to use XML-style tag syntax alongside existing formats.
dotnet-1.8.0 Apr 22, 2024 · issue -379

Semantic Kernel 1.8.0 adds AgentGroupChat, function call content types, HuggingFace TGI chat, and custom OpenAI-compatible endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.8.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.8.0
```
- ›Introduces AgentGroupChat to the Agent Framework, enabling multi-agent group chat orchestration.
- ›Adds function call content model classes (FunctionCallContent and related types) for structured handling of LLM function call payloads.
- ›Makes OpenAPI operation metadata and extension metadata available at function invocation time.
- ›Supports custom OpenAI-compatible chat message API endpoints via the OpenAI connector.
- ›Adds HuggingFace TGI (Text Generation Inference) Chat Completion Message API support.
+1 moreshow less
- ›Uses payload parameter during OpenAPI import when explicitly specified.
└──▷ BREAKING ON UPGRADE
- !Pre-V1 planners in Planners.Core source have been deleted.
- !Projects upgraded from net6.0 to net8.0; language version set to 12 — libraries targeting net6 will no longer be supported.
python-0.9.6b1 Apr 16, 2024 · issue -379

Semantic Kernel python-0.9.6b1 redesigns plugin/function registration with new kernel methods and modular import paths.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.6b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.6b1
```
└──▷ USE IT
Register a custom plugin class whose methods are decorated with @kernel_function, replacing the old plugin-addition pattern.
python
```
from semantic_kernel import Kernel
from semantic_kernel.functions import kernel_function

class MyPlugin:
    @kernel_function(name="greet", description="Greet a user")
    def greet(self, name: str) -> str:
        return f"Hello, {name}!"

kernel = Kernel()
kernel.add_plugin(MyPlugin(), plugin_name="MyPlugin")
```
- ›Adds kernel.add_plugin() and kernel.add_plugins() for registering plugins directly as a KernelPlugin instance, as a custom class with @kernel_function-decorated methods, or as a decorated dictionary.
- ›Adds kernel.add_function() and kernel.add_functions() for registering individual functions with the kernel.
- ›Adds kernel.add_plugin_from_openapi() to load an OpenAPI plugin into the kernel.
- ›Adds kernel.add_plugin_from_openai() to load an OpenAI plugin into the kernel.
- ›Restructures imports for faster load performance: only the Kernel is exposed at the root; all other components live in sub-packages (e.g., semantic_kernel.functions), with OpenAI and Azure OpenAI accessed via from semantic_kernel.connectors.ai.open_ai import ....
+2 moreshow less
- ›Updates Azure OpenAI On Your Data (AOAI OYD) connector to the 2024-02-15-preview API version.
- ›Allows the @kernel_function decorator to be used without brackets.
└──▷ BREAKING ON UPGRADE
- !Import paths for most SK components have moved to sub-packages; code importing directly from the root semantic_kernel namespace (other than Kernel) will break and must be updated to use full sub-package paths such as from semantic_kernel.functions import ... or from semantic_kernel.connectors.ai.open_ai import ....
dotnet-1.7.1 Apr 5, 2024 · issue -379

Semantic Kernel 1.7.1 adds optional chat history resumption in the stepwise planner and custom Bing Search endpoint support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.7.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.7.1
```
- ›Adds optional chatHistory parameter to the stepwise planner, enabling execution to be resumed mid-flight from a prior conversation state.
- ›Supports custom Bing Search endpoints alongside improved response formatting for Bing Search results.
dotnet-1.7.0 Apr 3, 2024 · issue -379

Semantic Kernel 1.7.0 adds Gemini connector, BERT ONNX embeddings, OpenAI TokenCredentials, Azure file-service endpoint, and CJK text-splitter support.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.7.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.7.0
```
└──▷ USE IT
Load a plugin that depends on multiple APIs using the new ApiManifestPluginParameters.
csharp
```
var plugin = await kernel.ImportPluginFromApiManifestAsync(
    pluginName: "MyMultiApiPlugin",
    filePath: "./plugins/myPlugin/apimanifest.json",
    new ApiManifestPluginParameters());
```
- ›Introduces ApiManifestPluginParameters to support multiple API dependencies when loading API Manifest plugins.
- ›Adds Name property to ChatMessageContent for identifying message authors in multi-agent chat scenarios.
- ›Publishes Microsoft.SemanticKernel.Plugins.OpenApi.Extensions as a standalone NuGet package for OpenAPI plugin extensibility.
- ›Adds BERT ONNX embedding generation service, enabling local on-device embedding without a cloud API.
- ›Adds experimental Gemini connector, bringing Google Gemini models into the SK connector ecosystem.
+9 moreshow less
- ›Adds OpenAI TokenCredentials support, enabling Azure AD / Entra ID token-based authentication for OpenAI services.
- ›Adds Azure Endpoint support for the File Service, allowing file operations against Azure OpenAI file APIs.
- ›Adds CJK (Chinese, Japanese, Korean) support to the text splitter for accurate chunking of CJK content.
- ›Exposes a specialized SSE (Server-Sent Events) parser and a streaming JSON parser as reusable utilities for connector authors.
- ›Updates Milvus memory connector to API version 2.3.
- ›Improves text splitter performance by reducing tokenizer calls during chunking.
- ›Upgrades Azure OpenAI completion API version to 2024-02-01.
- ›Disables Azure SDK network timeout when a custom HttpClient is supplied, preventing premature stream termination on long-running completions.
- ›Adds missing OpenAI connector Choice properties to response metadata, surfacing finish reason and other choice-level fields.
└──▷ BREAKING ON UPGRADE
- !The default chat system prompt has been removed; callers that relied on the built-in default must now supply their own system prompt explicitly.
- !ToolCallResultSerializerOptions is marked obsolete and will be removed in a future release; update code that references it.
python-0.9.5b1 Apr 1, 2024 · issue -379

Semantic Kernel Python 0.9.5b1 adds OpenAI/OpenAPI plugin operations with auth, AzureOpenAI stepwise planner support, and enhanced chat message content handling.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.5b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.5b1
```
- ›Enables the function calling stepwise planner to use AzureOpenAI chat service as a backend.
- ›Introduces operations to handle OpenAI plugins, improves OpenAPI plugin support, and allows authentication for plugin calls.
- ›Adds a messages custom function helper for Handlebars templates, and removes Jinja2 built-in helpers from the custom helpers namespace.
- ›Honors configured function calling options when executing kernel functions.
- ›Enhances ChatMessageContent creation and parsing with richer structured support.
python-0.9.4b1 Mar 20, 2024 · issue -380

Semantic Kernel Python 0.9.4b1 adds YAML prompt template support and prepends 'Semantic-Kernel' to User-Agent headers.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.4b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.4b1
```
- ›Prepends Semantic-Kernel and a version key-value pair to outgoing HTTP User-Agent headers, enabling easier traffic attribution and API gateway filtering.
- ›Adds support for YAML prompt templates, allowing prompt definitions to be authored and loaded in YAML format.
- ›Rebuilds XML creation and parsing internals, improving structured data handling for prompt and function metadata.
dotnet-1.6.3 Mar 19, 2024 · issue -380

Semantic Kernel 1.6.3 exposes Agent Thread Messages and clones KernelFunctions on plugin insertion.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.6.3 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.6.3
```
- ›Exposes Agent Thread Messages, allowing callers to retrieve messages from an agent thread directly.
- ›Creates a clone of KernelFunction when it is added to a KernelPlugin, preventing unintended shared-state mutations across plugin registrations.
- ›Adds a HuggingFace image-to-text Windows Forms sample demonstrating the image-to-text capability.
- ›Uses stateful tokenizer/encoding instances across token-count examples for consistent tokenization behavior.
python-0.9.3b1 Mar 15, 2024 · issue -380

Semantic Kernel Python gains Handlebars and Jinja2 prompt templating with loops, variables, and static function execution.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.3b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.3b1
```
- ›Adds Handlebars prompt template support, enabling loops, variables, and static function execution in prompts — matching the existing dotnet Handlebars implementation for cross-language compatibility.
- ›Adds Jinja2 prompt template support, enabling loops, variables, and static function execution in Python-native prompt workflows.
python-0.9.2b1 Mar 13, 2024 · issue -380

Semantic Kernel Python gains the Function Calling Stepwise Planner for agentic, tool-driven reasoning loops.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.2b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.2b1
```
- ›Introduces FunctionCallingStepwisePlanner to the Python SDK, enabling LLM-driven stepwise planning via function/tool calling.
dotnet-1.6.1 Mar 12, 2024 · issue -380

Semantic Kernel .NET 1.6.1 adds Agent file-ID reference handling and respects live Kernel plugin changes during auto-invocation.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.6.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.6.1
```
- ›Adds File ID Reference Handling to the experimental Agent package, allowing user messages to be associated with file IDs in OpenAI Storage.
- ›Kernel plugin changes made during function auto-invocation are now respected at runtime, enabling dynamic plugin registration mid-call.
- ›Marks the Experimental.Orchestration.Flow package as alpha status.
- ›Adds a home automation example demonstrating dependency injection (DI) patterns in a real application.
python-0.9.1b1 Mar 8, 2024 · issue -380

Semantic Kernel Python 0.9.1b1 adds auto tool calling for OpenAI/AzureOpenAI with configurable invocation limits.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.1b1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.1b1
```
└──▷ USE IT
Let the kernel automatically invoke registered tools during a chat completion call, up to a bounded number of attempts.
python
```
from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    auto_invoke_kernel_functions=True,
    max_auto_invoke_attempts=5
)
result = await kernel.invoke_prompt(prompt, settings=settings)
```
- ›Adds auto tool calling for AzureOpenAI/OpenAI models, enabled via auto_invoke_kernel_functions=True and max_auto_invoke_attempts=<max_attempts_int> in PromptExecutionSettings; disabled by default.
- ›Adds function_name and plugin_name parameters to invoke_prompt for more precise prompt-level kernel function targeting.
python-0.9.0.beta1 Mar 5, 2024 · issue -380

Semantic Kernel Python hits 0.9.0 beta with reworked Kernel Arguments, Function Result, prompt templating, and complex type support for method functions.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.9.0.beta1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.9.0.beta1
```
- ›Splits KernelFunction into KernelFunctionFromPrompt and KernelFunctionFromMethod classes for cleaner separation of prompt-based and code-based function definitions.
- ›Adds complex type support for method functions, enabling richer input/output signatures beyond primitive types.
- ›Introduces major rework of Kernel Arguments, Function Result, and prompt templating engine.
- ›Removes memory tied directly to the Kernel object, decoupling memory management from the core kernel.
- ›Rebuilds the exceptions structure into a more Pythonic hierarchy.
+1 moreshow less
- ›Replaces xml parsing with defusedxml to harden XML handling.
└──▷ BREAKING ON UPGRADE
- !Memory is no longer tied to the Kernel object — code that accessed memory through the kernel will break and must be updated.
- !KernelFunction is split into KernelFunctionFromPrompt and KernelFunctionFromMethod — any code importing or instantiating KernelFunction directly will need to migrate to the appropriate subclass.
- !The exceptions structure has been rebuilt — any code catching specific Semantic Kernel exception types by name will need to be updated to the new Pythonic hierarchy.
- !Methods previously suffixed with _async have had that suffix removed — any callers using the old _async method names will break.
dotnet-1.5.0 Feb 27, 2024 · issue -381

Semantic Kernel 1.5.0 adds ImageToText abstraction, HuggingFace connector updates, Agent image support, and new audio/content APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.5.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.5.0
```
- ›Adds Source property to the ChatMessageContent class for tracking message origin.
- ›Adds ContentFilterResults to text and message content metadata, surfacing Azure OpenAI content filter outcomes.
- ›Adds Semantic-Kernel-Version header to all outgoing HTTP requests for request attribution and diagnostics.
- ›Adds HandlebarsPlanCreationException for structured error handling in the Handlebars planner.
- ›Adds BinaryData support for ImageContent, enabling binary image payloads without a URI.
+9 moreshow less
- ›New ImageToText abstraction with HuggingFace connector support, enabling image-to-text inference through the HuggingFace HTTP client.
- ›Adds image support for Agent responses, allowing agents to return image content.
- ›Updates audio abstractions to return multiple values from a single call.
- ›Moves AudioContent class to the Microsoft.SemanticKernel namespace for consistency with other content types.
- ›Adds #each block support details and named function-parameter literal handling to the Handlebars planner template engine.
- ›Adds Create Plan prompt override capability to the Handlebars planner.
- ›Adds API Manifest plugin support with additional Microsoft Graph examples and configurable schema/search fields via Azure AI Search plugin.
- ›Improves ChatMessageContent serialization-friendliness for more reliable JSON round-trips.
- ›Improves Audio API with default setting values for easier configuration.
dotnet-1.4.0 Feb 14, 2024 · issue -381

Semantic Kernel 1.4.0 adds audio I/O abstractions, OpenAI File Service, Azure OpenAI Assistants API, and configurable Handlebars Planner prompts.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.4.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.4.0
```
- ›Exposes KernelFunction.ExecutionSettings to IAIServiceSelector, enabling service selectors to inspect per-function execution settings at dispatch time.
- ›Adds Audio-to-Text abstraction and OpenAI implementation for transcribing audio input.
- ›Adds Text-to-Audio abstraction and OpenAI implementation for synthesizing spoken audio from text.
- ›Adds OpenAI File Service support (OpenAI File Service) for uploading and managing files via the OpenAI Files API.
- ›Adds support for the Azure OpenAI Assistants API, enabling Assistants-based workflows in .NET.
+1 moreshow less
- ›Makes the Handlebars Planner prompt configurable, allowing customization of the planning prompt template.
dotnet-1.3.1 Feb 12, 2024 · issue -381

Semantic Kernel 1.3.1 adds a Chat Completion Agent, SK Agents framework, work/school account support for Microsoft Graph, and a new OpenApi Extensions project.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.3.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.3.1
```
- ›Adds Functions.OpenApi.Extensions project, extending OpenAPI function support for Semantic Kernel.
- ›Adds ChatCompletionAgent, enabling chat-completion models to be used as first-class agents in .NET.
- ›Adds SK Agents framework, providing a structured foundation for building and composing agents.
- ›Supports work and school accounts in the Microsoft Graph Connector, broadening organizational identity coverage.
- ›Adds PodType.Nano enum value to the Pinecone Connector, enabling use of Pinecone Nano pod types.
+3 moreshow less
- ›Adds implicit JSON-to-target-type conversion for kernel function return values.
- ›Improves planner options with multiple configurability enhancements.
- ›Formats agent output for AskAsync when an agent is used as a plug-in.
python-0.5.1.dev Feb 9, 2024 · issue -381

Semantic Kernel Python 0.5.1.dev adds CMK support for index creation and Pydantic models for Kernel and KernelFunction.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.5.1.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.5.1.dev
```
- ›Adds Customer Managed Key (CMK) support to the create Index operation in the Python library.
- ›Converts the Kernel class to a Pydantic model, enabling Pydantic-native validation and serialization of the core kernel object.
- ›Sets default plugins on semantic functions.
python-0.5.0.dev Feb 1, 2024 · issue -381

Semantic Kernel Python 0.5.0.dev unifies completion responses under KernelContent, adds Astra memory, and overhauls plugin architecture
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.5.0.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.5.0.dev
```
- ›Introduces KernelContent base class that unifies response objects for Chat, Text, and Embedding completions, providing consistent access to response metadata and inner content.
- ›Adds KernelPluginCollection class to replace PluginCollection and ReadOnlyPluginCollection, overhauling the plugin and function architecture.
- ›Renames AIRequestSettings to PromptExecutionSettings to align Python SDK terminology with the .NET implementation.
- ›Adds Astra memory store integration as a new memory backend option.
- ›Drops synchronous function execution — all function invocation is now async-only.
└──▷ BREAKING ON UPGRADE
- !AIRequestSettings is renamed to PromptExecutionSettings; any code referencing AIRequestSettings will break.
- !PluginCollection and ReadOnlyPluginCollection are removed and replaced by KernelPluginCollection; code using the old classes will break.
- !Synchronous function execution is removed; any code relying on sync invocation must be migrated to async.
dotnet-1.2.0 Jan 24, 2024 · issue -382

Semantic Kernel 1.2.0 adds Function and Prompt Filters, extended FunctionResult, and OpenAPI payload default values.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.2.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.2.0
```
- ›Introduces Function and Prompt Filters as the new interception model, replacing the now-deprecated Kernel events (SKEXP0003/SKEXP0004).
- ›Adds FunctionResultExtended to expose richer metadata from kernel function invocations.
- ›Supports DefaultValue for OpenAPI payload properties, improving plugin reliability when callers omit optional fields.
- ›Updates FlowOrchestrator to use YAML plugins for defining orchestration steps.
- ›Adds an example demonstrating how to use the OpenAI response_format property for structured outputs.
+1 moreshow less
- ›Extends chat message parsing to handle a broader range of message shapes.
└──▷ BREAKING ON UPGRADE
- !Kernel events are marked deprecated in favor of Filters; CancelKernelEventArgs is now attributed SKEXP0003 (was SKEXP0004), which may affect experimental-feature suppressions.
- !The NCalc Plugin has been removed from the plugin library.
- !Polly has been removed as a dependency, so any code relying on Polly being transitively available through Semantic Kernel will need to add it directly.
python-0.4.6.dev Jan 23, 2024 · issue -382

Semantic Kernel Python renames Skills to Plugins and completion settings to execution_settings for .NET alignment
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.4.6.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.4.6.dev
```
- ›Renames all Skills references to Plugins across class names, variable names, filenames, and directory names to align with SK .NET conventions.
- ›Renames completion settings to execution_settings in PromptTemplateConfig and AIRequestSettings to match SK .NET behavior.
└──▷ BREAKING ON UPGRADE
- !All Skills-named classes, variables, filenames, and directories are renamed to Plugins — any code referencing the old Skills names will break on upgrade.
- !The completion settings key in PromptTemplateConfig and AIRequestSettings is renamed to execution_settings — existing configurations using completion will break on upgrade.
dotnet-1.1.0 Jan 16, 2024 · issue -382

Semantic Kernel 1.1.0 adds agent tool support, instruction templating, DI-resolved OpenAI clients, and a new ResponseFormat setting.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.1.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.1.0
```
└──▷ USE IT
Force the OpenAI completion to return a JSON object by setting ResponseFormat on execution settings.
csharp
```
var settings = new OpenAIPromptExecutionSettings
{
    ResponseFormat = "json_object"
};
var result = await kernel.InvokePromptAsync(prompt, new(settings));
```
Resolve a pre-configured OpenAIClient from the DI container instead of passing credentials explicitly.
csharp
```
builder.Services.AddSingleton<OpenAIClient>(sp => new OpenAIClient(new Uri(endpoint), new AzureKeyCredential(apiKey)));
builder.Services.AddAzureOpenAIChatCompletion(deploymentName: "gpt-4");
```
- ›Adds OpenAIPromptExecutionSettings.ResponseFormat property to control the response format returned by OpenAI completions.
- ›Adds support for agent tools code-interpreter and retrieval on OpenAI Assistants-based agents.
- ›Adds support for instruction templating on Agents, enabling dynamic prompt construction at the agent level.
- ›Adds previous plan and error context to Handlebars planner retry logic, improving iterative planning recovery.
- ›Restores FlowOrchestrator support for multi-step flow orchestration workflows.
+1 moreshow less
- ›Function Calling Planner now catches exceptions and outputs error messages into chat history for observability.
python-0.4.5.dev Jan 11, 2024 · issue -382

Semantic Kernel Python 0.4.5.dev adds an Ollama connector and debug logging for StepwisePlanner.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.4.5.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.4.5.dev
```
- ›Adds Ollama connector, enabling local LLM inference via Ollama as a new backend for Python SK applications.
- ›Adds debug logging for StepwisePlanner's next-step thought, making planner reasoning observable at runtime.
python-0.4.4.dev Jan 5, 2024 · issue -382

Semantic Kernel for Python gains AIRequestSettings with three configuration methods for AI service request management.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.4.4.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.4.4.dev
```
- ›Adds AIRequestSettings base class for storing settings across multiple services via a single extension_data field, with dynamic creation of service-specific request setting classes at call time.
- ›Adds service-specific request settings classes (e.g., AzureOpenAIChatRequestSettings) for type-checked, single-service configuration.
- ›Adds kernel-based request settings generation that returns a pre-configured class with service_id and ai_model_id pre-filled based on the registered service.
- ›Adds richer exceptions when Azure OpenAI content filtering is triggered, surfacing filtering events as structured errors.
dotnet-1.0.1 Dec 18, 2023 · issue -383

Semantic Kernel dotnet-1.0.1 adds complex-type support for Handlebars/OpenAPI plugins, streaming passthrough for KernelFunctionFromMethod, and metadata propagation to StreamingMethodContent.
└──▷ GET THIS VERSION
```
$ git clone --branch dotnet-1.0.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.0.1
```
- ›Adds CancellationToken parameters to several Kernel methods, enabling cooperative cancellation across async Kernel operations.
- ›Changes InputVariable.Default type from string to object?, allowing non-string default values for prompt input variables.
- ›Enables KernelFunctionFromMethod streaming passthrough so native .NET functions can participate in streaming response pipelines.
- ›Propagates metadata to StreamingMethodContent, making per-chunk metadata available in streaming workflows.
- ›Adds complex-type support for OpenAPI plugins in the Handlebars template engine, allowing structured objects as plugin inputs/outputs.
+7 moreshow less
- ›Decouples the Handlebars PromptTemplates project from the Connectors.OpenAI dependency, reducing coupling between template rendering and AI connectors.
- ›Overhauls JSON Schema handling across the library for more consistent schema generation and consumption.
- ›Updates Azure AI Search connector to support the latest GA package.
- ›Logs complex objects as JSON for richer structured diagnostics output.
- ›Adds generic Prompt API helpers to simplify prompt construction.
- ›Updates OpenAI connector to use FunctionToolCallsProperty for serializing and deserializing ChatHistory with tool-calling details.
- ›Updates to Azure.AI.OpenAI beta 12 connector, tracking the latest Azure OpenAI SDK.
└──▷ BREAKING ON UPGRADE
- !InputVariable.Default type is changed from string to object?; code that assigns or reads this property as string without a cast may fail to compile or behave unexpectedly after upgrade.
python-0.4.2.dev Dec 12, 2023 · issue -383

Semantic Kernel Python adds an Azure OpenAI on Your Data connector backed by Azure AI Search.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.4.2.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.4.2.dev
```
- ›Adds a Python connector for Azure OpenAI on Your Data, allowing an Azure AI Search index to be configured as a data source so the model answers queries with index-retrieved content, including vector search retrieval modes.
python-0.4.1.dev Dec 5, 2023 · issue -383

Semantic Kernel Python 0.4.1.dev upgrades to Pydantic v2.5.2 and adds custom AzureOpenAI/OpenAI client support with configurable default headers.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.4.1.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.4.1.dev
```
- ›Allows default_headers configuration and passing custom AzureOpenAI/OpenAI client instances directly into the kernel.
- ›Upgrades to Pydantic v2.5.2, consolidating skbasemodel, skgeneric, and pydantic field classes into a unified skbasemodel, and replacing the dict function with model_dump and model_dump_json.
- ›Adds a grounding sample as a standalone Python script (in addition to the existing notebook).
└──▷ BREAKING ON UPGRADE
- !The Pydantic dict function is replaced by model_dump and model_dump_json; any code calling .dict() on SK Pydantic models will break.
- !Previously distinct classes skbasemodel, skgeneric, and pydantic field are consolidated into skbasemodel; aliases from earlier versions will be deprecated in the future v1 release.
python-0.4.0.dev Nov 29, 2023 · issue -384

Semantic Kernel Python 0.4.0.dev upgrades to OpenAI SDK 1.0+ and restructures AI service class hierarchies.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.4.0.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.4.0.dev
```
- ›Upgrades OpenAI SDK compatibility to version 1.0 or higher, enabling access to new models and APIs available in that SDK generation.
- ›AzureTextCompletion now extends AzureOpenAIConfigBase and OpenAITextCompletionBase, and OpenAIChatCompletion is refactored to extend OpenAIConfigBase, OpenAIChatCompletionBase, and OpenAITextCompletionBase, providing a more explicit class hierarchy for Azure and OpenAI service integrations.
└──▷ BREAKING ON UPGRADE
- !OpenAI SDK dependency is upgraded to version 1.0 or higher; code using the pre-1.0 SDK will break without upgrading.
- !AzureTextCompletion now extends AzureOpenAIConfigBase and OpenAITextCompletionBase instead of its previous base classes — class definitions that rely on the old hierarchy must be updated.
- !OpenAIChatCompletion is refactored from ChatCompletionClientBase and TextCompletionClientBase to OpenAIConfigBase, OpenAIChatCompletionBase, and OpenAITextCompletionBase — existing subclasses and constructor calls may need to be updated to use keyword arguments.
python-0.3.15.dev Nov 19, 2023 · issue -384

Semantic Kernel Python adds Azure CosmosDB Mongo vCore memory store, pre/post RunAsync handlers, and OpenAI user-agent headers.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.3.15.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.3.15.dev
```
- ›Adds Azure CosmosDB Mongo vCore as a vector memory datastore, expanding the set of supported backends for semantic memory.
- ›Syncs pre/post RunAsync event handlers from C# to Python, enabling hook-based pipeline instrumentation around kernel function execution.
- ›Adds a user-agent header to all OpenAI and OpenAPI HTTP requests, improving traceability of Semantic Kernel traffic at the API gateway level.
python-0.3.14.dev Oct 23, 2023 · issue -385

Semantic Kernel Python adds function calling for chat, MongoDB Atlas vector search, token usage tracking, and dict-like context variables.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.3.14.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.3.14.dev
```
- ›Implements function calling for chat completion via the new semantic_kernel chat pipeline (#2356).
- ›Adds MongoDB Atlas Vector Search as a new memory/vector store connector.
- ›Makes ContextVariables behave like a Python dict, enabling standard dict operations on kernel context.
- ›Adds simple token usage tracking to AI completion calls.
- ›Makes semantic_kernel.NullLogger match logging.Logger function signatures for drop-in compatibility.
+2 moreshow less
- ›Enforces return type hints on native functions for stronger typing.
- ›Improves AI service usability for text and chat completion.
java-0.2.9-alpha Sep 26, 2023 · issue -386

Semantic Kernel Java adds stepwise planner, JDBC/Postgres memory connectors, and Azure Cognitive Search memory store.
└──▷ GET THIS VERSION
```
$ git clone --branch java-0.2.9-alpha https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout java-0.2.9-alpha
```
- ›Adds JDBC and Postgres memory connectors for persistent vector storage in Java.
- ›Adds stepwise planner to the Java SDK, enabling multi-step autonomous task execution.
- ›Implements MemoryStore interface on AzureCognitiveSearchMemory in Java, making it a first-class memory backend.
- ›Changes minRelevanceScore on the memory API from double to float in Java.
└──▷ BREAKING ON UPGRADE
- !Removes the default NullMemory from the DefaultSKContext builder — code that relied on an implicit no-op memory store will now receive no memory instance by default and must supply one explicitly.
python-0.3.11.dev Sep 6, 2023 · issue -386

Semantic Kernel Python gains a Redis memory connector and chat system message support in completion settings.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.3.11.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.3.11.dev
```
- ›Adds Redis memory connector, enabling Redis as a vector/memory backend for Semantic Kernel Python applications.
- ›Adds chat_system_message to completion settings, allowing a system prompt to be set for chat-based LLM calls.
- ›Adds a settings function to load configuration directly into the constructor, streamlining kernel initialization.
python-0.3.10.dev Aug 28, 2023 · issue -387

Semantic Kernel Python 0.3.10.dev adds token bias controls, HF model kwargs, chat template restore, and orchestration serialization.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.3.10.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.3.10.dev
```
└──▷ USE IT
Bias the model toward or away from specific tokens when configuring a prompt template.
python
```
from semantic_kernel.connectors.ai.open_ai import OpenAITextPromptExecutionSettings
from semantic_kernel.prompt_template.prompt_template_config import PromptTemplateConfig

config = PromptTemplateConfig(
    template="Classify the sentiment: {{$input}}",
    token_selection_biases={1234: -100, 5678: 50}
)
```
- ›Adds token_selection_biases field to PromptTemplateConfig, enabling per-token logit bias control when building prompt templates.
- ›Adds HuggingFace model and pipeline kwargs to allow customization of model loading behavior in HF connectors.
- ›Adds restore method to chat_prompt_template for reconstructing chat prompt template state.
- ›Enables serialization support for the sk/orchestration module.
- ›Adds logger parameter (optional) to inheriting classes in the Semantic Kernel Python library.
python-0.3.9.dev Aug 23, 2023 · issue -387

Semantic Kernel Python gains Google PaLM connectors, a stepwise planner, USearch memory, and single-function kernel registration.
└──▷ GET THIS VERSION
```
$ git clone --branch python-0.3.9.dev https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-0.3.9.dev
```
- ›Adds num_records parameter to the text memory skill, allowing callers to control how many memory records are retrieved.
- ›Adds Google PaLM connector supporting text completion, chat completion, and text embedding services.
- ›Adds stepwise planner to the Python SDK.
- ›Adds methods to register a single native function directly to the kernel without wrapping it in a skill/plugin.
- ›Adds USearch memory connector for vector memory storage.
+1 moreshow less
- ›Azure Cognitive Search memory connector now uses HNSW for vector indexing.

Semantic Kernel

Summary

What Semantic Kernel answers

Examples

Command line

Release history