ai-agents-for-beginners

AI Ügynök Keretrendszerek Felfedezése

(Kattints a fenti képre a videó megtekintéséhez)

AI Ügynök Keretrendszerek Felfedezése

Az AI ügynök keretrendszerek olyan szoftverplatformok, amelyek célja az AI ügynökök létrehozásának, telepítésének és kezelésének egyszerűsítése. Ezek a keretrendszerek előre elkészített komponenseket, absztrakciókat és eszközöket biztosítanak a fejlesztők számára, amelyek megkönnyítik összetett AI rendszerek fejlesztését.

Ezek a keretrendszerek segítenek a fejlesztőknek az alkalmazásaik egyedi aspektusaira koncentrálni, miközben szabványos megközelítéseket kínálnak az AI ügynök fejlesztésének gyakori kihívásaira. Javítják a skálázhatóságot, hozzáférhetőséget és hatékonyságot az AI rendszerek építésében.

Bevezetés

Ebben a leckében szó lesz:

Tanulási célok

A lecke célja, hogy segítsen megérteni:

Mi az AI Ügynök Keretrendszer, és mit tesz lehetővé a fejlesztők számára?

A hagyományos AI keretrendszerek segítenek az AI integrálásában az alkalmazásokba, és javítják azokat az alábbi módokon:

Ez mind nagyszerűen hangzik, de miért van szükségünk AI Ügynök Keretrendszerre?

Az AI Ügynök keretrendszerek többek, mint egyszerű AI keretrendszerek. Ezeket arra tervezték, hogy lehetővé tegyék intelligens ügynökök létrehozását, amelyek képesek interakcióba lépni a felhasználókkal, más ügynökökkel és a környezettel, hogy konkrét célokat érjenek el. Ezek az ügynökök autonóm viselkedést mutathatnak, döntéseket hozhatnak, és alkalmazkodhatnak a változó körülményekhez. Nézzük meg az AI Ügynök Keretrendszerek által lehetővé tett kulcsfontosságú képességeket:

Összefoglalva, az ügynökök lehetővé teszik, hogy többet érjünk el, az automatizálást magasabb szintre emeljük, és olyan intelligens rendszereket hozzunk létre, amelyek képesek alkalmazkodni és tanulni a környezetükből.

Hogyan lehet gyorsan prototípust készíteni, iterálni és javítani az ügynök képességeit?

Ez egy gyorsan változó terület, de van néhány közös elem a legtöbb AI Ügynök Keretrendszerben, amelyek segíthetnek a gyors prototípus-készítésben és iterálásban, nevezetesen moduláris komponensek, együttműködési eszközök és valós idejű tanulás. Nézzük meg ezeket részletesebben:

Használj moduláris komponenseket

Az olyan SDK-k, mint a Microsoft Semantic Kernel és LangChain, előre elkészített komponenseket kínálnak, mint például AI csatlakozók, prompt sablonok és memória kezelés.

Hogyan használhatják a csapatok ezeket: A csapatok gyorsan összeállíthatják ezeket a komponenseket, hogy működő prototípust hozzanak létre anélkül, hogy nulláról kellene kezdeniük, lehetővé téve a gyors kísérletezést és iterálást.

Hogyan működik a gyakorlatban: Használhatsz egy előre elkészített elemzőt a felhasználói bemenetből származó információk kinyerésére, egy memória modult az adatok tárolására és visszakeresésére, valamint egy prompt generátort a felhasználókkal való interakcióhoz, mindezt anélkül, hogy ezeket a komponenseket nulláról kellene felépítened.

Példa kód. Nézzünk meg példákat arra, hogyan használhatsz egy előre elkészített AI csatlakozót a Semantic Kernel Python és .Net segítségével, amely automatikus funkcióhívást használ a modell felhasználói bemenetre adott válaszához:

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

A példából látható, hogyan használhatsz egy előre elkészített elemzőt a kulcsfontosságú információk kinyerésére a felhasználói bemenetből, például egy repülőjegy foglalási kérés kiindulási helyét, célállomását és dátumát. Ez a moduláris megközelítés lehetővé teszi, hogy a magas szintű logikára koncentrálj.

Használj együttműködési eszközöket

Az olyan keretrendszerek, mint a CrewAI, Microsoft AutoGen és Semantic Kernel, megkönnyítik több ügynök létrehozását, amelyek együtt dolgozhatnak.

Hogyan használhatják a csapatok ezeket: A csapatok specifikus szerepekkel és feladatokkal rendelkező ügynököket tervezhetnek, lehetővé téve az együttműködési munkafolyamatok tesztelését és finomítását, valamint az általános rendszerhatékonyság javítását.

Hogyan működik a gyakorlatban: Létrehozhatsz egy ügynökcsapatot, ahol minden ügynöknek van egy specializált funkciója, például adatlekérés, elemzés vagy döntéshozatal. Ezek az ügynökök kommunikálhatnak és megoszthatják az információkat, hogy közös célt érjenek el, például válaszoljanak egy felhasználói kérdésre vagy teljesítsenek egy feladatot.

