AzureFeeds

Most developers today face a common challenge when integrating AI into their applications: the gap between natural language prompts and actual code execution. While services like OpenAI’s ChatGPT excel at generating responses, they can’t directly interact with your existing systems, databases, or business logic. You’re left building complex orchestration layers, managing function calls manually, and creating brittle workflows that break when requirements change.

Microsoft Semantic Kernel changes this paradigm entirely.

Unlike traditional LLM integrations where you send a prompt and receive text, Semantic Kernel acts as an AI orchestration layer that bridges natural language with your existing codebase. Semantic Kernel intelligently decides which of your trusted functions to execute, chains your reliable workflows together automatically, and handles the complete workflow from user intent to business outcome using your proven business logic rather than asking the LLM to handle complex tasks with the risk of hallucinating solutions.

 

What Makes Semantic Kernel Different

The Traditional (Novice) LLM Integration Problem

Meet Kemi, a data analyst who has spent months perfecting a Python script that generates exactly the sales visualizations her team needs. Her workflow is reliable: run the script, review the charts, write insights based on patterns she knows matter to the business, and deliver a concise report.

Excited about AI’s potential, Kemi decides to “upgrade” her process with ChatGPT. She uploads her sales data and asks the model to create visualizations and analysis. The LLM responds by generating an entirely new script with a dozen different chart types – many irrelevant to her business needs. She then has to upload the generated images back to the model for analysis, hoping it will provide accurate insights.

The result? Instead of streamlining her proven workflow, Kemi now has:

• Unreliable outputs: The LLM generates different charts each time, some irrelevant to business decisions


• Loss of domain expertise: Her carefully crafted analysis logic is replaced by generic AI interpretations


• Broken workflow: What was once a single script is now a multi-step process of uploading, generating, downloading, and re-uploading


• Reduced confidence: She can’t trust the AI’s business recommendations the way she trusted her own tested methodology


• More complexity, not less: Her “AI upgrade” created more steps and uncertainty than her original manual process

Kemi’s experience reflects a common pitfall: replacing proven business logic with unpredictable LLM generation rather than enhancing existing workflows with intelligent orchestration.

A Better Approach: Semantic Kernel Integration

In this article, I present a better approach that solves Kemi’s problem entirely. Instead of replacing her proven workflows with unpredictable AI generation, we’ll show how Microsoft Semantic Kernel transforms her existing script into an intelligent agent that preserves her business logic while adding natural language control.

By the end of this article, you’ll have a solid grasp of how to integrate Semantic Kernel into your own workflows – whether that’s connecting weather APIs for automated marketing campaigns, database queries for sales reporting, or Teams notifications for development task management. The principles you’ll learn here apply to automating any specific marketing, sales, or development task where you want AI orchestration without sacrificing the reliability of your existing business logic.

The Semantic Kernel Transformation

Let’s see how Semantic Kernel solves Kemi’s workflow problem by transforming her existing script into an intelligent agent that preserves her business logic while adding natural language orchestration.

The Complete Example

• Before: Kemi’s Original Script


• After: Smart Business Agent


• Full Repository: semantic-kernel-business-agent

Kemi’s Original Functions

Kemi’s script contains two core functions that she’s refined over months:

• get_sales_summary(): Calculates total sales, daily averages, and key metrics


• create_basic_chart(): Generates a reliable sales trend visualization

These functions work perfectly for her needs, but require manual orchestration and individual execution.

Setting Up the Foundation

First, Kemi needs to install the required libraries and set up her OpenAI credentials:

pip install semantic-kernel pandas matplotlib python-dotenv

She creates a .env file to securely store her OpenAI API key:

OPENAI_API_KEY=your-openai-api-key-here

Get your OpenAI API key from platform.openai.com → API Keys

Step 1: From Manual Function Calls to Kernel Functions

In her original script, Kemi had to manually orchestrate everything:

# From basic_data_analysis.py – Kemi’s manual workflow
analyzer = DataAnalyzer()
print(analyzer.get_sales_summary()) # She manually calls this
analyzer.create_basic_chart() # Then manually calls this

With Semantic Kernel, she transforms these exact same functions into AI-discoverable capabilities:

from semantic_kernel.functions import kernel_function
from typing import Annotated

@kernel_function(
description=”Get sales performance summary with total sales, averages, and trends”,
name=”get_sales_summary”
)
def get_sales_summary(self) -> Annotated[str, “Sales summary with key metrics”]:
# Kemi’s exact same trusted business logic – unchanged!
total_sales = self.sales_data[‘sales’].sum()
avg_daily_sales = self.sales_data[‘sales’].mean()
return f”Total: ${total_sales:,}, Daily Avg: ${avg_daily_sales:.2f}”

She’s not replacing her proven logic with AI generation – she’s making her existing, reliable functions available to intelligent orchestration.

Step 2: Enhancing Her Chart Function with Smart Parameters

Kemi’s original create_basic_chart() only made one type of chart. With SK, she can enhance it to be more versatile while keeping the core logic:

