ai-agents-for-beginners

Udforsk AI Agent Frameworks

(Klik på billedet ovenfor for at se videoen til denne lektion)

Udforsk AI Agent Frameworks

AI agent frameworks er softwareplatforme designet til at forenkle oprettelsen, implementeringen og styringen af AI-agenter. Disse frameworks giver udviklere forudbyggede komponenter, abstraktioner og værktøjer, der gør det lettere at udvikle komplekse AI-systemer.

Disse frameworks hjælper udviklere med at fokusere på de unikke aspekter af deres applikationer ved at tilbyde standardiserede løsninger på almindelige udfordringer inden for AI-agentudvikling. De forbedrer skalerbarhed, tilgængelighed og effektivitet i opbygningen af AI-systemer.

Introduktion

Denne lektion vil dække:

Læringsmål

Målene med denne lektion er at hjælpe dig med at forstå:

Hvad er AI Agent Frameworks, og hvad gør de det muligt for udviklere at opnå?

Traditionelle AI Frameworks kan hjælpe dig med at integrere AI i dine apps og forbedre disse apps på følgende måder:

Det lyder alt sammen godt, ikke? Så hvorfor har vi brug for AI Agent Frameworks?

AI Agent Frameworks repræsenterer noget mere end blot AI frameworks. De er designet til at muliggøre oprettelsen af intelligente agenter, der kan interagere med brugere, andre agenter og miljøet for at opnå specifikke mål. Disse agenter kan udvise autonom adfærd, træffe beslutninger og tilpasse sig ændrede forhold. Lad os se på nogle nøglefunktioner, der muliggøres af AI Agent Frameworks:

Så kort sagt giver agenter dig mulighed for at gøre mere, tage automatisering til næste niveau og skabe mere intelligente systemer, der kan tilpasse sig og lære af deres miljø.

Hvordan kan man hurtigt prototype, iterere og forbedre agentens kapaciteter?

Dette er et hurtigt udviklende område, men der er nogle ting, der er fælles for de fleste AI Agent Frameworks, som kan hjælpe dig med hurtigt at prototype og iterere, nemlig modulkomponenter, samarbejdsværktøjer og realtidslæring. Lad os dykke ned i disse:

Brug modulkomponenter

SDK’er som Microsoft Semantic Kernel og LangChain tilbyder forudbyggede komponenter som AI-forbindelser, promptskabeloner og hukommelsesstyring.

Hvordan teams kan bruge disse: Teams kan hurtigt samle disse komponenter for at skabe en funktionel prototype uden at starte fra bunden, hvilket muliggør hurtig eksperimentering og iteration.

Hvordan det fungerer i praksis: Du kan bruge en forudbygget parser til at udtrække information fra brugerinput, en hukommelsesmodul til at gemme og hente data og en promptgenerator til at interagere med brugere, alt sammen uden at skulle bygge disse komponenter fra bunden.

Eksempelkode. Lad os se på eksempler på, hvordan du kan bruge en forudbygget AI Connector med Semantic Kernel Python og .Net, der bruger auto-funktionskald til at få modellen til at reagere på brugerinput:

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

Hvad du kan se fra dette eksempel er, hvordan du kan udnytte en forudbygget parser til at udtrække nøgleinformation fra brugerinput, såsom oprindelse, destination og dato for en flybookinganmodning. Denne modulære tilgang giver dig mulighed for at fokusere på den overordnede logik.

Udnyt samarbejdsværktøjer

Frameworks som CrewAI, Microsoft AutoGen og Semantic Kernel muliggør oprettelsen af flere agenter, der kan arbejde sammen.

Hvordan teams kan bruge disse: Teams kan designe agenter med specifikke roller og opgaver, hvilket gør det muligt at teste og forfine samarbejdsarbejdsgange og forbedre den samlede systemeffektivitet.

Hvordan det fungerer i praksis: Du kan oprette et team af agenter, hvor hver agent har en specialiseret funktion, såsom datahentning, analyse eller beslutningstagning. Disse agenter kan kommunikere og dele information for at opnå et fælles mål, såsom at besvare en brugerforespørgsel eller fuldføre en opgave.

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