Példa kód (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)

A fenti kódban látható, hogyan hozhatsz létre egy feladatot, amely több ügynök együttműködését igényli az adatok elemzéséhez. Minden ügynök egy specifikus funkciót lát el, és a feladatot az ügynökök koordinálásával hajtják végre a kívánt eredmény elérése érdekében. Dedikált, specializált szerepekkel rendelkező ügynökök létrehozásával javíthatod a feladat hatékonyságát és teljesítményét.

Tanulj valós időben

A fejlett keretrendszerek valós idejű környezeti megértést és alkalmazkodást tesznek lehetővé.

Hogyan használhatják a csapatok ezeket: A csapatok visszacsatolási hurkokat valósíthatnak meg, ahol az ügynökök tanulnak az interakciókból, és dinamikusan módosítják viselkedésüket, ami folyamatos fejlődést és képességek finomítását eredményezi.

Hogyan működik a gyakorlatban: Az ügynökök elemezhetik a felhasználói visszajelzéseket, környezeti adatokat és feladat eredményeket, hogy frissítsék tudásbázisukat, módosítsák döntéshozatali algoritmusaikat, és idővel javítsák teljesítményüket. Ez az iteratív tanulási folyamat lehetővé teszi az ügynökök számára, hogy alkalmazkodjanak a változó körülményekhez és felhasználói preferenciákhoz, növelve az általános rendszerhatékonyságot.

Milyen különbségek vannak az AutoGen, Semantic Kernel és Azure AI Agent Service keretrendszerek között?

Számos módon összehasonlíthatók ezek a keretrendszerek, de nézzük meg néhány kulcsfontosságú különbséget a tervezésük, képességeik és célzott felhasználási eseteik szempontjából:

AutoGen

Az AutoGen egy nyílt forráskódú keretrendszer, amelyet a Microsoft Research AI Frontiers Lab fejlesztett ki. Az eseményvezérelt, elosztott ügynöki alkalmazásokra összpontosít, lehetővé téve több LLM és SLM, eszközök és fejlett több ügynökös tervezési minták használatát.

Az AutoGen az ügynökök alapfogalmára épül, amelyek autonóm entitások, amelyek érzékelhetik környezetüket, döntéseket hozhatnak, és cselekedhetnek konkrét célok elérése érdekében. Az ügynökök aszinkron üzeneteken keresztül kommunikálnak, lehetővé téve számukra, hogy függetlenül és párhuzamosan dolgozzanak, növelve a rendszer skálázhatóságát és reagálóképességét.

Az ügynökök az aktor modellre épülnek. A Wikipedia szerint az aktor a párhuzamos számítás alapvető építőköve. Az általa kapott üzenetre válaszul az aktor képes: helyi döntéseket hozni, további aktorokat létrehozni, további üzeneteket küldeni, és meghatározni, hogyan reagáljon a következő kapott üzenetre.

Felhasználási esetek: Kódgenerálás automatizálása, adat-elemzési feladatok, és egyedi ügynökök létrehozása tervezési és kutatási funkciókhoz.

Az AutoGen néhány fontos alapfogalma:

Tehát ezek a Semantic Kernel keretrendszer alapjai, de mi a helyzet az Agent Frameworkkel?

Azure AI Agent Service

Az Azure AI Agent Service egy újabb fejlesztés, amelyet a Microsoft Ignite 2024 rendezvényen mutattak be. Lehetővé teszi AI ügynökök fejlesztését és telepítését rugalmasabb modellekkel, például nyílt forráskódú LLM-ek, mint a Llama 3, Mistral és Cohere közvetlen hívásával.

Az Azure AI Agent Service erősebb vállalati biztonsági mechanizmusokat és adatkezelési módszereket kínál, így ideális vállalati alkalmazásokhoz.

Kész megoldást nyújt több ügynököt kezelő keretrendszerekkel, mint például az AutoGen és a Semantic Kernel.

Ez a szolgáltatás jelenleg nyilvános előzetes verzióban érhető el, és Python és C# nyelveken támogatja az ügynökök fejlesztését.

A Semantic Kernel Python segítségével létrehozhatunk egy Azure AI ügynököt egy felhasználó által definiált plugin segítségével:

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

Alapfogalmak

Az Azure AI Agent Service az alábbi alapfogalmakat tartalmazza:

Felhasználási esetek: Az Azure AI Agent Service olyan vállalati alkalmazásokhoz készült, amelyek biztonságos, skálázható és rugalmas AI ügynök telepítést igényelnek.

Mi a különbség ezek között a keretrendszerek között?

Úgy tűnik, hogy sok átfedés van ezek között a keretrendszerek között, de vannak kulcsfontosságú különbségek a tervezésük, képességeik és célzott felhasználási eseteik tekintetében:

Még mindig nem biztos benne, melyiket válassza?

Felhasználási esetek

Nézzük meg, hogy segíthetünk-e néhány gyakori felhasználási eset áttekintésével:

