ai-agents-for-beginners

Explorarea cadrelor de lucru pentru agenți AI

(Faceți clic pe imaginea de mai sus pentru a viziona videoclipul acestei lecții)

Explorarea cadrelor de lucru pentru agenți AI

Cadrele de lucru pentru agenți AI sunt platforme software concepute pentru a simplifica crearea, implementarea și gestionarea agenților AI. Aceste cadre oferă dezvoltatorilor componente predefinite, abstracții și instrumente care eficientizează dezvoltarea sistemelor AI complexe.

Aceste cadre ajută dezvoltatorii să se concentreze pe aspectele unice ale aplicațiilor lor, oferind abordări standardizate pentru provocările comune în dezvoltarea agenților AI. Ele îmbunătățesc scalabilitatea, accesibilitatea și eficiența în construirea sistemelor AI.

Introducere

Această lecție va acoperi:

Obiective de învățare

Obiectivele acestei lecții sunt să vă ajute să înțelegeți:

Ce sunt cadrele de lucru pentru agenți AI și ce le permit dezvoltatorilor să facă?

Cadrele tradiționale AI pot ajuta la integrarea AI în aplicațiile dvs. și la îmbunătățirea acestora în următoarele moduri:

Sună grozav, nu-i așa? Atunci de ce avem nevoie de cadrele de lucru pentru agenți AI?

Cadrele de lucru pentru agenți AI reprezintă ceva mai mult decât cadrele tradiționale AI. Ele sunt concepute pentru a permite crearea de agenți inteligenți care pot interacționa cu utilizatorii, alți agenți și mediul pentru a atinge obiective specifice. Acești agenți pot manifesta un comportament autonom, pot lua decizii și se pot adapta la condiții în schimbare. Să analizăm câteva capacități cheie oferite de cadrele de lucru pentru agenți AI:

Pe scurt, agenții vă permit să faceți mai mult, să duceți automatizarea la nivelul următor, să creați sisteme mai inteligente care pot învăța și se pot adapta la mediul lor.

Cum să prototipăm rapid, să iterăm și să îmbunătățim capacitățile agentului?

Acesta este un domeniu în continuă evoluție, dar există câteva aspecte comune în majoritatea cadrelor de lucru pentru agenți AI care vă pot ajuta să prototipați și să iterați rapid, cum ar fi componentele modulare, instrumentele colaborative și învățarea în timp real. Să le analizăm:

Utilizați componente modulare

SDK-uri precum Microsoft Semantic Kernel și LangChain oferă componente predefinite, cum ar fi conectori AI, șabloane de prompturi și gestionarea memoriei.

Cum pot echipele să le folosească: Echipele pot asambla rapid aceste componente pentru a crea un prototip funcțional fără a începe de la zero, permițând experimentarea și iterarea rapidă.

Cum funcționează în practică: Puteți utiliza un parser predefinit pentru a extrage informații din inputul utilizatorului, un modul de memorie pentru a stoca și a recupera date și un generator de prompturi pentru a interacționa cu utilizatorii, toate acestea fără a fi nevoie să construiți aceste componente de la zero.

Exemplu de cod. Să analizăm exemple despre cum puteți utiliza un conector AI predefinit cu Semantic Kernel Python și .Net care folosește apelarea automată a funcțiilor pentru ca modelul să răspundă la inputul utilizatorului:

# 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}");
    }
}

Din acest exemplu, puteți vedea cum puteți valorifica un parser predefinit pentru a extrage informații cheie din inputul utilizatorului, cum ar fi originea, destinația și data unei cereri de rezervare a unui zbor. Această abordare modulară vă permite să vă concentrați pe logica de nivel înalt.

Valorificați instrumentele colaborative

Cadrele de lucru precum CrewAI, Microsoft AutoGen și Semantic Kernel facilitează crearea de mai mulți agenți care pot lucra împreună.

Cum pot echipele să le folosească: Echipele pot proiecta agenți cu roluri și sarcini specifice, permițându-le să testeze și să rafineze fluxurile de lucru colaborative și să îmbunătățească eficiența generală a sistemului.

Cum funcționează în practică: Puteți crea o echipă de agenți în care fiecare agent are o funcție specializată, cum ar fi recuperarea datelor, analiza sau luarea deciziilor. Acești agenți pot comunica și împărtăși informații pentru a atinge un obiectiv comun, cum ar fi răspunsul la o întrebare a utilizatorului sau finalizarea unei sarcini.

Exemplu de cod (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)