Hvad du ser i den tidligere kode er, hvordan du kan oprette en opgave, der involverer flere agenter, der arbejder sammen om at analysere data. Hver agent udfører en specifik funktion, og opgaven udføres ved at koordinere agenterne for at opnå det ønskede resultat. Ved at oprette dedikerede agenter med specialiserede roller kan du forbedre opgaveeffektiviteten og ydeevnen.

Lær i realtid

Avancerede frameworks giver muligheder for realtids kontekstforståelse og tilpasning.

Hvordan teams kan bruge disse: Teams kan implementere feedbackloops, hvor agenter lærer af interaktioner og justerer deres adfærd dynamisk, hvilket fører til kontinuerlig forbedring og forfining af kapaciteter.

Hvordan det fungerer i praksis: Agenter kan analysere brugerfeedback, miljødata og opgaveudfald for at opdatere deres vidensbase, justere beslutningsalgoritmer og forbedre ydeevnen over tid. Denne iterative læringsproces gør det muligt for agenter at tilpasse sig ændrede forhold og brugerpræferencer, hvilket forbedrer den samlede systemeffektivitet.

Hvad er forskellene mellem frameworks AutoGen, Semantic Kernel og Azure AI Agent Service?

Der er mange måder at sammenligne disse frameworks på, men lad os se på nogle nøgleforskelle i forhold til deres design, kapaciteter og målgrupper:

AutoGen

AutoGen er et open-source framework udviklet af Microsoft Research’s AI Frontiers Lab. Det fokuserer på hændelsesdrevne, distribuerede agentiske applikationer, der muliggør flere LLM’er og SLM’er, værktøjer og avancerede multi-agent designmønstre.

AutoGen er bygget omkring kernekonceptet agenter, som er autonome enheder, der kan opfatte deres miljø, træffe beslutninger og tage handlinger for at opnå specifikke mål. Agenter kommunikerer via asynkrone beskeder, hvilket gør det muligt for dem at arbejde uafhængigt og parallelt, hvilket forbedrer systemets skalerbarhed og responsivitet.

Ifølge Wikipedia er en aktør den grundlæggende byggesten for samtidig computation. Som svar på en besked, den modtager, kan en aktør: træffe lokale beslutninger, oprette flere aktører, sende flere beskeder og bestemme, hvordan den skal reagere på den næste besked, den modtager.

Anvendelsesområder: Automatisering af kodegenerering, dataanalysetasks og opbygning af skræddersyede agenter til planlægnings- og forskningsfunktioner.

Her er nogle vigtige kernekoncepter i AutoGen:

Applikationsstak

*agenter kommunikerer via beskeder gennem runtime, og runtime styrer agenternes livscyklus*

Semantic Kernel + Agent Framework

Semantic Kernel er en enterprise-klar AI Orchestration SDK. Den består af AI- og hukommelsesforbindelser sammen med et Agent Framework.

Lad os først dække nogle kernekomponenter:

Azure AI Agent Service

Azure AI Agent Service er en nyere tilføjelse, introduceret på Microsoft Ignite 2024. Det giver mulighed for udvikling og implementering af AI-agenter med mere fleksible modeller, såsom direkte opkald til open-source LLM’er som Llama 3, Mistral og Cohere.

Azure AI Agent Service tilbyder stærkere sikkerhedsmekanismer og metoder til datalagring, hvilket gør det velegnet til virksomhedsapplikationer.

Det fungerer direkte med multi-agent orkestreringsframeworks som AutoGen og Semantic Kernel.

Denne service er i øjeblikket i Public Preview og understøtter Python og C# til opbygning af agenter.

Ved hjælp af Semantic Kernel Python kan vi oprette en Azure AI Agent med et brugerdefineret plugin:

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

Centrale begreber

Azure AI Agent Service har følgende centrale begreber:

Anvendelsesområder: Azure AI Agent Service er designet til virksomhedsapplikationer, der kræver sikker, skalerbar og fleksibel implementering af AI-agenter.

Hvad er forskellen mellem disse frameworks?

Det lyder som om, der er en del overlap mellem disse frameworks, men der er nogle nøgleforskelle i forhold til deres design, kapaciteter og målgrupper:

Stadig i tvivl om, hvilken du skal vælge?

Anvendelsesområder

Lad os se, om vi kan hjælpe dig ved at gennemgå nogle almindelige anvendelsesområder:

