ai-agents-for-beginners

Zkoumání rámců AI agentů

(Klikněte na obrázek výše pro zhlédnutí videa této lekce)

Prozkoumejte rámce AI agentů

Rámce AI agentů jsou softwarové platformy navržené tak, aby usnadnily tvorbu, nasazení a správu AI agentů. Tyto rámce poskytují vývojářům předem připravené komponenty, abstrakce a nástroje, které zjednodušují vývoj složitých AI systémů.

Tyto rámce pomáhají vývojářům soustředit se na jedinečné aspekty jejich aplikací tím, že nabízejí standardizované přístupy k běžným výzvám při vývoji AI agentů. Zvyšují škálovatelnost, přístupnost a efektivitu při budování AI systémů.

Úvod

Tato lekce pokryje:

Cíle učení

Cíle této lekce jsou pomoci vám pochopit:

Co jsou rámce AI agentů a co umožňují vývojářům dělat?

Tradiční AI rámce vám mohou pomoci integrovat AI do vašich aplikací a zlepšit je následujícími způsoby:

To všechno zní skvěle, tak proč potřebujeme rámce AI agentů?

Rámce AI agentů představují něco víc než jen AI rámce. Jsou navrženy tak, aby umožnily tvorbu inteligentních agentů, kteří mohou interagovat s uživateli, jinými agenty a prostředím za účelem dosažení konkrétních cílů. Tito agenti mohou vykazovat autonomní chování, činit rozhodnutí a přizpůsobovat se měnícím se podmínkám. Podívejme se na některé klíčové schopnosti umožněné rámci AI agentů:

Shrnuto, agenti vám umožňují dělat více, posunout automatizaci na další úroveň a vytvářet inteligentnější systémy, které se mohou učit a přizpůsobovat svému prostředí.

Jak rychle prototypovat, iterovat a zlepšovat schopnosti agentů?

Toto je rychle se vyvíjející oblast, ale existují některé společné prvky napříč většinou rámců AI agentů, které vám mohou pomoci rychle prototypovat a iterovat, konkrétně modulární komponenty, kolaborativní nástroje a učení v reálném čase. Pojďme se na ně podívat:

Používejte modulární komponenty

SDK jako Microsoft Semantic Kernel a LangChain nabízejí předem připravené komponenty, jako jsou AI konektory, šablony promptů a správa paměti.

Jak to mohou týmy využít: Týmy mohou rychle sestavit tyto komponenty a vytvořit funkční prototyp bez nutnosti začínat od nuly, což umožňuje rychlé experimentování a iteraci.

Jak to funguje v praxi: Můžete použít předem připravený parser k extrakci informací ze vstupu uživatele, paměťový modul k ukládání a načítání dat a generátor promptů k interakci s uživateli, aniž byste museli tyto komponenty vytvářet od nuly.

Příklad kódu. Podívejme se na příklady, jak můžete použít předem připravený AI konektor se Semantic Kernel Python a .Net, který využívá automatické volání funkcí, aby model reagoval na vstup uživatele:

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

Z tohoto příkladu vidíte, jak můžete využít předem připravený parser k extrakci klíčových informací ze vstupu uživatele, jako je původ, cíl a datum požadavku na rezervaci letu. Tento modulární přístup vám umožňuje soustředit se na logiku na vyšší úrovni.

Využívejte kolaborativní nástroje

Rámce jako CrewAI, Microsoft AutoGen a Semantic Kernel usnadňují tvorbu více agentů, kteří mohou spolupracovat.

Jak to mohou týmy využít: Týmy mohou navrhovat agenty s konkrétními rolemi a úkoly, což umožňuje testování a zdokonalování kolaborativních pracovních postupů a zlepšení celkové efektivity systému.

Jak to funguje v praxi: Můžete vytvořit tým agentů, kde každý agent má specializovanou funkci, jako je získávání dat, analýza nebo rozhodování. Tito agenti mohou komunikovat a sdílet informace za účelem dosažení společného cíle, jako je zodpovězení dotazu uživatele nebo dokončení úkolu.