În codul anterior, puteți vedea cum puteți crea o sarcină care implică mai mulți agenți lucrând împreună pentru a analiza datele. Fiecare agent îndeplinește o funcție specifică, iar sarcina este executată prin coordonarea agenților pentru a atinge rezultatul dorit. Prin crearea de agenți dedicați cu roluri specializate, puteți îmbunătăți eficiența și performanța sarcinilor.

Învățați în timp real

Cadrele avansate oferă capacități pentru înțelegerea contextului în timp real și adaptare.

Cum pot echipele să le folosească: Echipele pot implementa bucle de feedback în care agenții învață din interacțiuni și își ajustează comportamentul dinamic, conducând la îmbunătățirea continuă și rafinarea capacităților.

Cum funcționează în practică: Agenții pot analiza feedback-ul utilizatorilor, datele de mediu și rezultatele sarcinilor pentru a-și actualiza baza de cunoștințe, a ajusta algoritmii de luare a deciziilor și a îmbunătăți performanța în timp. Acest proces de învățare iterativă permite agenților să se adapteze la condiții în schimbare și preferințele utilizatorilor, sporind eficiența generală a sistemului.

Care sunt diferențele între cadrele AutoGen, Semantic Kernel și Azure AI Agent Service?

Există multe moduri de a compara aceste cadre, dar să analizăm câteva diferențe cheie în ceea ce privește designul, capacitățile și cazurile de utilizare țintă:

AutoGen

AutoGen este un cadru open-source dezvoltat de Microsoft Research’s AI Frontiers Lab. Se concentrează pe aplicații distribuite, bazate pe evenimente, care permit utilizarea mai multor LLM-uri și SLM-uri, instrumente și modele avansate de design multi-agent.

AutoGen este construit în jurul conceptului de bază al agenților, care sunt entități autonome ce pot percepe mediul, lua decizii și întreprinde acțiuni pentru a atinge obiective specifice. Agenții comunică prin mesaje asincrone, permițându-le să funcționeze independent și în paralel, sporind scalabilitatea și receptivitatea sistemului.

Agenții se bazează pe modelul actorului. Conform Wikipedia, un actor este blocul de bază al calculului concurent. Ca răspuns la un mesaj primit, un actor poate: lua decizii locale, crea mai mulți actori, trimite mai multe mesaje și determina cum să răspundă la următorul mesaj primit.

Cazuri de utilizare: Automatizarea generării de cod, sarcini de analiză a datelor și construirea de agenți personalizați pentru funcții de planificare și cercetare.

Iată câteva concepte de bază importante ale AutoGen:

Semantic Kernel + Cadru de lucru pentru agenți

Semantic Kernel este un SDK de orchestrare AI pregătit pentru întreprinderi. Acesta constă în conectori AI și de memorie, împreună cu un cadru de lucru pentru agenți.

Să acoperim mai întâi câteva componente de bază:

Acestea sunt elementele de bază ale framework-ului Semantic Kernel, dar ce putem spune despre Agent Framework?

Serviciul Azure AI Agent

Serviciul Azure AI Agent este o adăugare mai recentă, introdusă la Microsoft Ignite 2024. Acesta permite dezvoltarea și implementarea agenților AI cu modele mai flexibile, cum ar fi apelarea directă a LLM-urilor open-source precum Llama 3, Mistral și Cohere.

Serviciul Azure AI Agent oferă mecanisme de securitate mai puternice pentru întreprinderi și metode de stocare a datelor, ceea ce îl face potrivit pentru aplicații de tip enterprise.

Funcționează direct cu framework-uri de orchestrare multi-agent, cum ar fi AutoGen și Semantic Kernel.

Acest serviciu este în prezent în Public Preview și suportă Python și C# pentru construirea agenților.

Folosind Semantic Kernel Python, putem crea un agent Azure AI cu un plugin definit de utilizator:

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())

Concepte de bază

Serviciul Azure AI Agent are următoarele concepte de bază:

Cazuri de utilizare: Serviciul Azure AI Agent este conceput pentru aplicații de tip enterprise care necesită implementarea agenților AI într-un mod sigur, scalabil și flexibil.

Care sunt diferențele dintre aceste framework-uri?

Pare că există multe suprapuneri între aceste framework-uri, dar există câteva diferențe cheie în ceea ce privește designul, capacitățile și cazurile de utilizare țintă:

Încă nu ești sigur ce să alegi?

Cazuri de utilizare

