FunctionResult<\/a>.<\/p>\n03. Creating a function from a prompt<\/h3>\n
Previously, creating a semantic function was tightly coupled with OpenAI request settings like max_tokens<\/code> and temperature<\/code>.<\/p>\nsemantic_function = kernel.create_semantic_function(\r\n prompt,\r\n function_name=\"Chat\",\r\n description=\"Chat with the assistant\",\r\n max_tokens=4000,\r\n temperature=0.3,\r\n)<\/code><\/pre>\nWe’ve updated it so that the execution settings can differ per service type. In the following example, we demonstrate how the execution settings type can be pulled from the service within the kernel. As we complete YAML prompt serialization, this code will become even simpler so that you as a developer don’t have to explicitly wire this up. You’ll simply provide the YAML file with the prompt and execution settings and Semantic Kernel will automatically create the function for you.<\/p>\n
chat_function = kernel.create_function_from_prompt(\r\n prompt=prompt,\r\n plugin_name=\"Summarize_Conversation\",\r\n function_name=\"Chat\",\r\n execution_settings=kernel.get_service(service_id).instantiate_prompt_execution_settings(\r\n service_id=service_id,\r\n max_tokens=4000,\r\n temperature=0.3,\r\n ),\r\n)<\/code><\/pre>\nThe prompt_execution_settings can be one of the following: a single settings object, a list of settings objects or a dictionary of PromptExecutionSetting to be able to handle multiple models.<\/p>\n
04. Configuring Memory as a Plugin<\/h3>\n
Previously, the kernel could only have a single memory provider. The TextMemoryPlugin<\/code> could then automagically find this single memory provider when being added to a kernel. Unfortunately, this was limiting because many customers required multiple search indexes to be usable within a kernel.<\/p>\n# An embeddings generator is created as a part of register_memory \r\n# and the kernel has only one memory store attribute\r\nkernel.register_memory_store(VolatileMemoryStore())\r\nkernel.import_plugin(TextMemoryPlugin())<\/code><\/pre>\nThe register_memory_store in turn called the following code in the kernel:<\/p>\n
def use_memory(\r\n self,\r\n storage: MemoryStoreBase,\r\n embeddings_generator: Optional[EmbeddingGeneratorBase] = None,\r\n) -> None:\r\n if embeddings_generator is None:\r\n service_id = self.get_text_embedding_generation_service_id()\r\n if not service_id:\r\n raise ValueError(\"The embedding service id cannot be `None` or empty\")\r\n embeddings_service = self.get_ai_service(EmbeddingGeneratorBase, service_id)\r\n if not embeddings_service:\r\n raise ValueError(f\"AI configuration is missing for: {service_id}\")\r\n embeddings_generator = embeddings_service(self)\r\n if storage is None:\r\n raise ValueError(\"The storage instance provided cannot be `None`\")\r\n if embeddings_generator is None:\r\n raise ValueError(\"The embedding generator cannot be `None`\")\r\n self.register_memory(SemanticTextMemory(storage, embeddings_generator))\r\n\r\ndef register_memory(self, memory: SemanticTextMemoryBase) -> None:\r\n self.memory = memory<\/code><\/pre>\nAfterwards, we changed the relationship so that a single kernel could have multiple TextMemoryPlugin<\/code> objects added, each with their own memory store. This is powerful, because it allows you as a developer to have multiple memories for things like documents, short-term memory, and long term memory.<\/p>\nembedding_gen = OpenAITextEmbedding(\r\n service_id=\"ada\", ai_model_id=\"text-embedding-ada-002\", api_key=api_key, org_id=org_id\r\n)\r\nkernel.add_service(embedding_gen)\r\n\r\nmemory = SemanticTextMemory(storage=VolatileMemoryStore(), embeddings_generator=embedding_gen)\r\nkernel.import_plugin_from_object(TextMemoryPlugin(memory), \"TextMemoryPlugin\")<\/code><\/pre>\n05. Utilizing Chat History as part of a prompt<\/h3>\n
Previously, if you wanted to include a chat history within a prompt, you’d have to do string manipulation to join it together. Additionally, these pattern didn’t take advantage of the roles in the Chat Completion APIs provided by OpenAI and other model providers.<\/p>\n
prompt = \"\"\"{{$history}}\r\nUser: {{$request}}\r\nAssistant: \"\"\"\r\n\r\nhistory = []\r\nvariables = ContextVariables()\r\nvariables[\"request\"] = request\r\nvariables[\"history\"] = \"\\n\".join(history)\r\nsemantic_function = kernel.create_semantic_function(\r\n prompt,\r\n function_name=\"Chat\",\r\n description=\"Chat with the assistant\",\r\n max_tokens=4000,\r\n temperature=0.3,\r\n)\r\nresult = await kernel.run_async(\r\n semantic_function,\r\n input_vars=variables,\r\n)\r\n\r\n# Add the request to the history\r\nhistory.append(\"User: \" + request)\r\nhistory.append(\"Assistant\" + result.result)<\/code><\/pre>\nSubsequently, integrating a chat history object into a prompt becomes significantly simpler. Semantic Kernel can effortlessly incorporate it as a complex object, ensuring seamless integration into the prompt. During this operation, it will also leverage the roles defined in the Chat Completion service to produce better outcomes.<\/p>\n
history = ChatHistory()\r\n\r\nprompt = \"{{$history}}\"\r\n\r\nchat_function = kernel.create_function_from_prompt(\r\n prompt=prompt,\r\n plugin_name=\"chatGPT\",\r\n function_name=\"Chat\",\r\n prompt_template_config=chat_prompt_template_config,\r\n)\r\n\r\nhistory.add_user_message(request)\r\n\r\nresult = await kernel.invoke(\r\n chat_function,\r\n request=request,\r\n history=history,\r\n)\r\n\r\nhistory.add_assistant_message(str(result))<\/code><\/pre>\n<\/code><\/p>\n06. Creating a Plugin with Kernel Functions<\/h3>\n
Previously, annotating a plugin with semantic meaning was very verbose.<\/p>\n
class MathPlugin:\r\n @sk_function(\r\n description=\"Adds two numbers together\",\r\n name=\"Add\",\r\n )\r\n @sk_function_context_parameter(\r\n name=\"input\",\r\n description=\"The first number to add\",\r\n )\r\n @sk_function_context_parameter(\r\n name=\"number2\",\r\n description=\"The second number to add\",\r\n )\r\n def add(self, context: SKContext) -> str:\r\n return str(float(context[\"input\"]) + float(context[\"number2\"]))\r\n\r\n @sk_function(\r\n description=\"Subtract two numbers\",\r\n name=\"Subtract\",\r\n )\r\n @sk_function_context_parameter(\r\n name=\"input\",\r\n description=\"The first number to subtract from\",\r\n )\r\n @sk_function_context_parameter(\r\n name=\"number2\",\r\n description=\"The second number to subtract away\",\r\n )\r\n def subtract(self, context: SKContext) -> str:\r\n return str(float(context[\"input\"]) - float(context[\"number2\"]))\r\n\r\nmath_plugin = kernel.import_plugin(\r\n MathPlugin(), \r\n plugin_name=\"MathPlugin\"\r\n)\r\n\r\nresult = await kernel.run_async(\r\n math_plugin[\"Sqrt\"],\r\n input_str=\"12\",\r\n)<\/code><\/pre>\nWe now allow annotations to be added directly to the input parameters so that it’s easier to read and use.<\/p>\n
class MathPlugin:\r\n @kernel_function(name=\"Add\")\r\n def add(\r\n self,\r\n number1: Annotated[float, \"the first number to add\"],\r\n number2: Annotated[float, \"the second number to add\"],\r\n ) -> Annotated[float, \"the output is a float\"]:\r\n return float(number1) + float(number2)\r\n\r\n @kernel_function(\r\n description=\"Subtracts value to a value\",\r\n name=\"Subtract\",\r\n )\r\n def subtract(\r\n self,\r\n number1: Annotated[float, \"the first number\"],\r\n number2: Annotated[float, \"the number to subtract\"],\r\n ) -> Annotated[float, \"the output is a float\"]:\r\n return float(number1) - float(number2)\r\n\r\nmath_plugin = kernel.import_plugin_from_object(\r\n plugin_instance=MathPlugin(), \r\n plugin_name=\"MathPlugin\"\r\n)\r\n\r\nresult = await kernel.invoke(\r\n math_plugin[\"Add\"],\r\n number1=5,\r\n number2=5,\r\n)<\/code><\/pre>\nWe now support types other than strings, including custom objects (preferably based on Pydantic BaseModels.<\/p>\n
07. Using Kernel Arguments<\/h3>\n
Previously, developers had to juggle SKContext<\/code> and ContextVariables<\/code>. Many times, it was confusing when to use one or the other.<\/p>\nchat_prompt=\"{{$request}}\"\r\nhistory = []\r\nvariables = ContextVariables()\r\nrequest = \"some input\"\r\nvariables[\"request\"] = request\r\nvariables[\"history\"] = \"\\n\".join(history)\r\n\r\nresult = await kernel.run_async(\r\n chat_func,\r\n input_vars=variables,\r\n)\r\n\r\n# Add the request to the history\r\nhistory.append(\"User: \" + request)\r\nhistory.append(\"Assistant\" + result.result)<\/code><\/pre>\nWe’ve simplified this use of variables by introducing KernelArguments<\/code>. You can create them much more easily, as keyword arguments passed to the KernelArgument object, and then pass the KernelArgument object into the invoke<\/code> function.<\/p>\nchat_prompt = \"{{$request}}\"\r\nchat_history = ChatHistory()\r\nchat_history.add_system_message(\r\n \"You are a helpful, funny chatbot.\"\r\n)\r\n\r\n# Kernel Arguments can be specified as a concrete object\r\nargs = KernelArguments(arg1=val1, arg2=val2)\r\nresult = await kernel.invoke(func, args)\r\n<\/code><\/pre>\nAdditionally, if you don’t want to create a KernelArgument<\/code> object, you can simply pass in inputs and values as kwargs<\/code> so that you can further simplify your code.<\/p>\nresult = await kernel.invoke(\r\n functions=chat_func,\r\n request=\"some input\",\r\n chat_history=chat_history,\r\n)\r\nhistory.add_user_message(request)\r\nhistory.add_assistant_message(str(result))<\/code><\/pre>\n08. Configure Multiple Prompt Execution Settings<\/h3>\n
Previously, each prompt could only have a single set of execution settings attached to it. This was limiting for developers who wanted to use the same prompt across multiple models with different settings.<\/p>\n
prompt_template_config=PromptTemplateConfig(\r\n execution_settings=PromptExecutionSettings(service_id=\"id1\", temperature=0.0),\r\n),<\/code><\/pre>\nNow, you can author multiple execution settings and assign them to a prompt. This is helpful if you want to test different settings in production.<\/p>\n
prompt_template_config=PromptTemplateConfig(\r\n template=\"{{$request}}\",\r\n execution_settings=[\r\n OpenAIPromptExecutionSettings(service_id=\"id1\", temperature=0.0, num_of_responses=2),\r\n GooglePalmPromptExecutionSettings(service_id=\"id2\", temperature=1.0, candidate_count=2),\r\n ],\r\n),<\/code><\/pre>\n09. Then vs. Now: A Comprehensive Example<\/h3>\n
To see how the different capabilities layer onto each other, we’ve provided the following example for building a simple chat bot. The first block of code is how you’d previously author the sample.<\/p>\n
system_message = \"\"\"\r\nYou are a chat bot. Your name is Mosscap and\r\nyou have one goal: figure out what people need.\r\nYour full name, should you need to know it, is\r\nSplendid Speckled Mosscap. You communicate\r\neffectively, but you tend to answer with long\r\nflowery prose.\r\n\"\"\"\r\n# Create a kernel\r\nkernel = Kernel()\r\n\r\n# Create a chat service\r\nchat_service = AzureChatCompletion(\r\n **azure_openai_settings_from_dot_env_as_dict(include_api_version=True)\r\n)\r\n\r\n# Add the chat service to the kernel\r\nkernel.add_chat_service(\"chat-gpt\", chat_service)\r\n\r\n# Define the chat request settings\r\nreq_settings = kernel.get_prompt_execution_settings_from_service(\r\n ChatCompletionClientBase, \r\n \"chat-gpt\",\r\n)\r\nreq_settings.max_tokens = 2000\r\nreq_settings.temperature = 0.7\r\nreq_settings.top_p = 0.8\r\n\r\n# Configure the prompt config, template, and function config\r\nprompt_config = PromptTemplateConfig(execution_settings=req_settings)\r\nprompt_template = ChatPromptTemplate(\r\n \"{{$user_input}}\", \r\n kernel.prompt_template_engine, \r\n prompt_config\r\n)\r\nprompt_template.add_system_message(system_message)\r\nprompt_template.add_user_message(\"Hi there, who are you?\")\r\nprompt_template.add_assistant_message(\"I am Mosscap, a chat bot. I'm trying to figure out what people need.\")\r\nfunction_config = SemanticFunctionConfig(prompt_config, prompt_template)\r\n\r\n# Register the semantic function with the kernel\r\nchat_function = kernel.register_semantic_function(\"ChatBot\", \"Chat\", function_config)\r\n\r\n# Define an SK Context variables object to handle user input\r\ncontext_vars = ContextVariables()\r\nuser_input = input(\"User:> \")\r\ncontext_vars[\"user_input\"] = user_input\r\n\r\n# Run the chat function with the user's input\r\nanswer = await kernel.run_async(chat_function, input_vars=context_vars)\r\n\r\n# Display the result\r\nprint(f\"Mosscap:> {answer}\")<\/code><\/pre>\nAfter the changes introduced in the Beta release, you’d now write something like the following:<\/p>\n
system_message = \"\"\"\r\nYou are a chat bot. Your name is Mosscap and\r\nyou have one goal: figure out what people need.\r\nYour full name, should you need to know it, is\r\nSplendid Speckled Mosscap. You communicate\r\neffectively, but you tend to answer with long\r\nflowery prose.\r\n\"\"\"\r\n\r\n# Create a Kernel\r\nkernel = Kernel()\r\n\r\n# Define a service ID that ties to the AI service\r\nservice_id = \"chat-gpt\"\r\nchat_service = AzureChatCompletion(\r\n service_id=service_id, **azure_openai_settings_from_dot_env_as_dict(include_api_version=True)\r\n)\r\n\r\n# Add the AI service to the kernel\r\nkernel.add_service(chat_service)\r\n\r\n# Get the Prompt Execution Settings\r\nreq_settings = kernel.get_service(service_id).instantiate_prompt_execution_settings(\r\n service_id=service_id, \r\n max_tokens=2000,\r\n temperature=0.7,\r\n top_p=0.8,\r\n)\r\n\r\n# Create the prompt template config and specify any required input variables\r\nprompt_template_config = PromptTemplateConfig(\r\n template={{$chat_history}}{{$input}},\r\n name=\"chat\",\r\n input_variables=[\r\n InputVariable(name=\"input\", description=\"The user input\", is_required=True),\r\n InputVariable(name=\"chat_history\", description=\"The history of the conversation\", is_required=True),\r\n ],\r\n execution_settings=req_settings, # The execution settings will be tied to the configured service_id\r\n)\r\n\r\n# Create the chat function from the prompt template config\r\nchat_function = kernel.create_function_from_prompt(\r\n plugin_name=\"chat_bot\",\r\n function_name=\"chat\",\r\n prompt_template_config=prompt_template_config\r\n)\r\n\r\n# Define a chat history object\r\nhistory = ChatHistory(system_message=system_message)\r\n\r\n# Add the desired messages\r\nhistory.add_user_message(\"Hi there, who are you?\")\r\nhistory.add_assistant_message(\"I am Mosscap, a chat bot. I'm trying to figure out what people need.\")\r\n\r\n# Gather the user's input\r\nuser_input = input(\"User:> \")\r\n\r\n# Invoke the chat function, passing the kernel arguments as kwargs\r\nresponse = await kernel.invoke(\r\n chat_function,\r\n request=user_input,\r\n chat_history=history,\r\n)\r\n\r\n# View the response\r\nprint(f\"Mosscap:> {response}\")\r\n\r\n# Add the user's input and the assistant's messages to the on-going chat history\r\nhistory.add_user_message(user_input)\r\nhistory.add_assistant_message(str(response))<\/code><\/pre>\nNote: there are several ways to set the system message now. The first is to explicitly add the system message to the chat history either by history.add_system_message or as part of the ChatHistory constructor with keyword arguments, as shown above. The other way is to provide a system message through the template that is configured as part of the PromptTemplateConfig. Everything the template parser sees in the template before the ChatHistory object will be turned into a system_message, while everything between or after a ChatHistory is turned into user messages.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"The Semantic Kernel team is excited to announce we are on the brink of releasing v1.0.0 of our Python SDK. In our journey towards this significant milestone, the latest beta release (0.9.0b1) has brought essential breaking changes, aligning our Python SDK’s capabilities with those of our .NET SDK. Our commitment to Pythonic best practices shines […]<\/p>\n","protected":false},"author":150043,"featured_media":2060,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[34,1],"tags":[],"class_list":["post-2014","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python-2","category-semantic-kernel"],"acf":[],"blog_post_summary":"
The Semantic Kernel team is excited to announce we are on the brink of releasing v1.0.0 of our Python SDK. In our journey towards this significant milestone, the latest beta release (0.9.0b1) has brought essential breaking changes, aligning our Python SDK’s capabilities with those of our .NET SDK. Our commitment to Pythonic best practices shines […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/posts\/2014","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/users\/150043"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/comments?post=2014"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/posts\/2014\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/media\/2060"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/media?parent=2014"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/categories?post=2014"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/agent-framework\/wp-json\/wp\/v2\/tags?post=2014"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}