Exploración de la colaboración del agente en el chat del agente (experimental)
Advertencia
El marco del agente de kernel semántico es experimental, todavía en desarrollo y está sujeto a cambios.
La documentación detallada de la API relacionada con esta discusión está disponible en:
Los agentes no están disponibles actualmente en Java.
¿Qué es El chat del agente?
El chat del agente proporciona un marco que permite la interacción entre varios agentes, incluso si son de tipos diferentes. Esto permite que un agente de finalización de chat y un agente de Open AI Assistant funcionen juntos dentro de la misma conversación. Chat del agente también define puntos de entrada para iniciar la colaboración entre agentes, ya sea a través de varias respuestas o una respuesta de agente único.
Como clase abstracta, Agent Chat se puede subclasar para admitir escenarios personalizados.
Una de estas subclases, Chat de grupo de agentes, ofrece una implementación concreta del chat del agente, mediante un enfoque basado en estrategia para administrar la dinámica de conversación.
Creación de un chat de grupo de agentes
Para crear un chat de grupo de agentes, puede especificar los agentes participantes o crear un chat vacío y, posteriormente, agregar participantes del agente. La configuración de la configuración del chat y las estrategias también se realiza durante la inicialización del chat de grupo de agentes. Esta configuración define cómo funcionará la dinámica de conversación dentro del grupo.
Nota: La configuración de chat predeterminada da como resultado una conversación limitada a una única respuesta. Consulte Comportamiento del chat del agente para obtener más información sobre cómo configurar _Chat-Settings.
Crear chat de grupo de agentes con agentes:
// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;
// Create chat with participating agents.
AgentGroupChat chat = new(agent1, agent2);
# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)
# Create chat with participating agents
chat = AgentGroupChat(agents=[agent1, agent2])
Los agentes no están disponibles actualmente en Java.
Agregar agentes a un chat de grupo de agentes:
// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;
// Create an empty chat.
AgentGroupChat chat = new();
// Add agents to an existing chat.
chat.AddAgent(agent1);
chat.AddAgent(agent2);
# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)
# Create an empty chat
chat = AgentGroupChat()
# Add agents to an existing chat
chat.add_agent(agent=agent1)
chat.add_agent(agent=agent2)
Los agentes no están disponibles actualmente en Java.
Uso del chat de grupo de agentes
El chat del agente admite dos modos de funcionamiento: Single-Turn y Multi-Turn. A su vez, se designa un agente específico para proporcionar una respuesta. A su vez, todos los agentes de la conversación toman turnos respondiendo hasta que se cumpla un criterio de terminación. En ambos modos, los agentes pueden colaborar respondiendo entre sí para lograr un objetivo definido.
Proporcionar entrada
Agregar un mensaje de entrada a un chat del agente sigue el mismo patrón que un objeto Historial de chat .
AgentGroupChat chat = new();
chat.AddChatMessage(new ChatMessageContent(AuthorRole.User, "<message content>"));
chat = AgentGroupChat()
await chat.add_chat_message(ChatMessageContent(role=AuthorRole.USER, content="<message content>"))
Los agentes no están disponibles actualmente en Java.
Invocación de agente de un solo turno
En una invocación multiturno, el sistema debe decidir qué agente responde a continuación y cuándo debe finalizar la conversación. En cambio, una invocación de un solo turno simplemente devuelve una respuesta del agente especificado, lo que permite al autor de la llamada administrar directamente la participación del agente.
Una vez que un agente participa en el chat del agente a través de una invocación de un solo turno, se agrega al conjunto de agentes aptos para la invocación de varios turnos.
// Define an agent
ChatCompletionAgent agent = ...;
// Create an empty chat.
AgentGroupChat chat = new();
// Invoke an agent for its response
ChatMessageContent[] messages = await chat.InvokeAsync(agent).ToArrayAsync();
# Define an agent
agent = ChatCompletionAgent(...)
# Create an empty chat
chat = AgentGroupChat()
# Invoke an agent for its response(s)
async for message in chat.invoke(agent)
# process message response(s)
Los agentes no están disponibles actualmente en Java.
Invocación del agente de varios turnos
Aunque la colaboración del agente requiere que haya un sistema en vigor que no solo determine qué agente debe responder durante cada turno, sino que también evalúa cuándo la conversación ha alcanzado su objetivo previsto, iniciar la colaboración multiturno sigue siendo sencilla.
Las respuestas del agente se devuelven de forma asincrónica a medida que se generan, lo que permite que la conversación se desarrolle en tiempo real.
Nota: En las secciones siguientes, selección del agente y finalización del chat, profundizará en la configuración de ejecución en detalle. La configuración de ejecución predeterminada emplea la selección secuencial o round robin y limita la participación del agente a un solo turno.
API de configuración de ejecución de .NET:AgentGroupChatSettings
// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;
// Create chat with participating agents.
AgentGroupChat chat =
new(agent1, agent2)
{
// Override default execution settings
ExecutionSettings =
{
TerminationStrategy = { MaximumIterations = 10 }
}
};
// Invoke agents
await foreach (ChatMessageContent response in chat.InvokeAsync())
{
// Process agent response(s)...
}
# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)
# Create chat with participating agents
chat = AgentGroupChat(
agents=[agent1, agent2],
termination_strategy=DefaultTerminationStrategy(maximum_iterations=10),
)
async for response in chat.invoke():
# process agent response(s)
Los agentes no están disponibles actualmente en Java.
Acceso al historial de chats
El historial de conversaciones de Chat del agente siempre es accesible, aunque los mensajes se entreguen a través del patrón de invocación. Esto garantiza que los intercambios anteriores permanezcan disponibles en toda la conversación.
Nota: El mensaje más reciente se proporciona primero (orden descendente: más reciente al más antiguo).
// Define and use a chat
AgentGroupChat chat = ...;
// Access history for a previously utilized AgentGroupChat
ChatMessageContent[] history = await chat.GetChatMessagesAsync().ToArrayAsync();
# Define a group chat
chat = AgentGroupChat(...)
# Access history for a previously utilized AgentGroupChat
history = await chat.get_chat_messages()
Los agentes no están disponibles actualmente en Java.
Dado que diferentes tipos de agente o configuraciones pueden mantener su propia versión del historial de conversaciones, el historial específico del agente también está disponible especificando un agente. (Por ejemplo: Abra ai Assistant frente al agente de finalización de chat).
// Agents to participate in chat
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;
// Define a group chat
AgentGroupChat chat = ...;
// Access history for a previously utilized AgentGroupChat
ChatMessageContent[] history1 = await chat.GetChatMessagesAsync(agent1).ToArrayAsync();
ChatMessageContent[] history2 = await chat.GetChatMessagesAsync(agent2).ToArrayAsync();
# Agents to participate in a chat
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)
# Define a group chat
chat = AgentGroupChat(...)
# Access history for a previously utilized AgentGroupChat
history1 = await chat.get_chat_messages(agent=agent1)
history2 = await chat.get_chat_messages(agent=agent2)
Los agentes no están disponibles actualmente en Java.
Definición del comportamiento del chat de grupo de agentes
La colaboración entre agentes para resolver tareas complejas es un patrón agente principal. Para usar este patrón de forma eficaz, un sistema debe estar en vigor que no solo determina qué agente debe responder durante cada turno, sino que también evalúa cuándo la conversación ha alcanzado su objetivo previsto. Esto requiere la administración de la selección del agente y el establecimiento de criterios claros para la terminación de la conversación, lo que garantiza una cooperación sin problemas entre los agentes hacia una solución. Ambos aspectos se rigen por la propiedad Configuración de ejecución.
En las secciones siguientes, selección del agente y finalización del chat, se profundizarán en estas consideraciones con detalle.
Selección del agente
En la invocación multiturno, la selección del agente se guía por una estrategia de selección. Esta estrategia se define mediante una clase base que se puede ampliar para implementar comportamientos personalizados adaptados a necesidades específicas. Para mayor comodidad, también hay disponibles dos estrategias de selección concretas predefinidas, que ofrecen enfoques listos para usar para controlar la selección del agente durante las conversaciones.
Si se conoce, se puede especificar un agente inicial para tomar siempre el primer turno. También se puede emplear un reductor de historial para limitar el uso de tokens cuando se usa una estrategia basada en una función de kernel.
API de estrategia de selección de .NET:
SelectionStrategySequentialSelectionStrategyKernelFunctionSelectionStrategyMicrosoft.SemanticKernel.Agents.History
// Define the agent names for use in the function template
const string WriterName = "Writer";
const string ReviewerName = "Reviewer";
// Initialize a Kernel with a chat-completion service
Kernel kernel = ...;
// Create the agents
ChatCompletionAgent writerAgent =
new()
{
Name = WriterName,
Instructions = "<writer instructions>",
Kernel = kernel
};
ChatCompletionAgent reviewerAgent =
new()
{
Name = ReviewerName,
Instructions = "<reviewer instructions>",
Kernel = kernel
};
// Define a kernel function for the selection strategy
KernelFunction selectionFunction =
AgentGroupChat.CreatePromptFunctionForStrategy(
$$$"""
Determine which participant takes the next turn in a conversation based on the the most recent participant.
State only the name of the participant to take the next turn.
No participant should take more than one turn in a row.
Choose only from these participants:
- {{{ReviewerName}}}
- {{{WriterName}}}
Always follow these rules when selecting the next participant:
- After {{{WriterName}}}, it is {{{ReviewerName}}}'s turn.
- After {{{ReviewerName}}}, it is {{{WriterName}}}'s turn.
History:
{{$history}}
""",
safeParameterNames: "history");
// Define the selection strategy
KernelFunctionSelectionStrategy selectionStrategy =
new(selectionFunction, kernel)
{
// Always start with the writer agent.
InitialAgent = writerAgent,
// Parse the function response.
ResultParser = (result) => result.GetValue<string>() ?? WriterName,
// The prompt variable name for the history argument.
HistoryVariableName = "history",
// Save tokens by not including the entire history in the prompt
HistoryReducer = new ChatHistoryTruncationReducer(3),
};
// Create a chat using the defined selection strategy.
AgentGroupChat chat =
new(writerAgent, reviewerAgent)
{
ExecutionSettings = new() { SelectionStrategy = selectionStrategy }
};
REVIEWER_NAME = "Reviewer"
WRITER_NAME = "Writer"
agent_reviewer = ChatCompletionAgent(
service_id=REVIEWER_NAME,
kernel=kernel,
name=REVIEWER_NAME,
instructions="<instructions>",
)
agent_writer = ChatCompletionAgent(
service_id=WRITER_NAME,
kernel=kernel,
name=WRITER_NAME,
instructions="<instructions>",
)
selection_function = KernelFunctionFromPrompt(
function_name="selection",
prompt=f"""
Determine which participant takes the next turn in a conversation based on the the most recent participant.
State only the name of the participant to take the next turn.
No participant should take more than one turn in a row.
Choose only from these participants:
- {REVIEWER_NAME}
- {WRITER_NAME}
Always follow these rules when selecting the next participant:
- After user input, it is {WRITER_NAME}'s turn.
- After {WRITER_NAME} replies, it is {REVIEWER_NAME}'s turn.
- After {REVIEWER_NAME} provides feedback, it is {WRITER_NAME}'s turn.
History:
{{{{$history}}}}
""",
)
chat = AgentGroupChat(
agents=[agent_writer, agent_reviewer],
selection_strategy=KernelFunctionSelectionStrategy(
function=selection_function,
kernel=_create_kernel_with_chat_completion("selection"),
result_parser=lambda result: str(result.value[0]) if result.value is not None else COPYWRITER_NAME,
agent_variable_name="agents",
history_variable_name="history",
),
)
Los agentes no están disponibles actualmente en Java.
Finalización del chat
En la invocación multiturno , la estrategia de terminación determina cuándo tiene lugar el turno final. Esta estrategia garantiza que la conversación finalice en el punto adecuado.
Esta estrategia se define mediante una clase base que se puede ampliar para implementar comportamientos personalizados adaptados a necesidades específicas. Para mayor comodidad, las estrategias de selección predefinidas de servidor también están disponibles, ofreciendo enfoques listos para usar para definir criterios de terminación para las conversaciones de chat del agente.
API de estrategia de selección de .NET:
TerminationStrategyRegexTerminationStrategyKernelFunctionSelectionStrategyKernelFunctionTerminationStrategyAggregatorTerminationStrategyMicrosoft.SemanticKernel.Agents.History
// Initialize a Kernel with a chat-completion service
Kernel kernel = ...;
// Create the agents
ChatCompletionAgent writerAgent =
new()
{
Name = "Writer",
Instructions = "<writer instructions>",
Kernel = kernel
};
ChatCompletionAgent reviewerAgent =
new()
{
Name = "Reviewer",
Instructions = "<reviewer instructions>",
Kernel = kernel
};
// Define a kernel function for the selection strategy
KernelFunction terminationFunction =
AgentGroupChat.CreatePromptFunctionForStrategy(
$$$"""
Determine if the reviewer has approved. If so, respond with a single word: yes
History:
{{$history}}
""",
safeParameterNames: "history");
// Define the termination strategy
KernelFunctionTerminationStrategy terminationStrategy =
new(selectionFunction, kernel)
{
// Only the reviewer may give approval.
Agents = [reviewerAgent],
// Parse the function response.
ResultParser = (result) =>
result.GetValue<string>()?.Contains("yes", StringComparison.OrdinalIgnoreCase) ?? false,
// The prompt variable name for the history argument.
HistoryVariableName = "history",
// Save tokens by not including the entire history in the prompt
HistoryReducer = new ChatHistoryTruncationReducer(1),
// Limit total number of turns no matter what
MaximumIterations = 10,
};
// Create a chat using the defined termination strategy.
AgentGroupChat chat =
new(writerAgent, reviewerAgent)
{
ExecutionSettings = new() { TerminationStrategy = terminationStrategy }
};
REVIEWER_NAME = "Reviewer"
WRITER_NAME = "Writer"
agent_reviewer = ChatCompletionAgent(
service_id=REVIEWER_NAME,
kernel=kernel,
name=REVIEWER_NAME,
instructions="<instructions>",
)
agent_writer = ChatCompletionAgent(
service_id=WRITER_NAME,
kernel=kernel,
name=WRITER_NAME,
instructions="<instructions>",
)
termination_function = KernelFunctionFromPrompt(
function_name="termination",
prompt="""
Determine if the copy has been approved. If so, respond with a single word: yes
History:
{{$history}}
""",
)
chat = AgentGroupChat(
agents=[agent_writer, agent_reviewer],
termination_strategy=KernelFunctionTerminationStrategy(
agents=[agent_reviewer],
function=termination_function,
kernel=_create_kernel_with_chat_completion("termination"),
result_parser=lambda result: str(result.value[0]).lower() == "yes",
history_variable_name="history",
maximum_iterations=10,
),
)
Los agentes no están disponibles actualmente en Java.
Restablecer el estado de finalización del chat
Independientemente de si se invoca Chat de grupo de agentes mediante el enfoque de un solo turno o multiturno, el estado del chat del grupo de agentes se actualiza para indicar que se completa una vez que se cumplen los criterios de terminación. Esto garantiza que el sistema reconozca cuando una conversación haya finalizado completamente. Para seguir usando una instancia de Chat de grupo de agentes una vez alcanzado el estado Completado , este estado debe restablecerse para permitir interacciones adicionales. Sin restablecer, no será posible realizar interacciones adicionales ni respuestas de agente.
En el caso de una invocación de varios turnos que alcance el límite máximo de turnos, el sistema interrumpirá la invocación del agente, pero no marcará la instancia como completada. Esto permite la posibilidad de extender la conversación sin necesidad de restablecer el estado finalización .
// Define an use chat
AgentGroupChat chat = ...;
// Evaluate if completion is met and reset.
if (chat.IsComplete)
{
// Opt to take action on the chat result...
// Reset completion state to continue use
chat.IsComplete = false;
}
# Define a group chat
chat = AgentGroupChat()
# Evaluate if completion is met and reset
if chat.is_complete:
# Reset completion state to continue use
chat.is_complete = False
Los agentes no están disponibles actualmente en Java.
Borrar el estado de conversación completa
Cuando haya terminado de usar un chat del agente en el que participó open AI Assistant, puede ser necesario eliminar el subproceso remoto asociado al asistente. El chat del agente admite el restablecimiento o desactivación del estado de conversación completo, que incluye eliminar cualquier definición de subproceso remoto. Esto garantiza que no se mantenga ningún dato de conversación residual vinculado al asistente una vez que finalice el chat.
Un restablecimiento completo no quita los agentes que se habían unido al chat del agente y deja el chat del agente en un estado en el que se puede reutilizar. Esto permite la continuación de las interacciones con los mismos agentes sin necesidad de reinicializarlas, lo que hace que las conversaciones futuras sean más eficaces.
// Define an use chat
AgentGroupChat chat = ...;
// Clear the all conversation state
await chat.ResetAsync();
# Define a group chat
chat = AgentGroupChat()
# Clear the conversation state
await chat.reset()
Los agentes no están disponibles actualmente en Java.
Procedimiento
Para obtener un ejemplo de un extremo a otro para usar el chat de grupo de agentes para la colaboración del agente , consulte: