Demystifying Semantic Kernel

Let's start with basic question, what exactly is Semantic Kernel?

1. SDK for AI Integration:

• Semantic Kernel provides a framework and tools to seamlessly integrate AI models, such as large language models (LLMs) from OpenAI, Azure OpenAI, Hugging Face, and others, into your existing applications.
• It supports multiple programming languages, including C#, Python, and Java, making it accessible to a wide range of developers.

2. Orchestration with Intelligence:

• Its core power lies in its ability to intelligently orchestrate the interactions between AI models and your code.
• It does this by:
• ""Enabling you to define plugins, which are modular blocks of code that encapsulate specific tasks or functionalities.""
• ""Using planners, which are AI-powered algorithms that can create plans (sequences of plugins to execute) based on user goals and context.""

3. Simplifying AI Adoption:

• It aims to democratize AI and make it easier for developers to incorporate advanced AI capabilities into their applications without requiring deep expertise in AI model development or orchestration.

Unveiling Complex Concepts: A Simplified Analogy for Easy Understanding

Imagine Semantic Kernel as a wise team leader, and the plugins as their team members with different skills.

1. GPT-3 as a Creative Advisor:

• The team leader (Semantic Kernel) asks a creative advisor (GPT-3) for general suggestions on how to approach a task.
• GPT-3, being knowledgeable but not knowing the exact team members, offers ideas like "write a poem," "translate a document," or "search for information."

1. Team Leader's Understanding:

• The team leader understands these general suggestions and matches them to the skills of their team members (plugins).
• They recognize that "write a poem" aligns with the "GPT3Plugin" member's skill, "translate a document" matches the "TranslationPlugin" member, and so on.

1. Creating a Plan:

• Based on this mapping, the team leader creates a plan that assigns specific tasks to the appropriate team members, ensuring they work together smoothly.

In essence, Semantic Kernel acts as the intelligent bridge between GPT-3's general suggestions and the specific actions of its plugins. It does this by:

• Understanding GPT-3's Language: It's trained to interpret the language patterns GPT-3 uses to describe tasks and goals.
• Knowing Plugin Capabilities: It has a comprehensive understanding of what each plugin can do, allowing it to match GPT-3's suggestions to plugin functionalities.
• Planning and Orchestration: It has the logical ability to create a sequence of actions (a plan) that involves multiple plugins and ensures their coordinated execution.

Remember: GPT-3 offers creative ideas, but Semantic Kernel is the one who understands those ideas and turns them into specific actions within its own system.

Enough of analogy; let's delve into basic Python examples to understand its role more from an engineer's perspective:

import semantic_kernel as sk

# Create a kernel instance
kernel = sk.Kernel()

# Register plugins (here, we're using fictional plugins for illustration)
kernel.register_plugin(WeatherPlugin())
kernel.register_plugin(EmailPlugin())
kernel.register_plugin(TranslationPlugin())

# Set a planner (a simple rule-based planner for this example)
kernel.planner = SimpleRuleBasedPlanner()

# Example user goal
user_goal = "Tell me the weather in Paris, and then email a summary to my friend in Spanish."

# Execute the plan
result = kernel.execute(user_goal)

# Print the result (assuming it contains the weather information and email content)
print(result)
        

Explanation:

1. Importing the SDK: imports the necessary library for using Semantic Kernel's features.
2. Creating a Kernel Instance:creates the core object that manages the plugins and orchestration process.
3. Registering Plugins:kernel.register_plugin(WeatherPlugin()) registers a plugin that can fetch weather information.
4. Similarly, EmailPlugin and TranslationPlugin are registered for email functionality and translation, respectively.
5. Setting a Planner:kernel.planner = SimpleRuleBasedPlanner() assigns a planner that will determine the sequence of plugins to execute based on user goals.
6. Specifying User Goal:user_goal contains the user's request, which the planner will use to create a plan.
7. Executing the Plan:result = kernel.execute(user_goal) triggers the execution of the plan generated by the planner.
8. Retrieving Results:print(result) prints the final output, which might include the weather forecast for Paris and the translated email ready to be sent.

Key Points:

• Plugins: The example demonstrates how plugins encapsulate specific AI capabilities (weather, email, translation) and can be seamlessly integrated.
• Planner: The planner intelligently determines the order of plugin execution based on the user's goal and context.

Till here we understood that Semantic kernal has plugins and it takes goal as input creates the plan to use different plugins, to achieve the desired goal, like in above example.

Let's explore another Python code example, this time integrating it with OpenAI. We'll break it down line by line to gain a clearer understanding of its end-to-end application

import semantic_kernel as sk
from openai import ChatGPT        

• Imports the Semantic Kernel SDK for plugin and planner functionalities.
• Imports the OpenAI API client to interact with GPT-3.

kernel = sk.Kernel()
        

• Instantiates the core Semantic Kernel object, responsible for managing plugins and orchestration.

class GPT3Plugin:
    def __init__(self, api_key):
        self.gpt = ChatGPT(api_key)

    def generate_text(self, prompt):
        return self.gpt.submit(prompt)
        

• Create a class named GPT3Plugin to encapsulate GPT-3 functionality. The init method initializes the plugin with your OpenAI API key, and the generate_text method sends a prompt to GPT-3, returning the generated text response

kernel.register_plugin(GPT3Plugin("<your_openai_api_key>"))
kernel.register_plugin(WeatherPlugin())
kernel.register_plugin(EmailPlugin())
        

• Makes the plugins available to the kernel for orchestration.
• Registers the GPT3Plugin (with your API key), WeatherPlugin, and EmailPlugin.

class OpenAIPlanner(sk.SimpleRuleBasedPlanner):
    def plan(self, user_goal):
        refined_goal = self.gpt3.generate_text(f"How can I best fulfill the request: {user_goal}")
        return super().plan(refined_goal)

kernel.planner = OpenAIPlanner()
        

• Set a custom planner: Create a planner class, OpenAIPlanner, that inherits from the base SimpleRuleBasedPlanner. The plan method is then overridden to use GPT-3 to refine the user goal (potentially suggesting creative approaches), apply rule-based planning logic on the refined goal, and assign this custom planner to the kernel

user_goal = "Write a creative poem about a rainy day in London."
result = kernel.execute(user_goal)
print(result)
        

• Execute the plan:Sets a user goal (writing a poem).Executes the plan generated by the planner.
• Prints the final result (the generated poem).

So, in the above example, GPT once again proves to be an intelligent creator, generating creative results to fulfill the user's goal. Semantic Kernel comprehends the GPT response and devises a plan to use the defined plugins, ensuring a proper sequence of calling plugins — that is, the plan.

This is what I have learned so far about Semantic Kernel, and I wanted to share it with all of you as I believe it serves as a good starting point.