ai-agents-for-beginners

Exploring AI Agent Frameworks

(Haz clic en la imagen de arriba para ver el video de esta lección)

Explorar frameworks de agentes de IA

Los frameworks de agentes de IA son plataformas de software diseñadas para simplificar la creación, despliegue y gestión de agentes de IA. Estos frameworks proporcionan a los desarrolladores componentes preconstruidos, abstracciones y herramientas que agilizan el desarrollo de sistemas de IA complejos.

Estos frameworks ayudan a los desarrolladores a centrarse en los aspectos únicos de sus aplicaciones al proporcionar enfoques estandarizados para desafíos comunes en el desarrollo de agentes de IA. Mejoran la escalabilidad, accesibilidad y eficiencia en la construcción de sistemas de IA.

Introducción

Esta lección cubrirá:

Objetivos de aprendizaje

Los objetivos de esta lección son ayudarte a entender:

¿Qué son los frameworks de agentes de IA y qué permiten hacer a los desarrolladores?

Los frameworks tradicionales de IA pueden ayudarte a integrar IA en tus aplicaciones y mejorar estas aplicaciones de las siguientes maneras:

Todo eso suena genial, ¿entonces por qué necesitamos el framework de agentes de IA?

Los frameworks de agentes de IA representan algo más que simples frameworks de IA. Están diseñados para posibilitar la creación de agentes inteligentes que pueden interactuar con usuarios, otros agentes y el entorno para alcanzar objetivos específicos. Estos agentes pueden mostrar comportamiento autónomo, tomar decisiones y adaptarse a condiciones cambiantes. Veamos algunas capacidades clave habilitadas por los frameworks de agentes de IA:

En resumen, los agentes te permiten hacer más, llevar la automatización al siguiente nivel y crear sistemas más inteligentes que pueden adaptarse y aprender de su entorno.

¿Cómo prototipar rápidamente, iterar y mejorar las capacidades del agente?

Este es un panorama que avanza rápidamente, pero hay algunas cosas comunes en la mayoría de los frameworks de agentes de IA que pueden ayudarte a prototipar e iterar rápidamente, a saber: componentes modulares, herramientas colaborativas y aprendizaje en tiempo real. Vamos a profundizar en esto:

Usar componentes modulares

SDKs como Microsoft Semantic Kernel y LangChain ofrecen componentes preconstruidos como conectores de IA, plantillas de prompt y gestión de memoria.

Cómo pueden usar esto los equipos: Los equipos pueden ensamblar rápidamente estos componentes para crear un prototipo funcional sin comenzar desde cero, lo que permite experimentación e iteración rápidas.

Cómo funciona en la práctica: Puedes usar un parser preconstruido para extraer información de la entrada del usuario, un módulo de memoria para almacenar y recuperar datos, y un generador de prompts para interactuar con los usuarios, todo sin tener que construir estos componentes desde cero.

Código de ejemplo. Veamos ejemplos de cómo puedes usar un conector de IA preconstruido con Semantic Kernel en Python y .Net que usa llamadas automáticas a funciones para que el modelo responda a la entrada del usuario:

# Ejemplo de Semantic Kernel en Python

import asyncio
from typing import Annotated

from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistory
from semantic_kernel.functions import kernel_function
from semantic_kernel.kernel import Kernel

# Definir un objeto ChatHistory para mantener el contexto de la conversación
chat_history = ChatHistory()
chat_history.add_user_message("I'd like to go to New York on January 1, 2025")


# Definir un plugin de ejemplo que contiene la función para reservar viajes
class BookTravelPlugin:
    """A Sample Book Travel Plugin"""

    @kernel_function(name="book_flight", description="Book travel given location and date")
    async def book_flight(
        self, date: Annotated[str, "The date of travel"], location: Annotated[str, "The location to travel to"]
    ) -> str:
        return f"Travel was booked to {location} on {date}"

# Crear el Kernel
kernel = Kernel()

# Añadir el plugin de ejemplo al objeto Kernel
kernel.add_plugin(BookTravelPlugin(), plugin_name="book_travel")

# Definir el Conector AI de Azure OpenAI
chat_service = AzureChatCompletion(
    deployment_name="YOUR_DEPLOYMENT_NAME", 
    api_key="YOUR_API_KEY", 
    endpoint="https://<your-resource>.azure.openai.com/",
)

# Definir la configuración de la solicitud para configurar el modelo con llamada automática a funciones
request_settings = AzureChatPromptExecutionSettings(function_choice_behavior=FunctionChoiceBehavior.Auto())