(
description=”Create and save a sales performance chart visualization”,
name=”create_sales_chart”
)
def create_sales_chart(
self,
chart_type: Annotated[str, “Type of chart: ‘trend’, ‘regional’, or ‘product'”] = “trend”
) -> Annotated[str, “Confirmation that chart was created”]:
# Kemi’s same matplotlib logic, now with intelligent chart selection
plt.figure(figsize=(12, 8))

if chart_type == “trend”:
plt.plot(self.sales_data[‘date’], self.sales_data[‘sales’], marker=’o’)
plt.title(‘Sales Trend Over Time’, fontsize=16)
# … rest of her charting logic

 

Step 3: Adding New Capabilities She Always Wanted

Now she can add functions she never had time to build manually, like automated insights and report sending:

(
description=”Send performance report via email to team”,
name=”send_report”
)
def send_report(self, recipient: Annotated[str, “Email address”]) -> Annotated[str, “Confirmation”]:
# For now, simulated – but she could easily integrate real email here
return f”📧 Performance report sent to {recipient}”

 

Step 4: Creating the Intelligent Agent

Here’s where the magic happens – connecting her functions to Semantic Kernel:

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from dotenv import load_dotenv

load_dotenv() # Load her OpenAI key

class SmartBusinessAgent:
def __init__(self):
# Initialize the kernel
self.kernel = Kernel()

# Connect to OpenAI
self.kernel.add_service(
OpenAIChatCompletion(
service_id=”business_agent”,
api_key=os.getenv(“OPENAI_API_KEY”),
ai_model_id=”gpt-4o-mini”
)
)

# Register Kemi’s functions as AI-accessible tools
self.kernel.add_plugin(SmartBusinessPlugin(), plugin_name=”business”)

# Enable automatic function orchestration
self.execution_settings = OpenAIChatPromptExecutionSettings(
function_choice_behavior=FunctionChoiceBehavior.Auto()
)

 

Step 5: The Natural Language Interface

Now Kemi can interact with her proven workflows using natural language:

async def process_request(self, user_request: str) -> str:
result = await self.kernel.invoke_prompt(
prompt=f”You are a business intelligence agent. You can analyze sales data, create charts, generate insights, and send reports.nnRequest: {user_request}”,
arguments=KernelArguments(settings=self.execution_settings)
)
return str(result)

 

The Transformation in Action

Before – Kemi’s manual, step-by-step process:

analyzer = DataAnalyzer()
summary = analyzer.get_sales_summary() # She decides to call this
chart = analyzer.create_basic_chart() # Then she decides to call this
# Then she manually writes insights and sends emails

After – Intelligent orchestration of her same functions:

agent = SmartBusinessAgent()
response = await agent.process_request(
“Analyze our sales performance, create relevant charts, and email the full report to sarah@company.com”
)
# SK automatically calls: get_sales_summary() → create_sales_chart(“trend”) →
# create_sales_chart(“regional”) → get_business_insights() → send_report(“sarah@company.com”)

 

prompt and model’s responseprompt and model’s response

The breakthrough: Kemi keeps her trusted business logic intact while gaining an intelligent interface that can understand complex requests, automatically determine which of her functions to call, and handle multi-step workflows – all while using her proven, reliable analysis methods instead of unpredictable AI generation.

This is the core power of Semantic Kernel: enhancing existing workflows with AI orchestration rather than replacing proven business logic with risky hallucination-prone generation.

Whether you’re working with weather APIs for marketing automation, database queries for sales reporting, or Teams notifications for development workflows, these same patterns apply. You can keep your proven logic and enhance with AI orchestration. 

Try It Yourself

Ready to transform your own workflows? Here’s how to get started:

1. Clone and Run the Complete Example

git clone https://github.com/your-username/semantic-kernel-business-agent
cd semantic-kernel-business-agent
pip install -r requirements.txt

 

2. Set Up Your Environment

# Add your OpenAI API key
cp .env.example .env
# Edit .env and add: OPENAI_API_KEY=your-key-here

 

3. Experience the Transformation

# Run Kemi’s original manual script
python basic_data_analysis.py

# Then run the intelligent agent
python smart_business_agent.py

 

4. Experiment with Natural Language Requests

Try these prompts with the smart agent:

• “Give me a comprehensive sales analysis with multiple chart types”


• “Create regional performance charts and send insights to my email”


• “What trends should we focus on for next quarter’s strategy?”

Watch how Semantic Kernel automatically orchestrates Kemi’s trusted functions to fulfill complex, multi-step requests.

Next Steps: Adapt to Your Workflow

Take your own scripts and apply the same transformation:

1. Identify your core functions (like Kemi’s get_sales_summary() and create_basic_chart())


2. Add ​ decorators with clear descriptions


3. Create your agent class connecting to your preferred LLM


4. Test with natural language requests that combine multiple functions

The full repository includes additional examples and documentation to help you extend these concepts to your specific use cases.

The goal isn’t to replace your expertise with AI – it’s to make your expertise accessible through intelligent, natural language orchestration.

Start with the working example, then gradually transform your own workflows. You’ll discover that Semantic Kernel doesn’t just automate tasks – it amplifies your existing capabilities while keeping you in control of the business logic that matters.

Further Reading

• Introduction to Semantic Kernel