Příklad kódu (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 předchozím kódu vidíte, jak můžete vytvořit úkol, který zahrnuje více agentů spolupracujících na analýze dat. Každý agent vykonává specifickou funkci a úkol je proveden koordinací agentů za účelem dosažení požadovaného výsledku. Vytvořením specializovaných agentů můžete zlepšit efektivitu a výkon úkolů.

Učte se v reálném čase

Pokročilé rámce poskytují schopnosti pro porozumění kontextu a adaptaci v reálném čase.

Jak to mohou týmy využít: Týmy mohou implementovat zpětnovazební smyčky, kde se agenti učí z interakcí a dynamicky přizpůsobují své chování, což vede k neustálému zlepšování a zdokonalování schopností.

Jak to funguje v praxi: Agenti mohou analyzovat zpětnou vazbu uživatelů, data z prostředí a výsledky úkolů, aby aktualizovali svou znalostní bázi, přizpůsobili algoritmy rozhodování a zlepšili výkon v průběhu času. Tento iterativní proces učení umožňuje agentům přizpůsobit se měnícím se podmínkám a preferencím uživatelů, čímž se zvyšuje celková efektivita systému.

Jaké jsou rozdíly mezi rámci AutoGen, Semantic Kernel a Azure AI Agent Service?

Existuje mnoho způsobů, jak tyto rámce porovnat, ale podívejme se na některé klíčové rozdíly z hlediska jejich návrhu, schopností a cílových případů použití:

AutoGen

AutoGen je open-source rámec vyvinutý laboratoří Microsoft Research’s AI Frontiers Lab. Zaměřuje se na událostmi řízené, distribuované agentní aplikace, umožňující více LLMs a SLMs, nástroje a pokročilé návrhové vzory pro více agentů.

AutoGen je postaven kolem základního konceptu agentů, což jsou autonomní entity, které mohou vnímat své prostředí, činit rozhodnutí a podnikat kroky k dosažení konkrétních cílů. Agenti komunikují prostřednictvím asynchronních zpráv, což jim umožňuje pracovat nezávisle a paralelně, čímž se zvyšuje škálovatelnost a odezva systému.

Podle Wikipedie je herec základním stavebním kamenem souběžného výpočtu. V reakci na přijatou zprávu může herec: činit lokální rozhodnutí, vytvářet další herce, posílat další zprávy a určovat, jak reagovat na další přijatou zprávu.

Případy použití: Automatizace generování kódu, úkoly analýzy dat a tvorba vlastních agentů pro plánování a výzkumné funkce.

Zde jsou některé důležité základní koncepty AutoGen:

Semantic Kernel + Agent Framework

Semantic Kernel je podnikový AI Orchestration SDK. Skládá se z AI a paměťových konektorů spolu s Agent Frameworkem.

Nejprve si pokryjme některé základní komponenty:

Azure AI Agent Service

Azure AI Agent Service je novější přírůstek, představený na Microsoft Ignite 2024. Umožňuje vývoj a nasazení AI agentů s flexibilnějšími modely, například přímým voláním open-source LLM jako Llama 3, Mistral a Cohere.

Azure AI Agent Service poskytuje silnější mechanismy zabezpečení pro podniky a metody ukládání dat, což ho činí vhodným pro podnikové aplikace.

Funguje ihned po instalaci s orchestračními rámci pro více agentů, jako jsou AutoGen a Semantic Kernel.

Tato služba je momentálně ve veřejném náhledu a podporuje Python a C# pro tvorbu agentů.

Pomocí Semantic Kernel Python můžeme vytvořit Azure AI Agent s uživatelsky definovaným pluginem:

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

Základní koncepty

Azure AI Agent Service má následující základní koncepty:

Použití: Azure AI Agent Service je navržen pro podnikové aplikace, které vyžadují bezpečné, škálovatelné a flexibilní nasazení AI agentů.

Jaký je rozdíl mezi těmito rámci?

Zdá se, že mezi těmito rámci existuje mnoho překryvů, ale existují klíčové rozdíly v jejich designu, schopnostech a cílových případech použití:

Stále si nejste jisti, který zvolit?

Použití

Podívejme se, jestli vám můžeme pomoci projít některé běžné případy použití:

Q: Experimentuji, učím se a vytvářím proof-of-concept aplikace agentů a chci být schopen rychle stavět a experimentovat

A: AutoGen by byl dobrá volba pro tento scénář, protože se zaměřuje na událostmi řízené, distribuované agentní aplikace a podporuje pokročilé návrhové vzory pro více agentů.

Q: Co dělá AutoGen lepší volbou než Semantic Kernel a Azure AI Agent Service pro tento případ použití?

A: AutoGen je speciálně navržen pro událostmi řízené, distribuované agentní aplikace, což ho činí dobře vhodným pro automatizaci úkolů generování kódu a analýzy dat. Poskytuje potřebné nástroje a schopnosti pro efektivní tvorbu komplexních systémů s více agenty.

Q: Zní to, že Azure AI Agent Service by zde také mohl fungovat, má nástroje pro generování kódu a další?

A: Ano, Azure AI Agent Service je platformová služba pro agenty a přidává vestavěné schopnosti pro více modelů, Azure AI Search, Bing Search a Azure Functions. Umožňuje snadno vytvářet vaše agenty v Foundry Portálu a nasazovat je ve velkém měřítku.

Q: Pořád jsem zmatený, dejte mi jen jednu možnost

A: Skvělou volbou je nejprve vytvořit vaši aplikaci v Semantic Kernel a poté použít Azure AI Agent Service k nasazení vašeho agenta. Tento přístup vám umožní snadno uchovávat vaše agenty a zároveň využívat sílu k vytvoření systémů s více agenty v Semantic Kernel. Navíc má Semantic Kernel konektor v AutoGen, což usnadňuje použití obou rámců společně.

Shrňme klíčové rozdíly v tabulce:

Rámec Zaměření Základní koncepty Případy použití
AutoGen Událostmi řízené, distribuované agentní aplikace Agenti, Persony, Funkce, Data Generování kódu, úkoly analýzy dat
Semantic Kernel Porozumění a generování textového obsahu podobného lidskému Agenti, Modulární komponenty, Spolupráce Porozumění přirozenému jazyku, generování obsahu
Azure AI Agent Service Flexibilní modely, podniková bezpečnost, Generování kódu, Volání nástrojů Modularita, Spolupráce, Orchestrace procesů Bezpečné, škálovatelné a flexibilní nasazení AI agentů

Jaký je ideální případ použití pro každý z těchto rámců?

Mohu integrovat své stávající nástroje Azure ekosystému přímo, nebo potřebuji samostatná řešení?

Odpověď je ano, můžete integrovat své stávající nástroje Azure ekosystému přímo s Azure AI Agent Service, zejména proto, že byl vytvořen tak, aby bezproblémově fungoval s ostatními službami Azure. Můžete například integrovat Bing, Azure AI Search a Azure Functions. Existuje také hluboká integrace s Azure AI Foundry.

Pro AutoGen a Semantic Kernel můžete také integrovat s Azure službami, ale může být nutné volat Azure služby z vašeho kódu. Dalším způsobem integrace je použití Azure SDKs k interakci s Azure službami z vašich agentů. Navíc, jak bylo zmíněno, můžete použít Azure AI Agent Service jako orchestrátor pro vaše agenty vytvořené v AutoGen nebo Semantic Kernel, což by poskytlo snadný přístup k Azure ekosystému.

Máte další otázky ohledně AI Agent Frameworks?

Připojte se k Azure AI Foundry Discord, kde se můžete setkat s ostatními studenty, zúčastnit se konzultačních hodin a získat odpovědi na vaše otázky ohledně AI agentů.

Reference

Předchozí lekce

Úvod do AI agentů a jejich případů použití

Další lekce

Porozumění návrhovým vzorům agentů

Prohlášení:
Tento dokument byl přeložen pomocí služby pro automatický překlad Co-op Translator. I když se snažíme o co největší přesnost, mějte prosím na paměti, že automatické překlady mohou obsahovat chyby nebo nepřesnosti. Původní dokument v jeho původním jazyce by měl být považován za závazný zdroj. Pro důležité informace doporučujeme profesionální lidský překlad. Neodpovídáme za žádná nedorozumění nebo nesprávné výklady vyplývající z použití tohoto překladu.

This site is open source. Improve this page.