async def main():
    # Realizar la solicitud al modelo para el historial de chat y configuración de solicitud dados
    # El Kernel contiene el ejemplo que el modelo solicitará invocar
    response = await chat_service.get_chat_message_content(
        chat_history=chat_history, settings=request_settings, kernel=kernel
    )
    assert response is not None

    """
    Note: In the auto function calling process, the model determines it can invoke the 
    `BookTravelPlugin` using the `book_flight` function, supplying the necessary arguments. 
    
    For example:

    "tool_calls": [
        {
            "id": "call_abc123",
            "type": "function",
            "function": {
                "name": "BookTravelPlugin-book_flight",
                "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
            }
        }
    ]

    Since the location and date arguments are required (as defined by the kernel function), if the 
    model lacks either, it will prompt the user to provide them. For instance:

    User: Book me a flight to New York.
    Model: Sure, I'd love to help you book a flight. Could you please specify the date?
    User: I want to travel on January 1, 2025.
    Model: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels!
    """

    print(f"`{response}`")
    # Ejemplo de Respuesta del Modelo AI: `Tu vuelo a Nueva York el 1 de enero de 2025 ha sido reservado con éxito. ¡Buen viaje! ✈️🗽`

    # Añadir la respuesta del modelo a nuestro contexto de historial de chat
    chat_history.add_assistant_message(response.content)


if __name__ == "__main__":
    asyncio.run(main())

// Semantic Kernel C# example

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using System.ComponentModel;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;

ChatHistory chatHistory = [];
chatHistory.AddUserMessage("I'd like to go to New York on January 1, 2025");

var kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.AddAzureOpenAIChatCompletion(
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType<BookTravelPlugin>("BookTravel"); 
var kernel = kernelBuilder.Build();

var settings = new AzureOpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

var chatCompletion = kernel.GetRequiredService<IChatCompletionService>();

var response = await chatCompletion.GetChatMessageContentAsync(chatHistory, settings, kernel);

/*
Behind the scenes, the model recognizes the tool to call, what arguments it already has (location) and (date)
{

"tool_calls": [
    {
        "id": "call_abc123",
        "type": "function",
        "function": {
            "name": "BookTravelPlugin-book_flight",
            "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
        }
    }
]
*/

Console.WriteLine(response.Content);
chatHistory.AddMessage(response!.Role, response!.Content!);

// Example AI Model Response: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽

// Define a plugin that contains the function to book travel
public class BookTravelPlugin
{
    [KernelFunction("book_flight")]
    [Description("Book travel given location and date")]
    public async Task<string> BookFlight(DateTime date, string location)
    {
        return await Task.FromResult( $"Travel was booked to {location} on {date}");
    }
}

Lo que puedes ver en este ejemplo es cómo puedes aprovechar un parser preconstruido para extraer información clave de la entrada del usuario, como el origen, el destino y la fecha de una solicitud de reserva de vuelo. Este enfoque modular te permite centrarte en la lógica de alto nivel.

Aprovechar herramientas colaborativas

Frameworks como CrewAI, Microsoft AutoGen y Semantic Kernel facilitan la creación de múltiples agentes que pueden trabajar juntos.

Cómo pueden usar esto los equipos: Los equipos pueden diseñar agentes con roles y tareas específicas, permitiéndoles probar y refinar flujos de trabajo colaborativos y mejorar la eficiencia general del sistema.

Cómo funciona en la práctica: Puedes crear un equipo de agentes donde cada agente tiene una función especializada, como recuperación de datos, análisis o toma de decisiones. Estos agentes pueden comunicarse y compartir información para alcanzar un objetivo común, como responder a una consulta de un usuario o completar una tarea.

Código de ejemplo (AutoGen):

# creando agentes, luego crear un calendario de ronda robin donde puedan trabajar juntos, en este caso en orden

# Agente de Recuperación de Datos
# Agente de Análisis de Datos
# Agente de Toma de Decisiones

agent_retrieve = AssistantAgent(
    name="dataretrieval",
    model_client=model_client,
    tools=[retrieve_tool],
    system_message="Use tools to solve tasks."
)

agent_analyze = AssistantAgent(
    name="dataanalysis",
    model_client=model_client,
    tools=[analyze_tool],
    system_message="Use tools to solve tasks."
)

# la conversación termina cuando el usuario dice "APROBAR"
termination = TextMentionTermination("APPROVE")

user_proxy = UserProxyAgent("user_proxy", input_func=input)

team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)

stream = team.run_stream(task="Analyze data", max_turns=10)
# Use asyncio.run(...) al ejecutar en un script.
await Console(stream)

Lo que ves en el código anterior es cómo puedes crear una tarea que implica a múltiples agentes trabajando juntos para analizar datos. Cada agente realiza una función específica y la tarea se ejecuta coordinando a los agentes para alcanzar el resultado deseado. Al crear agentes dedicados con roles especializados, puedes mejorar la eficiencia y el rendimiento de las tareas.

