¿Qué es un Planificador?
Una vez que tenga varios complementos, necesita una manera de que el agente de IA los use juntos para resolver la necesidad de un usuario. Aquí es donde entra en acción la planificación.
Al principio, el kernel semántico introdujo el concepto de planificadores que usaban avisos para solicitar la inteligencia artificial para elegir las funciones que se van a invocar. Sin embargo, como se introdujo el kernel semántico, OpenAI introdujo una manera nativa para que el modelo invoque o "llame" a una función: llamada a función. Otros modelos de inteligencia artificial como Gemini, Claude y Mistral han adoptado la llamada a funciones como una funcionalidad básica, lo que lo convierte en una característica admitida entre modelos.
Debido a estos avances, el kernel semántico ha evolucionado para usar la llamada a funciones como la forma principal de planear y ejecutar tareas.
Importante
La llamada a funciones solo está disponible en los modelos openAI que son 0613 o versiones posteriores. Si usa un modelo anterior (por ejemplo, 0314), esta funcionalidad devolverá un error. Se recomienda usar los modelos openAI más recientes para aprovechar esta característica.
¿Cómo crea una función que llama a un "plan"?
En su forma más sencilla, la llamada a funciones es simplemente una manera de que una inteligencia artificial invoque una función con los parámetros correctos. Por ejemplo, un usuario quiere activar una bombilla. Suponiendo que la inteligencia artificial tiene el complemento adecuado, puede llamar a la función para encender la luz.
| Role | Mensaje |
|---|---|
| 🔵User | Active la luz n.º 1. |
| 🔴Asistente (llamada de función) | Lights.change_state(1, { "isOn": true }) |
| 🟢Herramienta | { "id": 1, "name": "Table Lamp", "isOn": true, "brightness": 100, "hex": "FF0000" } |
| 🔴Asistente | La lámpara está ahora activada |
Pero, ¿qué ocurre si el usuario no conoce el identificador de la luz? ¿O qué ocurre si el usuario quiere encender todas las luces? Aquí es donde entra en acción la planificación. Los modelos LLM de hoy en día son capaces de llamar a funciones iterativamente para resolver la necesidad de un usuario. Esto se logra mediante la creación de un bucle de comentarios en el que la inteligencia artificial puede llamar a una función, comprobar el resultado y, a continuación, decidir qué hacer a continuación.
Por ejemplo, un usuario puede pedir a la inteligencia artificial que "alterne" una bombilla. La inteligencia artificial primero tendría que comprobar el estado de la bombilla antes de decidir si se activará o desactivará.
| Role | Mensaje |
|---|---|
| 🔵User | Por favor, alterna todas las luces |
| 🔴Asistente (llamada de función) | Lights.get_lights() |
| 🟢Herramienta | { "lights": [ { "id": 1, "name": "Table Lamp", "isOn": true, "brightness": 100, "hex": "FF0000" }, { "id": 2, "name": "Ceiling Light", "isOn": false, "brightness": 0, "hex": "FFFFFF" } ] } |
| 🔴Asistente (llamada de función) | Lights.change_state(1, { "isOn": false }) Lights.change_state(2, { "isOn": true }) |
| 🟢Herramienta | { "id": 1, "name": "Table Lamp", "isOn": false, "brightness": 0, "hex": "FFFFFF" } |
| 🟢Herramienta | { "id": 2, "name": "Ceiling Light", "isOn": true, "brightness": 100, "hex": "FF0000" } |
| 🔴Asistente | Las luces se han activado |
Nota:
En este ejemplo, también ha visto llamadas a funciones paralelas. Aquí es donde la inteligencia artificial puede llamar a varias funciones al mismo tiempo. Se trata de una característica eficaz que puede ayudar a la inteligencia artificial a resolver tareas complejas con mayor rapidez. Se agregó a los modelos openAI en 1106.
Bucle de planeación automática
Admitir llamadas a funciones sin kernel semántico es relativamente compleja. Tendría que escribir un bucle que lograra lo siguiente:
- Creación de esquemas JSON para cada una de las funciones
- Proporcionar el LLM con los esquemas de función y historial de chat anteriores
- Analizar la respuesta de LLM para determinar si quiere responder con un mensaje o llamar a una función
- Si LLM quiere llamar a una función, tendría que analizar el nombre de la función y los parámetros de la respuesta de LLM.
- Invocación de la función con los parámetros correctos
- Devuelve los resultados de la función para que LLM pueda determinar lo que debe hacer a continuación.
- Repita los pasos del 2 al 6 hasta que LLM decida que ha completado la tarea o necesita ayuda del usuario.
En kernel semántico, facilitamos el uso de llamadas a funciones mediante la automatización de este bucle automáticamente. Esto le permite centrarse en la creación de los complementos necesarios para resolver las necesidades del usuario.
Nota:
Comprender cómo funciona el bucle de llamada de funciones es esencial para crear agentes de inteligencia artificial confiables y eficaces. Para obtener información detallada sobre cómo funciona el bucle, consulte el artículo llamada a funciones.
Uso de llamadas automáticas a funciones
Para usar llamadas automáticas a funciones en kernel semántico, debe hacer lo siguiente:
- Registro del complemento con el kernel
- Creación de un objeto de configuración de ejecución que indica a la inteligencia artificial que llame automáticamente a funciones
- Invocación del servicio de finalización de chat con el historial de chat y el kernel
using System.ComponentModel;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Connectors.OpenAI;
// 1. Create the kernel with the Lights plugin
var builder = Kernel.CreateBuilder().AddAzureOpenAIChatCompletion(modelId, endpoint, apiKey);
builder.Plugins.AddFromType<LightsPlugin>("Lights");
Kernel kernel = builder.Build();
var chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();
// 2. Enable automatic function calling
OpenAIPromptExecutionSettings openAIPromptExecutionSettings = new()
{
ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions
};
var history = new ChatHistory();
string? userInput;
do {
// Collect user input
Console.Write("User > ");
userInput = Console.ReadLine();
// Add user input
history.AddUserMessage(userInput);
// 3. Get the response from the AI with automatic function calling
var result = await chatCompletionService.GetChatMessageContentAsync(
history,
executionSettings: openAIPromptExecutionSettings,
kernel: kernel);
// Print the results
Console.WriteLine("Assistant > " + result);
// Add the message from the agent to the chat history
history.AddMessage(result.Role, result.Content ?? string.Empty);
} while (userInput is not null)
import asyncio
from semantic_kernel import Kernel
from semantic_kernel.functions import kernel_function
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.connectors.ai.function_call_behavior import FunctionCallBehavior
from semantic_kernel.connectors.ai.chat_completion_client_base import ChatCompletionClientBase
from semantic_kernel.contents.chat_history import ChatHistory
from semantic_kernel.functions.kernel_arguments import KernelArguments
from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
AzureChatPromptExecutionSettings,
)
async def main():
# 1. Create the kernel with the Lights plugin
kernel = Kernel()
kernel.add_service(AzureChatCompletion(
deployment_name="your_models_deployment_name",
api_key="your_api_key",
base_url="your_base_url",
))
kernel.add_plugin(
LightsPlugin(),
plugin_name="Lights",
)
chat_completion : AzureChatCompletion = kernel.get_service(type=ChatCompletionClientBase)
# 2. Enable automatic function calling
execution_settings = AzureChatPromptExecutionSettings(tool_choice="auto")
execution_settings.function_call_behavior = FunctionCallBehavior.EnableFunctions(auto_invoke=True, filters={})
# Create a history of the conversation
history = ChatHistory()
userInput = None
while True:
# Collect user input
userInput = input("User > ")
# Terminate the loop if the user says "exit"
if userInput == "exit":
break
# Add user input to the history
history.add_user_message(userInput)
# 3. Get the response from the AI with automatic function calling
result = (await chat_completion.get_chat_message_contents(
chat_history=history,
settings=execution_settings,
kernel=kernel,
arguments=KernelArguments(),
))[0]
# Print the results
print("Assistant > " + str(result))
# Add the message from the agent to the chat history
history.add_message(result)
# Run the main function
if __name__ == "__main__":
asyncio.run(main())
Cuando se usa la llamada automática a funciones, todos los pasos del bucle de planeación automática se controlan automáticamente y se agregan al ChatHistory objeto . Una vez completado el bucle de llamada de función, puede inspeccionar el ChatHistory objeto para ver todas las llamadas de función realizadas y los resultados proporcionados por kernel semántico.
¿Qué ocurre con las funciones que llaman paso a paso y los planificadores de handlebars?
Los planificadores Stepwise y Handlebars siguen estando disponibles en kernel semántico. Sin embargo, se recomienda usar la llamada de función para la mayoría de las tareas, ya que es más eficaz y fácil de usar. Los planificadores Stepwise y Handlebars quedarán en desuso en una versión futura del kernel semántico.
Antes de dejar de usar estos planificadores, proporcionaremos instrucciones sobre cómo migrar los planificadores existentes a las llamadas a funciones. Si tiene alguna pregunta sobre este proceso, póngase en contacto con nosotros en el panel de discusiones del repositorio de GitHub de kernel semántico.
Precaución
Si va a crear un nuevo agente de IA, se recomienda no usar los planificadores Stepwise o Handlebars. En su lugar, use la llamada de función, ya que es más eficaz y fácil de usar.
Pasos siguientes
Ahora que comprende cómo funcionan los planificadores en kernel semántico, puede obtener más información sobre cómo influyen el agente de IA para que planeen y ejecuten las tareas en nombre de los usuarios.