K: Kísérletezek, tanulok és proof-of-concept ügynöki alkalmazásokat építek, és gyorsan szeretnék építeni és kísérletezni.

V: Az AutoGen jó választás lenne ebben az esetben, mivel az eseményvezérelt, elosztott ügynöki alkalmazásokra összpontosít, és támogatja a fejlett több ügynökös tervezési mintákat.

K: Miért jobb választás az AutoGen, mint a Semantic Kernel és az Azure AI Agent Service ebben az esetben?

V: Az AutoGen kifejezetten az eseményvezérelt, elosztott ügynöki alkalmazásokra lett tervezve, így jól alkalmazható kódgenerálási és adat-elemzési feladatok automatizálására. Megadja a szükséges eszközöket és képességeket a komplex több ügynökös rendszerek hatékony felépítéséhez.

K: Úgy tűnik, hogy az Azure AI Agent Service is működhet itt, hiszen vannak eszközei kódgeneráláshoz és más feladatokhoz?

V: Igen, az Azure AI Agent Service egy platformszolgáltatás ügynökök számára, és beépített képességeket kínál több modellhez, Azure AI Search-hez, Bing Search-hez és Azure Functions-höz. Könnyen lehet ügynököket építeni a Foundry Portálban és nagy léptékben telepíteni őket.

K: Még mindig zavaros, csak adj egy opciót.

V: Egy nagyszerű választás az alkalmazás építése először a Semantic Kernel-ben, majd az ügynök telepítése az Azure AI Agent Service segítségével. Ez a megközelítés lehetővé teszi az ügynökök egyszerű tárolását, miközben kihasználja a több ügynökös rendszerek építésének erejét a Semantic Kernel-ben. Ezenkívül a Semantic Kernel rendelkezik egy csatlakozóval az AutoGen-ben, ami megkönnyíti a két keretrendszer együttes használatát.

Foglaljuk össze a kulcsfontosságú különbségeket egy táblázatban:

Keretrendszer Fókusz Alapfogalmak Felhasználási esetek
AutoGen Eseményvezérelt, elosztott ügynöki alkalmazások Ügynökök, Személyiségek, Funkciók, Adatok Kódgenerálás, adat-elemzési feladatok
Semantic Kernel Emberi szöveg megértése és generálása Ügynökök, Moduláris komponensek, Együttműködés Természetes nyelv megértése, tartalomgenerálás
Azure AI Agent Service Rugalmas modellek, vállalati biztonság, Kódgenerálás, Eszközök hívása Modularitás, Együttműködés, Folyamatok irányítása Biztonságos, skálázható és rugalmas AI ügynök telepítés

Mi az ideális felhasználási eset ezekhez a keretrendszerekhez?

Integrálhatom közvetlenül a meglévő Azure ökoszisztéma eszközeimet, vagy különálló megoldásokra van szükségem?

A válasz igen, közvetlenül integrálhatja meglévő Azure ökoszisztéma eszközeit, különösen az Azure AI Agent Service esetében, mivel úgy lett kialakítva, hogy zökkenőmentesen működjön együtt más Azure szolgáltatásokkal. Például integrálhatja a Bing-et, Azure AI Search-t és Azure Functions-t. Mély integrációt kínál az Azure AI Foundry-val is.

Az AutoGen és a Semantic Kernel esetében szintén integrálhatja az Azure szolgáltatásokat, de ehhez szükség lehet arra, hogy az Azure szolgáltatásokat a kódjából hívja meg. Egy másik módja az integrációnak az Azure SDK-k használata, hogy az ügynökök az Azure szolgáltatásokkal kommunikáljanak. Ezenkívül, ahogy említettük, az Azure AI Agent Service-t használhatja orchestrátorként az AutoGen-ben vagy Semantic Kernel-ben épített ügynökök számára, ami egyszerű hozzáférést biztosít az Azure ökoszisztémához.

További kérdései vannak az AI Agent Frameworkökkel kapcsolatban?

Csatlakozzon az Azure AI Foundry Discord közösséghez, hogy találkozzon más tanulókkal, részt vegyen konzultációkon, és választ kapjon az AI ügynökökkel kapcsolatos kérdéseire.

Hivatkozások

Előző lecke

Bevezetés az AI ügynökökbe és felhasználási esetek

Következő lecke

Ügynöki tervezési minták megértése

Felelősség kizárása:
Ez a dokumentum az Co-op Translator AI fordítási szolgáltatás segítségével lett lefordítva. Bár törekszünk a pontosságra, kérjük, vegye figyelembe, hogy az automatikus fordítások hibákat vagy pontatlanságokat tartalmazhatnak. Az eredeti dokumentum az eredeti nyelvén tekintendő hiteles forrásnak. Kritikus információk esetén javasolt professzionális emberi fordítást igénybe venni. Nem vállalunk felelősséget semmilyen félreértésért vagy téves értelmezésért, amely a fordítás használatából eredhet.

This site is open source. Improve this page.