Aprender en tiempo real

Los frameworks avanzados ofrecen capacidades para la comprensión contextual y la adaptación en tiempo real.

Cómo pueden usar esto los equipos: Los equipos pueden implementar bucles de retroalimentación donde los agentes aprenden de las interacciones y ajustan su comportamiento dinámicamente, lo que conduce a una mejora continua y refinamiento de capacidades.

Cómo funciona en la práctica: Los agentes pueden analizar la retroalimentación de los usuarios, datos ambientales y resultados de tareas para actualizar su base de conocimientos, ajustar algoritmos de toma de decisiones y mejorar el rendimiento con el tiempo. Este proceso de aprendizaje iterativo permite que los agentes se adapten a condiciones cambiantes y a las preferencias de los usuarios, mejorando la efectividad general del sistema.

¿Cuáles son las diferencias entre los frameworks AutoGen, Semantic Kernel y Azure AI Agent Service?

Hay muchas formas de comparar estos frameworks, pero veamos algunas diferencias clave en términos de su diseño, capacidades y casos de uso objetivo:

AutoGen

AutoGen es un framework de código abierto desarrollado por el AI Frontiers Lab de Microsoft Research. Se centra en aplicaciones agentic distribuidas y dirigidas por eventos, permitiendo múltiples LLMs y SLMs, herramientas y patrones avanzados de diseño multiagente.

AutoGen se construye alrededor del concepto central de agentes, que son entidades autónomas que pueden percibir su entorno, tomar decisiones y realizar acciones para lograr objetivos específicos. Los agentes se comunican a través de mensajes asincrónicos, lo que les permite trabajar de forma independiente y en paralelo, mejorando la escalabilidad y la capacidad de respuesta del sistema.

Los agentes se basan en el modelo actor. Según Wikipedia, un actor es la unidad básica de la computación concurrente. En respuesta a un mensaje que recibe, un actor puede: tomar decisiones locales, crear más actores, enviar más mensajes y determinar cómo responder al siguiente mensaje recibido.

Casos de uso: Automatización de generación de código, tareas de análisis de datos y construcción de agentes personalizados para funciones de planificación e investigación.

Aquí hay algunos conceptos centrales importantes de AutoGen:

Semantic Kernel + Agent Framework

Semantic Kernel es un SDK de orquestación de IA listo para empresas. Consiste en conectores de IA y de memoria, junto con un Agent Framework.

Primero cubramos algunos componentes centrales:

Así que esos son los conceptos básicos del framework Semantic Kernel, ¿y qué pasa con el Agent Framework?

Azure AI Agent Service

Azure AI Agent Service es una incorporación más reciente, introducida en Microsoft Ignite 2024. Permite el desarrollo y despliegue de agentes de IA con modelos más flexibles, como llamar directamente a LLMs de código abierto como Llama 3, Mistral y Cohere.

Azure AI Agent Service proporciona mecanismos de seguridad empresarial más robustos y métodos de almacenamiento de datos, lo que lo hace adecuado para aplicaciones empresariales.

Funciona de forma inmediata con frameworks de orquestación multiagente como AutoGen y Semantic Kernel.

Este servicio está actualmente en Public Preview y admite Python y C# para la creación de agentes.

Usando Semantic Kernel Python, podemos crear un Azure AI Agent con un complemento definido por el usuario:

import asyncio
from typing import Annotated

from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings, AzureAIAgentThread
from semantic_kernel.contents import ChatMessageContent
from semantic_kernel.contents import AuthorRole
from semantic_kernel.functions import kernel_function


# Definir un complemento de ejemplo para la muestra
class MenuPlugin:
    """A sample Menu Plugin used for the concept sample."""

    @kernel_function(description="Provides a list of specials from the menu.")
    def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
        return """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """

    @kernel_function(description="Provides the price of the requested menu item.")
    def get_item_price(
        self, menu_item: Annotated[str, "The name of the menu item."]
    ) -> Annotated[str, "Returns the price of the menu item."]:
        return "$9.99"


async def main() -> None:
    ai_agent_settings = AzureAIAgentSettings.create()

    async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(
            credential=creds,
            conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
        ) as client,
    ):
        # Crear la definición del agente
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            name="Host",
            instructions="Answer questions about the menu.",
        )

        # Crear el Agente AzureAI usando el cliente definido y la definición del agente
        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[MenuPlugin()],
        )

        # Crear un hilo para mantener la conversación
        # Si no se proporciona un hilo, se creará uno nuevo
        # y se devolverá con la respuesta inicial
        thread: AzureAIAgentThread | None = None

        user_inputs = [
            "Hello",
            "What is the special soup?",
            "How much does that cost?",
            "Thank you",
        ]

        try:
            for user_input in user_inputs:
                print(f"# User: '{user_input}'")
                # Invocar al agente para el hilo especificado
                response = await agent.get_response(
                    messages=user_input,
                    thread_id=thread,
                )
                print(f"# {response.name}: {response.content}")
                thread = response.thread
        finally:
            await thread.delete() if thread else None
            await client.agents.delete_agent(agent.id)


