The Planner is one of the fundamental concepts of the Semantic Kernel.
It makes use of the collection of native and semantic functions that have been registered to the kernel and using AI, will formulate a plan to execute the given ask.
From our own testing, planner works best with more powerful models like gpt4 but sometimes you might get working plans with cheaper models like gpt-35-turbo. We encourage you to implement your own versions of the planner and use different models that fit your user needs.
Read more about planner here
!python -m pip install semantic-kernel==0.3.10.dev0
import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, AzureChatCompletion
kernel = sk.Kernel()
useAzureOpenAI = True
# Configure AI backend used by the kernel
if useAzureOpenAI:
deployment, api_key, endpoint = sk.azure_openai_settings_from_dot_env()
kernel.add_chat_service("gpt-3.5", AzureChatCompletion("gpt-35-turbo", endpoint, api_key))
else:
api_key, org_id = sk.openai_settings_from_dot_env()
kernel.add_chat_service("gpt-3.5", OpenAIChatCompletion("gpt-3.5-turbo", api_key, org_id))
ask = """
Tomorrow is Valentine's day. I need to come up with a few date ideas. She speaks French so write it in French.
Convert the text to uppercase"""
The planner needs to know what skills are available to it. Here we'll give it access to the SummarizeSkill and WriterSkill we have defined on disk. This will include many semantic functions, of which the planner will intelligently choose a subset.
You can also include native functions as well. Here we'll add the TextSkill.
from semantic_kernel.core_skills.text_skill import TextSkill
skills_directory = "../../samples/skills/"
summarize_skill = kernel.import_semantic_skill_from_directory(skills_directory, "SummarizeSkill")
writer_skill = kernel.import_semantic_skill_from_directory(skills_directory, "WriterSkill")
text_skill = kernel.import_skill(TextSkill(), "TextSkill")
Define your ASK. What do you want the Kernel to do?
Let's start by taking a look at a basic planner. The BasicPlanner produces a JSON-based plan that aims to solve the provided ask sequentially and evaluated in order.
from semantic_kernel.planning.basic_planner import BasicPlanner
planner = BasicPlanner()
basic_plan = await planner.create_plan_async(ask, kernel)
print(basic_plan.generated_plan)
You can see that the Planner took my ask and converted it into an JSON-based plan detailing how the AI would go about solving this task, making use of the skills that the Kernel has available to it.
As you can see in the above plan, the AI has determined which functions to call in order to fulfill the user ask. The output of each step of the plan becomes the input to the next function.
Let's also define an inline skill and have it be available to the Planner. Be sure to give it a function name and skill name.
sk_prompt = """
{{$input}}
Rewrite the above in the style of Shakespeare.
"""
shakespeareFunction = kernel.create_semantic_function(sk_prompt, "shakespeare", "ShakespeareSkill",
max_tokens=2000, temperature=0.8)
Let's update our ask using this new skill
ask = """
Tomorrow is Valentine's day. I need to come up with a few date ideas.
She likes Shakespeare so write using his style. She speaks French so write it in French.
Convert the text to uppercase."""
new_plan = await planner.create_plan_async(ask, kernel)
print(new_plan.generated_plan)
Now that we have a plan, let's try to execute it! The Planner has a function called execute_plan.
results = await planner.execute_plan_async(new_plan, kernel)
print(results)
To build more advanced planners, we need to introduce a proper Plan object that can contain all the necessary state and information needed for high quality plans.
To see what that object model is, look at (https://github.com/microsoft/semantic-kernel/blob/main/python/semantic_kernel/planning/plan.py)
The sequential planner is an XML-based step-by-step planner. You can see the prompt used for it here (https://github.com/microsoft/semantic-kernel/blob/main/python/semantic_kernel/planning/sequential_planner/Skills/SequentialPlanning/skprompt.txt)
from semantic_kernel.planning import SequentialPlanner
planner = SequentialPlanner(kernel)
sequential_plan = await planner.create_plan_async(goal=ask)
To see the steps that the Sequential Planner will take, we can iterate over them and print their descriptions
for step in sequential_plan._steps:
print(step.description, ":", step._state.__dict__)
Let's ask the sequential planner to execute the plan.
result = await sequential_plan.invoke_async()
print(result)
The action planner takes in a list of functions and the goal, and outputs a single function to use that is appropriate to meet that goal.
from semantic_kernel.planning import ActionPlanner
planner = ActionPlanner(kernel)
Let's add more skills to the kernel
from semantic_kernel.core_skills import FileIOSkill, MathSkill, TextSkill, TimeSkill
kernel.import_skill(MathSkill(), "math")
kernel.import_skill(FileIOSkill(), "fileIO")
kernel.import_skill(TimeSkill(), "time")
kernel.import_skill(TextSkill(), "text")
ask = "What is the sum of 110 and 990?"
plan = await planner.create_plan_async(goal=ask)
result = await plan.invoke_async()
print(result)