Să vedem dacă te putem ajuta trecând prin câteva cazuri de utilizare comune:

Î: Experimentez, învăț și construiesc aplicații agent proof-of-concept și vreau să pot construi și experimenta rapid.

R: AutoGen ar fi o alegere bună pentru acest scenariu, deoarece se concentrează pe aplicații agentice distribuite, bazate pe evenimente, și suportă modele avansate de design multi-agent.

Î: Ce face ca AutoGen să fie o alegere mai bună decât Semantic Kernel și Azure AI Agent Service pentru acest caz de utilizare?

R: AutoGen este conceput special pentru aplicații agentice distribuite, bazate pe evenimente, ceea ce îl face potrivit pentru automatizarea sarcinilor de generare de cod și analiză de date. Oferă instrumentele și capacitățile necesare pentru a construi eficient sisteme multi-agent complexe.

Î: Pare că Azure AI Agent Service ar putea funcționa și aici, are instrumente pentru generarea de cod și altele?

R: Da, Azure AI Agent Service este un serviciu de platformă pentru agenți și adaugă capabilități încorporate pentru modele multiple, Azure AI Search, Bing Search și Azure Functions. Face ușor construirea agenților în Foundry Portal și implementarea lor la scară.

Î: Sunt încă confuz, doar dă-mi o opțiune.

R: O alegere excelentă este să construiești aplicația ta în Semantic Kernel mai întâi și apoi să folosești Azure AI Agent Service pentru a implementa agentul. Această abordare îți permite să persiști agenții cu ușurință, în timp ce valorifici puterea de a construi sisteme multi-agent în Semantic Kernel. În plus, Semantic Kernel are un conector în AutoGen, ceea ce face ușor utilizarea ambelor framework-uri împreună.

Să rezumăm diferențele cheie într-un tabel:

Framework Focus Concepte de bază Cazuri de utilizare
AutoGen Aplicații agentice distribuite, bazate pe evenimente Agenți, Personaje, Funcții, Date Generare de cod, sarcini de analiză de date
Semantic Kernel Înțelegerea și generarea de conținut asemănător limbajului uman Agenți, Componente Modulare, Colaborare Înțelegerea limbajului natural, generarea de conținut
Azure AI Agent Service Modele flexibile, securitate enterprise, Generare de cod, Apelarea instrumentelor Modularitate, Colaborare, Orchestrarea proceselor Implementarea agenților AI într-un mod sigur, scalabil și flexibil

Care este cazul ideal de utilizare pentru fiecare dintre aceste framework-uri?

Pot integra direct instrumentele existente din ecosistemul Azure sau am nevoie de soluții independente?

Răspunsul este da, poți integra direct instrumentele existente din ecosistemul Azure cu Azure AI Agent Service, mai ales pentru că acesta a fost construit să funcționeze perfect cu alte servicii Azure. De exemplu, ai putea integra Bing, Azure AI Search și Azure Functions. Există, de asemenea, o integrare profundă cu Azure AI Foundry.

Pentru AutoGen și Semantic Kernel, poți, de asemenea, integra cu serviciile Azure, dar poate fi necesar să apelezi serviciile Azure din codul tău. O altă modalitate de integrare este utilizarea SDK-urilor Azure pentru a interacționa cu serviciile Azure din agenții tăi. În plus, așa cum s-a menționat, poți folosi Azure AI Agent Service ca orchestrator pentru agenții construiți în AutoGen sau Semantic Kernel, ceea ce ar oferi acces ușor la ecosistemul Azure.

Ai mai multe întrebări despre framework-urile AI Agent?

Alătură-te Discord-ului Azure AI Foundry pentru a întâlni alți cursanți, a participa la ore de consultanță și a obține răspunsuri la întrebările tale despre agenții AI.

Referințe

Lecția anterioară

Introducere în agenții AI și cazuri de utilizare ale agenților

Lecția următoare

Înțelegerea modelelor de design agentic

Declinare de responsabilitate:
Acest document a fost tradus folosind serviciul de traducere AI Co-op Translator. Deși ne străduim să asigurăm acuratețea, vă rugăm să fiți conștienți că traducerile automate pot conține erori sau inexactități. Documentul original în limba sa natală ar trebui considerat sursa autoritară. Pentru informații critice, se recomandă traducerea profesională realizată de un specialist uman. Nu ne asumăm responsabilitatea pentru eventualele neînțelegeri sau interpretări greșite care pot apărea din utilizarea acestei traduceri.

This site is open source. Improve this page.