if __name__ == "__main__":
    asyncio.run(main())

Conceptos clave

Azure AI Agent Service tiene los siguientes conceptos clave:

Use Cases: Azure AI Agent Service está diseñado para aplicaciones empresariales que requieren despliegue de agentes de IA seguro, escalable y flexible.

¿Cuál es la diferencia entre estos frameworks?

Parece que hay mucha superposición entre estos frameworks, pero hay algunas diferencias clave en términos de su diseño, capacidades y casos de uso objetivo:

¿Aún no estás seguro de cuál elegir?

Casos de uso

Veamos si podemos ayudarte pasando por algunos casos de uso comunes:

Q: I’m experimenting, learning and building proof-of-concept agent applications, and I want to be able to build and experiment quickly

A: AutoGen would be a good choice for this scenario, as it focuses on event-driven, distributed agentic applications and supports advanced multi-agent design patterns.

Q: What makes AutoGen a better choice than Semantic Kernel and Azure AI Agent Service for this use case?

A: AutoGen is specifically designed for event-driven, distributed agentic applications, making it well-suited for automating code generation and data analysis tasks. It provides the necessary tools and capabilities to build complex multi-agent systems efficiently.

Q: Sounds like Azure AI Agent Service could work here too, it has tools for code generation and more?

A: Yes, Azure AI Agent Service is a platform service for agents and add built-in capabilities for multiple models, Azure AI Search, Bing Search and Azure Functions. It makes it easy to build your agents in the Foundry Portal and deploy them at scale.

Q: I’m still confused just give me one option

A: A great choice is to build your application in Semantic Kernel first and then use Azure AI Agent Service to deploy your agent. This approach allows you to easily persist your agents while leveraging the power to build multi-agent systems in Semantic Kernel. Additionally, Semantic Kernel has a connector in AutoGen, making it easy to use both frameworks together.

Resumamos las diferencias clave en una tabla:

Framework Focus Core Concepts Use Cases
AutoGen Aplicaciones multiagente distribuidas y orientadas a eventos Agents, Personas, Functions, Data Generación de código, tareas de análisis de datos
Semantic Kernel Comprensión y generación de texto similar al humano Agents, Modular Components, Collaboration Comprensión del lenguaje natural, generación de contenido
Azure AI Agent Service Modelos flexibles, seguridad empresarial, generación de código, invocación de herramientas Modularity, Collaboration, Process Orchestration Despliegue de agentes de IA seguro, escalable y flexible

¿Cuál es el caso de uso ideal para cada uno de estos frameworks?

¿Puedo integrar directamente mis herramientas existentes del ecosistema Azure, o necesito soluciones independientes?

La respuesta es sí, puedes integrar tus herramientas existentes del ecosistema Azure directamente con Azure AI Agent Service especialmente, esto porque ha sido diseñado para funcionar sin problemas con otros servicios de Azure. Por ejemplo, podrías integrar Bing, Azure AI Search y Azure Functions. También hay una integración profunda con Microsoft Foundry.

Para AutoGen y Semantic Kernel, también puedes integrar con servicios de Azure, pero puede requerir que llames a los servicios de Azure desde tu código. Otra forma de integrar es usar los SDKs de Azure para interactuar con los servicios de Azure desde tus agentes. Además, como se mencionó, puedes usar Azure AI Agent Service como orquestador para tus agentes construidos en AutoGen o Semantic Kernel, lo que te daría un acceso sencillo al ecosistema Azure.

Ejemplos de código

¿Tienes más preguntas sobre los frameworks de agentes de IA?

Únete al Microsoft Foundry Discord para encontrarte con otros estudiantes, asistir a horas de oficina y obtener respuestas a tus preguntas sobre AI Agents.

Referencias

Previous Lesson

Introduction to AI Agents and Agent Use Cases

Next Lesson

Understanding Agentic Design Patterns

Descargo de responsabilidad: Este documento ha sido traducido mediante el servicio de traducción por IA Co-op Translator. Aunque nos esforzamos por la exactitud, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por un traductor humano. No nos hacemos responsables de ningún malentendido o interpretación errónea que surja del uso de esta traducción.

This site is open source. Improve this page.