ai-agents-for-beginners

Raziskovanje okvirov za AI agente

(Kliknite zgornjo sliko za ogled videa te lekcije)

Raziskovanje okvirov za AI agente

Okviri za AI agente so programske platforme, zasnovane za poenostavitev ustvarjanja, uvajanja in upravljanja AI agentov. Ti okviri razvijalcem ponujajo vnaprej pripravljene komponente, abstrakcije in orodja, ki olajšajo razvoj kompleksnih AI sistemov.

Okviri pomagajo razvijalcem, da se osredotočijo na edinstvene vidike svojih aplikacij, saj zagotavljajo standardizirane pristope k skupnim izzivom pri razvoju AI agentov. Povečujejo skalabilnost, dostopnost in učinkovitost pri gradnji AI sistemov.

Uvod

Ta lekcija bo obravnavala:

Cilji učenja

Cilji te lekcije so, da razumete:

Kaj so okviri za AI agente in kaj omogočajo razvijalcem?

Tradicionalni AI okviri lahko pomagajo pri integraciji AI v aplikacije in izboljšanju teh aplikacij na naslednje načine:

Zveni odlično, kajne? Zakaj torej potrebujemo okvire za AI agente?

Okviri za AI agente predstavljajo nekaj več kot le AI okviri. Zasnovani so za omogočanje ustvarjanja inteligentnih agentov, ki lahko komunicirajo z uporabniki, drugimi agenti in okoljem, da dosežejo določene cilje. Ti agenti lahko izkazujejo avtonomno vedenje, sprejemajo odločitve in se prilagajajo spreminjajočim se razmeram. Poglejmo ključne zmogljivosti, ki jih omogočajo okviri za AI agente:

Skratka, agenti omogočajo več, dvigujejo avtomatizacijo na višjo raven in ustvarjajo bolj inteligentne sisteme, ki se lahko prilagajajo in učijo iz svojega okolja.

Kako hitro prototipirati, iterirati in izboljšati zmogljivosti agenta?

To je hitro razvijajoče se področje, vendar obstajajo nekatere skupne značilnosti večine okvirov za AI agente, ki vam lahko pomagajo hitro prototipirati in iterirati, kot so modularne komponente, orodja za sodelovanje in učenje v realnem času. Poglobimo se v te:

Uporaba modularnih komponent

SDK-ji, kot sta Microsoft Semantic Kernel in LangChain, ponujajo vnaprej pripravljene komponente, kot so AI konektorji, predloge za pozive in upravljanje spomina.

Kako lahko ekipe to uporabijo: Ekipe lahko hitro sestavijo te komponente za ustvarjanje funkcionalnega prototipa, ne da bi začele od začetka, kar omogoča hitro eksperimentiranje in iteracijo.

Kako to deluje v praksi: Uporabite lahko vnaprej pripravljen razčlenjevalnik za pridobivanje informacij iz uporabniškega vnosa, modul za spomin za shranjevanje in pridobivanje podatkov ter generator pozivov za interakcijo z uporabniki, vse brez potrebe po gradnji teh komponent od začetka.

Primer kode. Poglejmo primere, kako lahko uporabite vnaprej pripravljen AI konektor s Semantic Kernel Python in .Net, ki uporablja samodejno klicanje funkcij za odziv modela na uporabniški vnos:

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

Iz tega primera lahko vidite, kako lahko izkoristite vnaprej pripravljen razčlenjevalnik za pridobivanje ključnih informacij iz uporabniškega vnosa, kot so izvor, destinacija in datum zahteve za rezervacijo leta. Ta modularni pristop vam omogoča, da se osredotočite na logiko na višji ravni.

Izkoristite orodja za sodelovanje

Okviri, kot so CrewAI, Microsoft AutoGen in Semantic Kernel, omogočajo ustvarjanje več agentov, ki lahko sodelujejo.

Kako lahko ekipe to uporabijo: Ekipe lahko oblikujejo agente s specifičnimi vlogami in nalogami, kar omogoča testiranje in izboljšanje sodelovalnih delovnih procesov ter izboljšanje splošne učinkovitosti sistema.

Kako to deluje v praksi: Ustvarite lahko ekipo agentov, kjer ima vsak agent specializirano funkcijo, kot so pridobivanje podatkov, analiza ali sprejemanje odločitev. Ti agenti lahko komunicirajo in delijo informacije za dosego skupnega cilja, kot je odgovor na uporabniško vprašanje ali dokončanje naloge.

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

