ai-agents-for-beginners

Explorer les cadres d'agents IA

(Cliquez sur l’image ci-dessus pour visionner la vidéo de cette leçon)

Explorer les cadres d’agents IA

Les cadres d’agents IA sont des plateformes logicielles conçues pour simplifier la création, le déploiement et la gestion des agents IA. Ces cadres offrent aux développeurs des composants préconstruits, des abstractions et des outils qui facilitent le développement de systèmes IA complexes.

Ces cadres permettent aux développeurs de se concentrer sur les aspects uniques de leurs applications en proposant des approches standardisées pour relever les défis courants dans le développement d’agents IA. Ils améliorent la scalabilité, l’accessibilité et l’efficacité dans la construction de systèmes IA.

Introduction

Cette leçon couvrira :

Objectifs d’apprentissage

Les objectifs de cette leçon sont de vous aider à comprendre :

Qu’est-ce qu’un cadre d’agents IA et que permettent-ils aux développeurs de faire ?

Les cadres IA traditionnels peuvent vous aider à intégrer l’IA dans vos applications et à améliorer ces dernières de plusieurs façons :

Tout cela semble génial, alors pourquoi avons-nous besoin d’un cadre d’agents IA ?

Les cadres d’agents IA vont au-delà des simples cadres IA. Ils sont conçus pour permettre la création d’agents intelligents capables d’interagir avec les utilisateurs, d’autres agents et l’environnement pour atteindre des objectifs spécifiques. Ces agents peuvent adopter un comportement autonome, prendre des décisions et s’adapter à des conditions changeantes. Voici quelques capacités clés offertes par les cadres d’agents IA :

En résumé, les agents permettent d’aller plus loin, de pousser l’automatisation à un niveau supérieur, et de créer des systèmes plus intelligents capables de s’adapter et d’apprendre de leur environnement.

Comment prototyper rapidement, itérer et améliorer les capacités de l’agent ?

C’est un domaine en constante évolution, mais il existe des éléments communs à la plupart des cadres d’agents IA qui peuvent vous aider à prototyper et itérer rapidement, notamment les composants modulaires, les outils collaboratifs et l’apprentissage en temps réel. Explorons ces éléments :

Utiliser des composants modulaires

Les SDK comme Microsoft Semantic Kernel et LangChain offrent des composants préconstruits tels que des connecteurs IA, des modèles de prompts et une gestion de la mémoire.

Comment les équipes peuvent les utiliser : Les équipes peuvent assembler rapidement ces composants pour créer un prototype fonctionnel sans partir de zéro, permettant ainsi une expérimentation et une itération rapides.

Comment cela fonctionne en pratique : Vous pouvez utiliser un analyseur préconstruit pour extraire des informations des entrées utilisateur, un module mémoire pour stocker et récupérer des données, et un générateur de prompts pour interagir avec les utilisateurs, le tout sans avoir à construire ces composants à partir de zéro.

Exemple de code. Voici des exemples d’utilisation d’un connecteur IA préconstruit avec Semantic Kernel en Python et .Net qui utilise des appels de fonctions automatiques pour que le modèle réponde aux entrées utilisateur :

# Semantic Kernel Python Example

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

# Define a ChatHistory object to hold the conversation's context
chat_history = ChatHistory()
chat_history.add_user_message("I'd like to go to New York on January 1, 2025")


# Define a sample plugin that contains the function to book travel
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}"

# Create the Kernel
kernel = Kernel()

# Add the sample plugin to the Kernel object
kernel.add_plugin(BookTravelPlugin(), plugin_name="book_travel")

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

# Define the request settings to configure the model with auto-function calling
request_settings = AzureChatPromptExecutionSettings(function_choice_behavior=FunctionChoiceBehavior.Auto())


