Semantic Kernel

Provides a language-agnostic Kernel abstraction (Microsoft.SemanticKernel.Kernel in .NET, semantic_kernel.Kernel in Python) that orchestrates LLM calls, function composition, and plugin execution across C#, Python, and Java with consistent conceptual models. The kernel acts as a central dispatcher that routes semantic functions (LLM-powered operations) and native functions through a unified execution pipeline, handling service selection, argument binding, and result marshaling across language boundaries.

Implements a provider-agnostic function calling system that converts native functions and semantic functions into OpenAPI/JSON schemas, then routes function-calling requests to multiple LLM providers (OpenAI, Azure OpenAI, Anthropic, Ollama, etc.) with automatic schema translation and result parsing. The system uses a service selection layer that allows developers to specify execution settings per function, enabling fallback chains and provider-specific optimizations without code changes.

Provides tight integration with Azure OpenAI services and Microsoft 365 Copilot platform, including native support for Azure authentication (managed identities, service principals), Azure Cognitive Search for RAG, and Copilot-specific features (plugins, message extensions). The framework includes optimized connectors for Azure OpenAI that handle token counting, deployment selection, and Azure-specific execution settings.

Provides comprehensive OpenTelemetry (OTel) instrumentation across the kernel, including traces for function calls, LLM requests, and agent execution, plus metrics for token counting, latency, and error rates. The framework emits semantic conventions-compliant telemetry that integrates with observability platforms (Azure Monitor, Datadog, Jaeger, etc.) without code changes.

Implements optional prompt caching and function result memoization to reduce redundant LLM calls and API costs. The system can cache LLM responses based on prompt content hashing and memoize function results based on input arguments, with configurable cache backends (in-memory, Redis, etc.). This is particularly useful for agents that repeatedly invoke the same functions or prompts.

Provides a KernelPlugin abstraction that bundles related semantic and native functions into composable, reusable units that can be dynamically loaded into the kernel at runtime. Plugins are defined declaratively (via attributes in .NET, decorators in Python) and support metadata (descriptions, input/output schemas) that enable LLMs to discover and reason about available functions. The system supports both file-based plugins (loaded from disk) and in-memory plugin registration.

Provides a templating language for defining LLM prompts as semantic functions with support for variable interpolation, execution settings (model, temperature, max tokens), and prompt composition. Semantic functions are defined as text templates (stored in .txt files or inline) that reference kernel arguments and can be executed through the kernel with provider-specific execution settings. The system supports a custom prompt template language with handlebars-style syntax for variable substitution and function composition.

Provides abstractions for embedding generation (IEmbeddingGenerationService) and vector storage (IMemoryStore) that enable retrieval-augmented generation (RAG) workflows. The system supports multiple embedding providers (OpenAI, Azure OpenAI, Ollama) and vector store backends (Azure Cognitive Search, Chroma, Pinecone, Weaviate, etc.) through a plugin-based architecture. Developers can store semantic memories (text chunks with embeddings) and retrieve relevant context for LLM prompts using semantic similarity search.

Provides ChatCompletionAgent and related agent base classes that implement autonomous agent loops with built-in support for function calling, memory management, and multi-turn conversations. Agents use a planning strategy (e.g., function-calling loop) to determine which functions to invoke based on LLM reasoning, execute those functions, and incorporate results into subsequent LLM calls. The framework handles conversation history management, token counting, and termination conditions.

Provides abstractions for coordinating multiple agents in a single application, enabling agents to communicate with each other, share context, and collaborate on complex tasks. The framework supports agent grouping, message routing between agents, and shared kernel instances for function access. Agents can invoke other agents as functions, creating hierarchical or peer-to-peer agent networks.

Enables automatic conversion of OpenAPI 3.0 schemas into kernel functions, allowing developers to expose REST APIs as LLM-callable functions without manual schema definition. The system parses OpenAPI specifications, generates function signatures, and creates semantic functions that construct HTTP requests based on LLM-provided parameters. This enables agents to discover and invoke external APIs dynamically.

Provides a filter pipeline architecture (IFunctionFilter, IPromptFilter) that enables developers to intercept and modify function calls, prompt execution, and LLM responses at multiple points in the execution lifecycle. Filters can be registered globally or per-function, enabling cross-cutting concerns like logging, cost tracking, prompt injection prevention, and response validation without modifying core function logic.

Provides built-in Python code execution capabilities that allow agents to write and execute Python code dynamically, enabling complex computations, data transformations, and reasoning tasks that are difficult for LLMs alone. The system includes sandboxing mechanisms to prevent malicious code execution and integrates code execution as a kernel function that agents can invoke.