Q: Jeg eksperimenterer, lærer og bygger proof-of-concept agent-applikationer, og jeg vil kunne bygge og eksperimentere hurtigt

A: AutoGen ville være et godt valg til dette scenarie, da det fokuserer på hændelsesdrevne, distribuerede agent-applikationer og understøtter avancerede multi-agent designmønstre.

Q: Hvad gør AutoGen til et bedre valg end Semantic Kernel og Azure AI Agent Service til dette anvendelsesområde?

A: AutoGen er specifikt designet til hændelsesdrevne, distribuerede agent-applikationer, hvilket gør det velegnet til automatisering af kodegenerering og dataanalyseopgaver. Det giver de nødvendige værktøjer og kapaciteter til effektivt at bygge komplekse multi-agent systemer.

Q: Det lyder som om Azure AI Agent Service også kunne fungere her, det har værktøjer til kodegenerering og mere?

A: Ja, Azure AI Agent Service er en platformtjeneste for agenter og tilføjer indbyggede kapaciteter for flere modeller, Azure AI Search, Bing Search og Azure Functions. Det gør det nemt at bygge dine agenter i Foundry Portal og implementere dem i stor skala.

Q: Jeg er stadig forvirret, giv mig bare én mulighed

A: Et godt valg er at bygge din applikation i Semantic Kernel først og derefter bruge Azure AI Agent Service til at implementere din agent. Denne tilgang giver dig mulighed for nemt at gemme dine agenter, samtidig med at du udnytter kraften til at bygge multi-agent systemer i Semantic Kernel. Derudover har Semantic Kernel en connector i AutoGen, hvilket gør det nemt at bruge begge frameworks sammen.

Lad os opsummere de vigtigste forskelle i en tabel:

Framework Fokus Centrale begreber Anvendelsesområder
AutoGen Hændelsesdrevne, distribuerede agent-applikationer Agenter, Personas, Funktioner, Data Kodegenerering, dataanalyseopgaver
Semantic Kernel Forståelse og generering af menneskelignende tekstindhold Agenter, Moduler, Samarbejde Naturlig sprogforståelse, indholdsgenerering
Azure AI Agent Service Fleksible modeller, virksomheds-sikkerhed, Kodegenerering, Værktøjskald Modularitet, Samarbejde, Procesorkestrering Sikker, skalerbar og fleksibel implementering af AI-agenter

Hvad er det ideelle anvendelsesområde for hvert af disse frameworks?

Kan jeg integrere mine eksisterende Azure-økosystemværktøjer direkte, eller har jeg brug for selvstændige løsninger?

Svaret er ja, du kan integrere dine eksisterende Azure-økosystemværktøjer direkte med Azure AI Agent Service, især fordi det er bygget til at fungere problemfrit med andre Azure-tjenester. Du kunne for eksempel integrere Bing, Azure AI Search og Azure Functions. Der er også dyb integration med Azure AI Foundry.

For AutoGen og Semantic Kernel kan du også integrere med Azure-tjenester, men det kan kræve, at du kalder Azure-tjenesterne fra din kode. En anden måde at integrere på er at bruge Azure SDK’er til at interagere med Azure-tjenester fra dine agenter. Derudover, som nævnt, kan du bruge Azure AI Agent Service som en orkestrator for dine agenter bygget i AutoGen eller Semantic Kernel, hvilket ville give nem adgang til Azure-økosystemet.

Har du flere spørgsmål om AI Agent Frameworks?

Deltag i Azure AI Foundry Discord for at møde andre lærende, deltage i kontortimer og få svar på dine spørgsmål om AI-agenter.

Referencer

Forrige lektion

Introduktion til AI-agenter og anvendelsesområder

Næste lektion

Forståelse af agentiske designmønstre

Ansvarsfraskrivelse:
Dette dokument er blevet oversat ved hjælp af AI-oversættelsestjenesten Co-op Translator. Selvom vi bestræber os på nøjagtighed, skal det bemærkes, at automatiserede oversættelser kan indeholde fejl eller unøjagtigheder. Det originale dokument på dets oprindelige sprog bør betragtes som den autoritative kilde. For kritisk information anbefales professionel menneskelig oversættelse. Vi påtager os ikke ansvar for eventuelle misforståelser eller fejltolkninger, der måtte opstå som følge af brugen af denne oversættelse.

This site is open source. Improve this page.