V prejšnji kodi vidite, kako lahko ustvarite nalogo, ki vključuje več agentov, ki sodelujejo pri analizi podatkov. Vsak agent opravlja določeno funkcijo, naloga pa se izvaja s koordinacijo agentov za dosego želenega rezultata. Z ustvarjanjem namenskih agentov s specializiranimi vlogami lahko izboljšate učinkovitost in zmogljivost nalog.

Učenje v realnem času

Napredni okviri omogočajo zmožnosti za razumevanje konteksta in prilagoditev v realnem času.

Kako lahko ekipe to uporabijo: Ekipe lahko implementirajo povratne zanke, kjer se agenti učijo iz interakcij in dinamično prilagajajo svoje vedenje, kar vodi k nenehnemu izboljševanju in izpopolnjevanju zmogljivosti.

Kako to deluje v praksi: Agenti lahko analizirajo povratne informacije uporabnikov, podatke o okolju in rezultate nalog za posodobitev svoje baze znanja, prilagoditev algoritmov za sprejemanje odločitev in izboljšanje zmogljivosti skozi čas. Ta iterativni proces učenja omogoča agentom, da se prilagodijo spreminjajočim se razmeram in preferencam uporabnikov, kar izboljša splošno učinkovitost sistema.

Kakšne so razlike med okviri AutoGen, Semantic Kernel in Azure AI Agent Service?

Obstaja veliko načinov za primerjavo teh okvirov, vendar si poglejmo ključne razlike glede njihove zasnove, zmogljivosti in ciljnih primerov uporabe:

AutoGen

AutoGen je odprtokodni okvir, ki ga je razvil Microsoft Research’s AI Frontiers Lab. Osredotoča se na dogodkovno vodene, porazdeljene agentne aplikacije, ki omogočajo več LLM-jev in SLM-jev, orodij ter napredne vzorce oblikovanja več agentov.

AutoGen temelji na osnovnem konceptu agentov, ki so avtonomne entitete, ki lahko zaznavajo svoje okolje, sprejemajo odločitve in ukrepajo za dosego določenih ciljev. Agenti komunicirajo prek asinhronih sporočil, kar jim omogoča, da delujejo neodvisno in vzporedno, kar povečuje skalabilnost in odzivnost sistema.

Agenti temeljijo na modelu akterja. Po Wikipediji je akter osnovni gradnik sočasnega računalništva. Kot odziv na prejeto sporočilo lahko akter: sprejme lokalne odločitve, ustvari več akterjev, pošlje več sporočil in določi, kako se odzvati na naslednje prejeto sporočilo.

Primeri uporabe: Avtomatizacija generiranja kode, naloge analize podatkov in gradnja prilagojenih agentov za funkcije načrtovanja in raziskovanja.

Tu so nekateri pomembni osnovni koncepti AutoGen:

Semantic Kernel + Agent Framework

Semantic Kernel je SDK za orkestracijo AI, pripravljen za podjetja. Sestavljajo ga AI in spominski konektorji ter okvir za agente.

Najprej pokrijmo nekatere osnovne komponente:

Torej, to so osnove okvira Semantic Kernel, kaj pa Agent Framework?

Azure AI Agent Service

Azure AI Agent Service je novejši dodatek, predstavljen na Microsoft Ignite 2024. Omogoča razvoj in uvajanje AI agentov z bolj prilagodljivimi modeli, kot je neposredno klicanje odprtokodnih LLM-jev, kot so Llama 3, Mistral in Cohere.

Azure AI Agent Service zagotavlja močnejše mehanizme za varnost v podjetjih in metode shranjevanja podatkov, zaradi česar je primeren za poslovne aplikacije.

Deluje takoj z večagentnimi orkestracijskimi okviri, kot sta AutoGen in Semantic Kernel.

Ta storitev je trenutno v javni predogledni različici in podpira Python ter C# za gradnjo agentov.

Z uporabo Semantic Kernel Python lahko ustvarimo Azure AI agenta z uporabniško določenim vtičnikom:

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

Osnovni koncepti

Azure AI Agent Service vključuje naslednje osnovne koncepte:

Primeri uporabe: Azure AI Agent Service je zasnovan za poslovne aplikacije, ki zahtevajo varno, skalabilno in prilagodljivo uvajanje AI agentov.

Kakšna je razlika med temi okviri?

Zdi se, da je med temi okviri veliko prekrivanja, vendar obstajajo ključne razlike glede njihove zasnove, zmogljivosti in ciljnih primerov uporabe:

Še vedno niste prepričani, katerega izbrati?

Primeri uporabe

Poglejmo, če vam lahko pomagamo z nekaj pogostimi primeri uporabe:

