Semantic Functions

The core of a semantic function is a prompt template—a parameterized string of natural language instructions and few-shot examples. This template is dynamically rendered at runtime using a template engine that injects variables from the execution context.

• Variables: Placeholders like {{$input}} or {{$skillName}} are replaced with actual values.
• Few-Shot Examples: In-context learning examples embedded in the template guide the model's output format.
• Engine: Uses a syntax (e.g., Handlebars) to separate logic from the prompt text, enabling reuse and composition.

This component defines the runtime parameters for the large language model call. It is separate from the prompt logic and controls the deterministic aspects of the inference.

• Model Selection: Specifies which LLM (e.g., GPT-4, Claude 3) to use for completion.
• Inference Parameters: Sets values for temperature, top_p, max_tokens, and stop sequences to control creativity and length.
• Service Endpoint: Configures the API endpoint and authentication, allowing the same function to target different model providers or deployments.

A defining feature is the ability to invoke native plugin functions (code written in C#, Python, etc.). The semantic function acts as a planner or orchestrator, using the LLM to decide when and how to call these functions.

• Skill/Plugin Reference: The function has access to a registry of available native functions (skills).
• Parameter Marshaling: The LLM's natural language output is parsed to generate structured inputs for the native function call.
• Chaining: Outputs from native functions can be fed back into the semantic function's context for multi-step reasoning.

While flexible, semantic functions often define expected input parameters and return types to integrate cleanly within a larger, typed application. This provides a contract for developers.

• Parameter Definition: Describes the variables the prompt template expects (e.g., topic: string, tone: enum).
• Structured Output: Though the core output is text, post-processing can enforce a JSON Schema or a Pydantic model to guarantee a structured response for downstream systems.
• Context Variable Binding: Inputs are bound to the function's execution context, making them available to the template engine.

The semantic function executes within a runtime context that provides access to shared services, memory, and, crucially, other functions. This context enables composition and statefulness.

• Skill Collection: A reference to the set of native and semantic skills the function can invoke.
• Memory Connectors: Access to vector stores or other memory systems for retrieval-augmented generation (RAG) within the prompt.
• Conversation History: The context maintains the dialog history, allowing the function to be aware of previous interactions.

In advanced use, semantic functions are used by planners—specialized components that automatically chain functions together to achieve a complex goal. The function's description and schema are metadata for the planner.

• Goal Decomposition: A planner (e.g., a Sequential Planner) uses a semantic function to break a user request into a plan of actionable steps.
• Auto-Generated Plans: The planner LLM reads the descriptions of available semantic functions to construct a valid execution sequence.
• Orchestration: The planner handles the execution flow, error handling, and passing results between functions in the chain.

Function calling is a core LLM capability where the model is prompted to output a structured request—typically a JSON object—that matches a predefined schema for invoking an external function or API. It is the foundational mechanism that enables models to act beyond text generation.

• Key Mechanism: The model receives descriptions of available functions (name, purpose, parameter schema) and decides if and how to call one.
• Structured Output: The model's response is constrained to a specific JSON format, enabling reliable parsing by the host application.
• Contrast with Semantic Functions: While function calling is the general capability, a semantic function is a specific implementation pattern, often a templated prompt that uses function calling to orchestrate other plugins.

Semantic Kernel is an open-source SDK from Microsoft that provides the primary architectural context for semantic functions. It is a lightweight orchestration layer that blends conventional programming ("native functions") with AI prompts ("semantic functions") into a cohesive planner.

• Core Abstraction: It introduces the concepts of Skills (collections of functions), Planners (AI components that chain functions), and Memory for context.
• Native vs. Semantic Functions: Native functions are written in code (C#, Python). Semantic functions are defined by prompts and can call native functions, creating a hybrid AI/software system.
• Orchestration: Semantic Kernel's planner can automatically generate a sequence of native and semantic function calls to fulfill a complex user goal.

A tool registry (or function registry) is a central catalog within an AI agent system that stores the definitions, schemas, and executable handlers for all tools and APIs available for invocation. It is the source of truth for tool discovery.

• Metadata Storage: Contains each tool's name, description, parameter JSON Schema, authentication requirements, and a pointer to its execution code.
• Dynamic Registration: Tools can be added at runtime, allowing systems to adapt to new capabilities without restarting.
• Discovery Mechanism: When an LLM needs to act, it queries or is provided with a filtered list from the registry to inform its tool selection decision.

Structured output guarantees are techniques that enforce a language model's response to strictly conform to a predefined schema, such as a Pydantic model or JSON Schema. This is critical for the reliable parsing of function call arguments.

• Enforcement Methods: Can be achieved via guided generation (model API features), output parsers (post-processing libraries), or grammar-based sampling.
• Type Safety: Ensures parameters are of the correct type (string, integer, array) and format before being passed to the underlying function, preventing runtime errors.
• Relationship to Semantic Functions: A semantic function's prompt template is often designed to work in concert with a structured output schema, guiding the model to fill the required fields correctly.

Dynamic dispatch is the runtime mechanism in a function-calling framework that receives a model's structured tool call request and routes it to the correct handler function or API client for execution.

• Routing Logic: Uses the tool_name or function_name field from the model's JSON output as a key to look up the corresponding executable in the registry.
• Parameter Binding: Extracts the arguments object from the request, validates it against the tool's schema, and passes the values as parameters to the handler.
• System Integration: This layer decouples the AI model's decision from the actual code execution, allowing for middleware, security checks, and logging to be injected.

The ReAct (Reasoning + Acting) framework is a prompting paradigm that interleaves a language model's internal reasoning traces with external actions (tool calls). It provides a conceptual model for how semantic functions can be used in multi-step problem-solving.

• Pattern: The model output follows a loop of Thought (internal reasoning), Action (a structured tool call), and Observation (the tool's result).
• Explicit Planning: This forces the model to articulate its plan before acting, improving transparency and reliability in complex tasks.
• Implementation Context: While ReAct is a prompting technique, frameworks like Semantic Kernel implement planners that operationalize this pattern, where a semantic function might manage the "Thought" step that leads to an "Action".