Semantic Kernel

Plugins are the primary unit of capability extension in Semantic Kernel. They are collections of related functions that an AI can call. A plugin can contain:

• Native Functions: Code written in languages like C#, Python, or Java that performs deterministic operations (e.g., calculations, database queries).
• Semantic Functions: Prompts defined by natural language instructions and few-shot examples, executed by an LLM. Plugins modularize skills—like "MathPlugin" or "EmailPlugin"—and are registered with the kernel to make their functions discoverable and callable by planners.

The Kernel is the central runtime and orchestration engine. It acts as a function registry and dispatcher, managing:

• Plugin Registration: Loading and cataloging available plugins and their functions.
• Function Invocation: Executing both native and semantic functions, handling input/output binding.
• Context Management: Maintaining a shared KernelArguments context that flows between chained function calls, allowing results from one function to be passed as input to another. The kernel abstracts the complexity of mixing LLM prompts with traditional code execution.

Planners are AI-driven components that automatically decompose a high-level user goal into a sequence of executable steps (a plan). Using the kernel's registry, a planner:

1. Analyzes the available plugins and functions.
2. Generates a step-by-step plan to achieve the goal.
3. Invokes the kernel to execute each step in the plan. For example, given the goal "Summarize the top news story and email it to me," a planner might create a plan calling a NewsPlugin.GetTopStory function followed by an EmailPlugin.Send function.

Semantic functions are prompts treated as callable software functions. Defined by:

• Prompt Template: A natural language instruction with placeholders for variables (e.g., Summarize this: {{$input}}).
• Configuration: Settings like the LLM model to use, temperature, and token limits. When invoked, the kernel renders the template with provided arguments, sends it to the configured LLM, and returns the completion. This allows developers to package and reuse complex prompt logic alongside native code.

Connectors are abstractions for interfacing with external AI and data services. Key connector types include:

• AI Service Connectors: Provide a uniform interface to different LLM endpoints (e.g., OpenAI, Azure OpenAI, Hugging Face). Switching models often requires only a configuration change.
• Memory Connectors: Interface with vector databases (e.g., Azure AI Search, Qdrant, PostgreSQL) to store and retrieve embeddings for semantic memory and recall.
• Chat Completion Connectors: Specialized connectors for managing multi-turn conversational context with chat models. Connectors standardize integration, promoting portability and reducing vendor lock-in.

The Memory abstraction provides AI agents with persistent, searchable context beyond a single conversation. It enables:

• Vector-based Semantic Search: Storing text as embeddings in a vector database allows the kernel to retrieve relevant past information using similarity search, not just keyword matching.
• Information Recall: A planner can query memory to find relevant facts before executing a step (e.g., "Find the user's project notes from last week").
• Chat History: Maintaining long-term conversation context across sessions. This component is crucial for building agents that learn and act on historical data.

In Semantic Kernel, a semantic function is a prompt-based, natural language instruction that is templated and invoked as a callable unit within a plan. Unlike native functions written in code, semantic functions are defined by a prompt template and configuration, allowing the LLM to generate dynamic text or orchestrate other functions.

• Core Abstraction: They turn a prompt into a reusable, configurable component.
• Orchestration: A semantic function can call native plugin functions, creating a hybrid AI/programmatic workflow.
• Template Variables: Use the {{$input}} syntax and other context variables to make prompts dynamic.

A native function (or plugin function) in Semantic Kernel is a conventional programming language method (C#, Python) that is registered with the kernel and becomes callable by planners and semantic functions. This bridges deterministic code with LLM reasoning.

• Code Integration: Enables AI agents to execute precise logic, calculations, or API calls written in standard code.
• Automatic Schema Generation: The kernel inspects the method's signature (parameters, return type) to create a description the LLM can understand.
• Decorator-Based: In Python, the @kernel_function decorator marks a method as available to the kernel.

A planner in Semantic Kernel is a component that uses an LLM to decompose a high-level user goal into a sequence of actionable steps, typically a series of semantic and native function calls. It embodies the Reasoning + Acting (ReAct) pattern within the SDK.

• Goal-Oriented: Takes a natural language objective (e.g., "Send an email summarizing the latest sales figures") and creates a plan.
• Dynamic Orchestration: Selects and chains available functions from registered plugins to fulfill the goal.
• Self-Correction: Can replan based on execution errors or unexpected outputs.

The kernel is the central runtime and coordination engine in Semantic Kernel. It manages the registry of available plugins (containing native and semantic functions), handles prompt templating, and executes plans by invoking the LLM and connected functions.

• Service Aggregator: Configures and injects services like LLM connectors, embedding generators, and memory stores.
• Function Registry: The Kernel object is the catalog where all callable functions are registered.
• Execution Context: Provides a KernelArguments object that flows through a plan, carrying variables and state between function steps.

Plugins are the primary unit of modularity and capability packaging in Semantic Kernel. A plugin is a collection of related functions (both native and semantic) grouped together, analogous to a class in object-oriented programming or a module in Python.

• Organizational Structure: Functions are accessed via the plugin name (e.g., MathPlugin.Add, EmailPlugin.Send).
• Reusability and Sharing: Plugins can be developed independently and imported into different kernel instances.
• Native Code Wrapping: The standard pattern for making existing libraries and APIs available to an AI agent.