V: Eksperimentiram, se učim in gradim aplikacije z agenti kot dokaz koncepta, želim pa hitro graditi in eksperimentirati.

O: AutoGen bi bil dobra izbira za ta scenarij, saj se osredotoča na dogodkovno vodene, porazdeljene aplikacije z agenti in podpira napredne večagentne vzorce oblikovanja.

V: Kaj naredi AutoGen boljšo izbiro kot Semantic Kernel in Azure AI Agent Service za ta primer uporabe?

O: AutoGen je posebej zasnovan za dogodkovno vodene, porazdeljene aplikacije z agenti, zaradi česar je zelo primeren za avtomatizacijo nalog generiranja kode in analize podatkov. Ponuja potrebna orodja in zmogljivosti za učinkovito gradnjo kompleksnih večagentnih sistemov.

V: Zdi se, da bi Azure AI Agent Service lahko deloval tudi tukaj, saj ima orodja za generiranje kode in več?

O: Da, Azure AI Agent Service je platformna storitev za agente in dodaja vgrajene zmogljivosti za več modelov, Azure AI Search, Bing Search in Azure Functions. Omogoča enostavno gradnjo vaših agentov v Foundry Portalu in njihovo uvajanje na velikem obsegu.

V: Še vedno sem zmeden, samo dajte mi eno možnost.

O: Odlična izbira je, da najprej zgradite svojo aplikacijo v Semantic Kernel in nato uporabite Azure AI Agent Service za uvajanje vašega agenta. Ta pristop vam omogoča, da enostavno ohranite svoje agente, hkrati pa izkoristite moč za gradnjo večagentnih sistemov v Semantic Kernel. Poleg tega ima Semantic Kernel povezovalnik v AutoGen, kar omogoča enostavno uporabo obeh okvirov skupaj.

Povzemimo ključne razlike v tabeli:

Okvir Osredotočenost Osnovni koncepti Primeri uporabe
AutoGen Dogodkovno vodene, porazdeljene aplikacije z agenti Agenti, Osebnosti, Funkcije, Podatki Generiranje kode, naloge analize podatkov
Semantic Kernel Razumevanje in generiranje besedil, podobnih človeškim Agenti, Modularne komponente, Sodelovanje Razumevanje naravnega jezika, generiranje vsebine
Azure AI Agent Service Prilagodljivi modeli, varnost v podjetjih, Generiranje kode, Klicanje orodij Modularnost, Sodelovanje, Orkestracija procesov Varno, skalabilno in prilagodljivo uvajanje AI agentov

Kateri je idealen primer uporabe za vsak od teh okvirov?

Ali lahko neposredno integriram svoje obstoječe Azure ekosistemske storitve ali potrebujem samostojne rešitve?

Odgovor je da, lahko neposredno integrirate svoje obstoječe Azure ekosistemske storitve z Azure AI Agent Service, še posebej zato, ker je bil zasnovan za brezhibno delovanje z drugimi Azure storitvami. Na primer, lahko integrirate Bing, Azure AI Search in Azure Functions. Obstaja tudi globoka integracija z Azure AI Foundry.

Za AutoGen in Semantic Kernel lahko prav tako integrirate z Azure storitvami, vendar boste morda morali klicati Azure storitve iz svoje kode. Drug način integracije je uporaba Azure SDK-jev za interakcijo z Azure storitvami iz vaših agentov. Poleg tega, kot je bilo omenjeno, lahko uporabite Azure AI Agent Service kot orkestrator za vaše agente, zgrajene v AutoGen ali Semantic Kernel, kar omogoča enostaven dostop do Azure ekosistema.

Imate več vprašanj o AI Agent Frameworkih?

Pridružite se Azure AI Foundry Discord, da se povežete z drugimi učenci, udeležite uradnih ur in dobite odgovore na svoja vprašanja o AI agentih.

Reference

Prejšnja lekcija

Uvod v AI agente in primere uporabe agentov

Naslednja lekcija

Razumevanje vzorcev oblikovanja agentov

Omejitev odgovornosti:
Ta dokument je bil preveden z uporabo storitve za prevajanje z umetno inteligenco Co-op Translator. Čeprav si prizadevamo za natančnost, vas opozarjamo, da lahko avtomatizirani prevodi vsebujejo napake ali netočnosti. Izvirni dokument v njegovem maternem jeziku je treba obravnavati kot avtoritativni vir. Za ključne informacije priporočamo profesionalni človeški prevod. Ne prevzemamo odgovornosti za morebitne nesporazume ali napačne razlage, ki bi nastale zaradi uporabe tega prevoda.

This site is open source. Improve this page.