Semantic Kernel

Provides a language-agnostic Kernel abstraction (Microsoft.SemanticKernel.Kernel in .NET, semantic_kernel.Kernel in Python) that orchestrates LLM invocations, plugin registration, and function execution across C#, Python, and Java. The kernel acts as a central coordinator that manages AI service connections, maintains execution context, and routes function calls through a consistent pipeline regardless of underlying language runtime. Implements a decorator-based plugin system where functions are registered as KernelFunction objects with metadata for discovery and invocation.

Implements a provider-agnostic function calling system that translates semantic kernel function definitions into provider-specific schemas (OpenAI JSON schema, Anthropic tool_use format, etc.) and routes tool calls back through a unified handler. Uses a connector abstraction layer (IChatCompletionService, IEmbeddingGenerationService) that abstracts away provider-specific API differences, allowing seamless switching between OpenAI, Azure OpenAI, Anthropic, Ollama, and other LLM providers. Function metadata is extracted via reflection/introspection and automatically converted to the target provider's tool schema format.

Provides patterns and utilities for coordinating multiple agents in a single application, enabling agents to communicate with each other and delegate tasks. The framework supports agent composition where one agent can invoke another agent's capabilities, and agent hierarchies where a coordinator agent manages multiple specialist agents. Communication between agents is mediated through the kernel, allowing agents to share context and results. Supports both sequential agent chains (agent A → agent B → agent C) and parallel agent execution with result aggregation. Agents maintain separate conversation histories but can share semantic memory and function registries.

Provides a configuration system for LLM execution settings that abstracts provider-specific parameters (temperature, max_tokens, top_p, etc.) into a unified PromptExecutionSettings object. Developers can configure settings globally on the kernel or per-function invocation, with automatic translation to provider-specific formats (OpenAI compat, Anthropic, etc.). Supports fallback configurations where if a setting is not supported by a provider, a sensible default is used. Settings can be serialized to JSON for persistence and reloaded at runtime. Enables A/B testing of different model configurations without code changes.

Implements streaming support for LLM responses, allowing applications to receive and process tokens as they are generated rather than waiting for the complete response. The system provides streaming APIs for both chat completion and semantic functions, returning async iterables or streams of token chunks. Streaming is transparent to the developer; the same function invocation API works for both streaming and non-streaming modes. Supports streaming with function calling, where tool calls are streamed and executed incrementally. Enables real-time UI updates and reduced perceived latency in conversational applications.

Implements a custom prompt template language (documented in PROMPT_TEMPLATE_LANGUAGE.md) that uses {{variable}} syntax for dynamic prompt composition, supporting variable substitution, conditional blocks, and function composition. Semantic functions are defined as YAML or inline C#/Python with embedded prompts that are parsed and compiled into executable functions. The system maintains a PromptTemplateEngine that interpolates variables from kernel arguments at execution time, enabling dynamic prompt construction without string concatenation. Supports both simple variable replacement and complex prompt engineering patterns like few-shot examples and chain-of-thought templates.

Provides a memory abstraction layer (ISemanticTextMemory, TextMemoryPlugin) that decouples embedding generation from vector storage, allowing developers to use any embedding model (OpenAI, Azure OpenAI, Hugging Face) with any vector database (Chroma, Weaviate, Pinecone, in-memory). The system implements a two-stage pipeline: (1) text is converted to embeddings via an IEmbeddingGenerationService, and (2) embeddings are stored/retrieved via an IMemoryStore implementation. Supports semantic search by converting queries to embeddings and performing similarity matching, enabling RAG patterns where retrieved context is injected into prompts. Memory operations are exposed as kernel plugins (TextMemoryPlugin) for seamless integration with function calling.

Provides a planning framework (documented in PLANNERS.md) that decomposes complex user goals into executable steps using LLM-based reasoning. The system includes multiple planner implementations: SequentialPlanner (breaks tasks into ordered steps), HandlebarsPlanner (uses Handlebars templates for step generation), and FunctionCallingPlanner (leverages native function calling for step execution). Planners generate a Plan object containing a sequence of steps, each mapping to a kernel function. The Kernel then executes steps sequentially, passing outputs from one step as inputs to the next, enabling multi-step agent workflows. Supports dynamic replanning if steps fail or return unexpected results.

Provides a ChatCompletionAgent abstraction (.NET and Python implementations documented in Agent Framework section) that wraps an LLM in a loop: the agent receives a user message, calls the LLM with available functions, executes returned function calls, and feeds results back to the LLM until a terminal response is generated. The agent maintains conversation history (ChatHistory) and manages function call execution through the kernel. Supports both .NET (ChatCompletionAgent class) and Python (ChatCompletionAgent class) with consistent APIs. Agents can be configured with execution settings (max iterations, timeout, temperature) and support streaming responses for real-time output.

Integrates OpenAPI/Swagger specifications to automatically generate kernel functions from REST API definitions, enabling agents to call external APIs without manual function wrapping. The system parses OpenAPI schemas, extracts endpoint definitions, and generates KernelFunction objects that handle HTTP request construction, parameter validation, and response parsing. Supports both OpenAPI 3.0 and Swagger 2.0 formats. Functions generated from OpenAPI specs are registered in the kernel and can be called by agents or planners just like native functions, enabling seamless integration of external services (e.g., weather APIs, database APIs) into agent workflows.

Implements a filter pipeline architecture (documented in decisions/0033-kernel-filters.md) that allows developers to intercept and modify kernel function execution at multiple points: before function invocation (PreFunctionInvocationFilter), after invocation (PostFunctionInvocationFilter), and on errors (ErrorFilter). Filters are registered globally on the kernel and execute for all function calls, enabling cross-cutting concerns like logging, telemetry, rate limiting, and response modification. The filter system uses a chain-of-responsibility pattern where each filter can modify context, skip execution, or short-circuit the pipeline. Filters have access to function metadata, arguments, and results, enabling sophisticated execution control.

Integrates OpenTelemetry (OTel) for distributed tracing and metrics collection across kernel function execution, LLM API calls, and embedding operations. The system emits spans for each function invocation, LLM request, and embedding generation, with semantic conventions documented in decisions/0044-OTel-semantic-convention.md. Traces include function metadata, token counts, latency, and error information, enabling end-to-end observability of agent execution. Supports exporting traces to any OTel-compatible backend (Jaeger, Datadog, Azure Monitor). Telemetry is automatically collected without requiring explicit instrumentation in user code; developers can configure sampling and export policies.

Provides a Python code execution capability that allows agents to generate and execute Python code dynamically within a sandboxed environment. The system includes a PythonCodeExecutionPlugin that can evaluate Python expressions and statements, returning results to the agent. This enables agents to perform calculations, data transformations, or complex logic without pre-registering functions. Code execution is isolated from the main application using subprocess or restricted execution contexts, preventing malicious code from accessing sensitive resources. Supports passing variables from the kernel context into the execution environment and returning results back to the agent.