async def main():
    # Make the request to the model for the given chat history and request settings
    # The Kernel contains the sample that the model will request to invoke
    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}`")
    # Example AI Model Response: `Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽`

    # Add the model's response to our chat history context
    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}");
    }
}

Ce que vous voyez dans cet exemple, c’est comment vous pouvez exploiter un analyseur préconstruit pour extraire des informations clés des entrées utilisateur, comme l’origine, la destination et la date d’une demande de réservation de vol. Cette approche modulaire vous permet de vous concentrer sur la logique de haut niveau.

Exploiter des outils collaboratifs

Des cadres comme CrewAI, Microsoft AutoGen et Semantic Kernel facilitent la création de plusieurs agents pouvant travailler ensemble.

Comment les équipes peuvent les utiliser : Les équipes peuvent concevoir des agents avec des rôles et des tâches spécifiques, leur permettant de tester et d’affiner les flux de travail collaboratifs et d’améliorer l’efficacité globale du système.

Comment cela fonctionne en pratique : Vous pouvez créer une équipe d’agents où chaque agent a une fonction spécialisée, comme la récupération de données, l’analyse ou la prise de décision. Ces agents peuvent communiquer et partager des informations pour atteindre un objectif commun, comme répondre à une requête utilisateur ou accomplir une tâche.

Exemple de code (AutoGen) :

# creating agents, then create a round robin schedule where they can work together, in this case in order

# Data Retrieval Agent
# Data Analysis Agent
# Decision Making Agent

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."
)

# conversation ends when user says "APPROVE"
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(...) when running in a script.
await Console(stream)

Dans le code précédent, vous voyez comment créer une tâche impliquant plusieurs agents travaillant ensemble pour analyser des données. Chaque agent remplit une fonction spécifique, et la tâche est exécutée en coordonnant les agents pour atteindre le résultat souhaité. En créant des agents dédiés avec des rôles spécialisés, vous pouvez améliorer l’efficacité et les performances des tâches.

Apprendre en temps réel

Les cadres avancés offrent des capacités de compréhension contextuelle et d’adaptation en temps réel.

Comment les équipes peuvent les utiliser : Les équipes peuvent implémenter des boucles de rétroaction où les agents apprennent des interactions et ajustent leur comportement de manière dynamique, conduisant à une amélioration continue et à un affinement des capacités.

Comment cela fonctionne en pratique : Les agents peuvent analyser les retours des utilisateurs, les données environnementales et les résultats des tâches pour mettre à jour leur base de connaissances, ajuster leurs algorithmes de prise de décision et améliorer leurs performances au fil du temps. Ce processus d’apprentissage itératif permet aux agents de s’adapter à des conditions changeantes et aux préférences des utilisateurs, améliorant ainsi l’efficacité globale du système.

Quelles sont les différences entre les cadres AutoGen, Semantic Kernel et Azure AI Agent Service ?

Il existe de nombreuses façons de comparer ces cadres, mais examinons quelques différences clés en termes de conception, de capacités et de cas d’utilisation ciblés :

AutoGen

AutoGen est un cadre open-source développé par le laboratoire AI Frontiers de Microsoft Research. Il se concentre sur les applications agentiques distribuées et pilotées par des événements, permettant l’utilisation de plusieurs LLMs et SLMs, d’outils et de modèles de conception avancés pour les agents multi-agents.

AutoGen repose sur le concept central des agents, qui sont des entités autonomes capables de percevoir leur environnement, de prendre des décisions et d’agir pour atteindre des objectifs spécifiques. Les agents communiquent via des messages asynchrones, leur permettant de travailler de manière indépendante et en parallèle, améliorant ainsi la scalabilité et la réactivité du système.

Selon Wikipédia, un acteur est l’élément de base du calcul concurrent. En réponse à un message qu’il reçoit, un acteur peut : prendre des décisions locales, créer d’autres acteurs, envoyer d’autres messages et déterminer comment répondre au prochain message reçu.

Cas d’utilisation : Automatisation de la génération de code, tâches d’analyse de données, et création d’agents personnalisés pour des fonctions de planification et de recherche.

Voici quelques concepts fondamentaux d’AutoGen :

Application stack

*les agents communiquent via des messages à travers le runtime, et le runtime gère le cycle de vie des agents*

Semantic Kernel + Cadre d’agents

Semantic Kernel est un SDK d’orchestration IA prêt pour l’entreprise. Il se compose de connecteurs IA et mémoire, ainsi que d’un cadre d’agents.

Commençons par couvrir quelques composants clés :

Service Azure AI Agent

Le service Azure AI Agent est une nouveauté introduite lors de Microsoft Ignite 2024. Il permet de développer et de déployer des agents IA avec des modèles plus flexibles, comme l’appel direct à des LLM open-source tels que Llama 3, Mistral et Cohere.

Le service Azure AI Agent offre des mécanismes de sécurité renforcés pour les entreprises et des méthodes de stockage de données, ce qui le rend adapté aux applications d’entreprise.

Il fonctionne directement avec des frameworks d’orchestration multi-agents comme AutoGen et Semantic Kernel.

Ce service est actuellement en aperçu public et prend en charge Python et C# pour la création d’agents.

En utilisant Semantic Kernel Python, nous pouvons créer un agent Azure AI avec un plugin défini par l’utilisateur :

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


# Define a sample plugin for the sample
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,
    ):
        # Create agent definition
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            name="Host",
            instructions="Answer questions about the menu.",
        )

        # Create the AzureAI Agent using the defined client and agent definition
        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[MenuPlugin()],
        )

        # Create a thread to hold the conversation
        # If no thread is provided, a new thread will be
        # created and returned with the initial response
        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}'")
                # Invoke the agent for the specified thread
                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())

Concepts clés

Le service Azure AI Agent repose sur les concepts clés suivants :

Cas d’utilisation : Le service Azure AI Agent est conçu pour les applications d’entreprise nécessitant un déploiement d’agents IA sécurisé, évolutif et flexible.

Quelle est la différence entre ces frameworks ?

Il semble qu’il y ait beaucoup de chevauchements entre ces frameworks, mais il existe des différences clés en termes de conception, de capacités et de cas d’utilisation ciblés :

Vous ne savez toujours pas lequel choisir ?

Cas d’utilisation

Voyons si nous pouvons vous aider en passant en revue quelques cas d’utilisation courants :

Q : Je fais des expérimentations, j’apprends et je construis des applications d’agents en preuve de concept, et je veux pouvoir construire et expérimenter rapidement.

R : AutoGen serait un bon choix pour ce scénario, car il se concentre sur des applications agentiques distribuées et basées sur des événements, et prend en charge des modèles de conception avancés pour les systèmes multi-agents.

Q : Qu’est-ce qui rend AutoGen meilleur que Semantic Kernel et le service Azure AI Agent pour ce cas d’utilisation ?

R : AutoGen est spécifiquement conçu pour des applications agentiques distribuées et basées sur des événements, ce qui le rend bien adapté à l’automatisation des tâches de génération de code et d’analyse de données. Il fournit les outils et capacités nécessaires pour construire efficacement des systèmes multi-agents complexes.

Q : Il semble que le service Azure AI Agent pourrait aussi fonctionner ici, il dispose d’outils pour la génération de code et plus encore ?

R : Oui, le service Azure AI Agent est une plateforme de service pour les agents et ajoute des capacités intégrées pour plusieurs modèles, Azure AI Search, Bing Search et Azure Functions. Il facilite la création de vos agents dans le portail Foundry et leur déploiement à grande échelle.

Q : Je suis toujours confus, donnez-moi juste une option.

R : Un excellent choix est de construire votre application dans Semantic Kernel d’abord, puis d’utiliser le service Azure AI Agent pour déployer votre agent. Cette approche vous permet de persister facilement vos agents tout en tirant parti de la puissance de la construction de systèmes multi-agents dans Semantic Kernel. De plus, Semantic Kernel dispose d’un connecteur dans AutoGen, ce qui facilite l’utilisation des deux frameworks ensemble.

Résumons les principales différences dans un tableau :

Framework Focus Concepts clés Cas d’utilisation
AutoGen Applications agentiques distribuées et basées sur des événements Agents, Personas, Fonctions, Données Génération de code, tâches d’analyse de données
Semantic Kernel Compréhension et génération de contenu textuel humain Agents, Composants modulaires, Collaboration Compréhension du langage naturel, génération de contenu
Service Azure AI Agent Modèles flexibles, sécurité d’entreprise, génération de code, appel d’outils Modularité, Collaboration, Orchestration de processus Déploiement d’agents IA sécurisé, évolutif et flexible

Quel est le cas d’utilisation idéal pour chacun de ces frameworks ?

Puis-je intégrer directement mes outils existants de l’écosystème Azure, ou ai-je besoin de solutions autonomes ?

La réponse est oui, vous pouvez intégrer directement vos outils existants de l’écosystème Azure avec le service Azure AI Agent, notamment parce qu’il a été conçu pour fonctionner de manière transparente avec d’autres services Azure. Vous pourriez, par exemple, intégrer Bing, Azure AI Search et Azure Functions. Il existe également une intégration profonde avec Azure AI Foundry.

Pour AutoGen et Semantic Kernel, vous pouvez également intégrer des services Azure, mais cela peut nécessiter d’appeler les services Azure depuis votre code. Une autre façon d’intégrer est d’utiliser les SDK Azure pour interagir avec les services Azure depuis vos agents. De plus, comme mentionné, vous pouvez utiliser le service Azure AI Agent comme orchestrateur pour vos agents construits dans AutoGen ou Semantic Kernel, ce qui permet un accès facile à l’écosystème Azure.

Vous avez d’autres questions sur les frameworks d’agents IA ?

Rejoignez le Discord Azure AI Foundry pour rencontrer d’autres apprenants, assister à des heures de bureau et obtenir des réponses à vos questions sur les agents IA.

Références

Leçon précédente

Introduction aux agents IA et cas d’utilisation des agents

Leçon suivante

Comprendre les modèles de conception agentique

Avertissement :
Ce document a été traduit à l’aide du service de traduction automatique Co-op Translator. Bien que nous nous efforcions d’assurer l’exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d’origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle réalisée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d’interprétations erronées résultant de l’utilisation de cette traduction.

This site is open source. Improve this page.