ai-agents-for-beginners

Utforske AI-agentrammeverk

(Klikk på bildet ovenfor for å se videoen av denne leksjonen)

Utforsk AI-agentrammeverk

AI-agentrammeverk er programvareplattformer designet for å forenkle opprettelse, distribusjon og administrasjon av AI-agenter. Disse rammeverkene gir utviklere forhåndsbygde komponenter, abstraksjoner og verktøy som effektiviserer utviklingen av komplekse AI-systemer.

Disse rammeverkene hjelper utviklere med å fokusere på de unike aspektene ved applikasjonene sine ved å tilby standardiserte tilnærminger til vanlige utfordringer i AI-agentutvikling. De forbedrer skalerbarhet, tilgjengelighet og effektivitet i byggingen av AI-systemer.

Introduksjon

Denne leksjonen vil dekke:

Læringsmål

Målene med denne leksjonen er å hjelpe deg med å forstå:

Hva er AI-agentrammeverk, og hva gjør de det mulig for utviklere å gjøre?

Tradisjonelle AI-rammeverk kan hjelpe deg med å integrere AI i appene dine og forbedre disse appene på følgende måter:

Det høres flott ut, ikke sant? Så hvorfor trenger vi AI-agentrammeverk?

AI-agentrammeverk representerer noe mer enn bare AI-rammeverk. De er designet for å muliggjøre opprettelsen av intelligente agenter som kan samhandle med brukere, andre agenter og miljøet for å oppnå spesifikke mål. Disse agentene kan utvise autonom atferd, ta beslutninger og tilpasse seg endrede forhold. La oss se på noen nøkkelfunksjoner muliggjort av AI-agentrammeverk:

Oppsummert lar agenter deg gjøre mer, ta automatisering til neste nivå, og skape mer intelligente systemer som kan tilpasse seg og lære av miljøet sitt.

Hvordan raskt prototype, iterere og forbedre agentens evner?

Dette er et raskt bevegende landskap, men det er noen ting som er felles for de fleste AI-agentrammeverk som kan hjelpe deg med å raskt prototype og iterere, nemlig modulkomponenter, samarbeidsverktøy og sanntidslæring. La oss dykke inn i disse:

Bruk modulkomponenter

SDK-er som Microsoft Semantic Kernel og LangChain tilbyr forhåndsbygde komponenter som AI-koblinger, promptmaler og minnehåndtering.

Hvordan team kan bruke disse: Team kan raskt sette sammen disse komponentene for å lage en funksjonell prototype uten å starte fra bunnen av, noe som muliggjør rask eksperimentering og iterasjon.

Hvordan det fungerer i praksis: Du kan bruke en forhåndsbygd parser for å hente informasjon fra brukerinput, en minnemodul for å lagre og hente data, og en promptgenerator for å samhandle med brukere, alt uten å måtte bygge disse komponentene fra bunnen av.

Eksempelkode. La oss se på eksempler på hvordan du kan bruke en forhåndsbygd AI-kobling med Semantic Kernel Python og .Net som bruker autofunksjonskall for å få modellen til å svare på brukerinput:

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

Det du ser fra dette eksemplet er hvordan du kan utnytte en forhåndsbygd parser for å hente nøkkelinformasjon fra brukerinput, som opprinnelse, destinasjon og dato for en flybestillingsforespørsel. Denne modulære tilnærmingen lar deg fokusere på den overordnede logikken.

Utnytt samarbeidsverktøy

Rammeverk som CrewAI, Microsoft AutoGen og Semantic Kernel legger til rette for opprettelsen av flere agenter som kan samarbeide.

Hvordan team kan bruke disse: Team kan designe agenter med spesifikke roller og oppgaver, slik at de kan teste og forbedre samarbeidsarbeidsflyter og forbedre den generelle systemeffektiviteten.

Hvordan det fungerer i praksis: Du kan opprette et team av agenter der hver agent har en spesialisert funksjon, som datainnhenting, analyse eller beslutningstaking. Disse agentene kan kommunisere og dele informasjon for å oppnå et felles mål, som å svare på en brukerforespørsel eller fullføre en oppgave.

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)

Det du ser i den forrige koden er hvordan du kan opprette en oppgave som involverer flere agenter som samarbeider for å analysere data. Hver agent utfører en spesifikk funksjon, og oppgaven utføres ved å koordinere agentene for å oppnå ønsket resultat. Ved å opprette dedikerte agenter med spesialiserte roller kan du forbedre oppgaveeffektiviteten og ytelsen.

Lær i sanntid

Avanserte rammeverk gir muligheter for sanntidskontekstforståelse og tilpasning.

Hvordan team kan bruke disse: Team kan implementere tilbakemeldingssløyfer der agenter lærer av interaksjoner og justerer oppførselen dynamisk, noe som fører til kontinuerlig forbedring og raffinering av evner.

Hvordan det fungerer i praksis: Agenter kan analysere brukertilbakemeldinger, miljødata og oppgaveutfall for å oppdatere kunnskapsbasen, justere beslutningsalgoritmer og forbedre ytelsen over tid. Denne iterative læringsprosessen gjør det mulig for agenter å tilpasse seg endrede forhold og brukerpreferanser, noe som forbedrer den generelle systemeffektiviteten.

Hva er forskjellene mellom rammeverkene AutoGen, Semantic Kernel og Azure AI Agent Service?

Det finnes mange måter å sammenligne disse rammeverkene på, men la oss se på noen viktige forskjeller når det gjelder design, funksjoner og målgrupper:

AutoGen

AutoGen er et åpen kildekode-rammeverk utviklet av Microsoft Research’s AI Frontiers Lab. Det fokuserer på hendelsesdrevne, distribuerte agentiske applikasjoner, som muliggjør flere LLM-er og SLM-er, verktøy og avanserte multi-agent designmønstre.

AutoGen er bygget rundt kjernekonseptet agenter, som er autonome enheter som kan oppfatte miljøet sitt, ta beslutninger og utføre handlinger for å oppnå spesifikke mål. Agenter kommuniserer gjennom asynkrone meldinger, noe som gjør det mulig for dem å arbeide uavhengig og parallelt, og forbedrer systemets skalerbarhet og responsivitet.

Ifølge Wikipedia er en aktør den grunnleggende byggesteinen for samtidig beregning. Som svar på en melding den mottar, kan en aktør: ta lokale beslutninger, opprette flere aktører, sende flere meldinger og bestemme hvordan den skal svare på neste melding den mottar.

Bruksområder: Automatisering av kodegenerering, dataanalysetjenester og bygging av tilpassede agenter for planleggings- og forskningsfunksjoner.

Her er noen viktige kjernebegreper i AutoGen:

Semantic Kernel + Agent Framework

Semantic Kernel er en bedriftsklar AI Orchestration SDK. Den består av AI- og minnekoblinger, sammen med et Agent Framework.

La oss først dekke noen kjernekomponenter:

Azure AI Agent Service

Azure AI Agent Service er en nyere tilleggstjeneste, introdusert på Microsoft Ignite 2024. Den muliggjør utvikling og distribusjon av AI-agenter med mer fleksible modeller, som for eksempel direkte kall til åpne LLM-er som Llama 3, Mistral og Cohere.

Azure AI Agent Service tilbyr sterkere sikkerhetsmekanismer for bedrifter og metoder for datalagring, noe som gjør den egnet for bedriftsapplikasjoner.

Den fungerer umiddelbart med orkestreringsrammeverk for flere agenter som AutoGen og Semantic Kernel.

Denne tjenesten er for øyeblikket i offentlig forhåndsvisning og støtter Python og C# for å bygge agenter.

Ved å bruke Semantic Kernel Python kan vi lage en Azure AI Agent med et brukerdefinert 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())

Kjernebegreper

Azure AI Agent Service har følgende kjernebegreper:

Bruksområder: Azure AI Agent Service er designet for bedriftsapplikasjoner som krever sikker, skalerbar og fleksibel distribusjon av AI-agenter.

Hva er forskjellen mellom disse rammeverkene?

Det kan virke som om det er mye overlapp mellom disse rammeverkene, men det er noen viktige forskjeller når det gjelder design, funksjonalitet og målgrupper:

Er du fortsatt usikker på hvilken du skal velge?

Bruksområder

La oss se om vi kan hjelpe deg ved å gå gjennom noen vanlige bruksområder:

Spørsmål: Jeg eksperimenterer, lærer og bygger proof-of-concept agentapplikasjoner, og jeg vil kunne bygge og eksperimentere raskt.

Svar: AutoGen vil være et godt valg for dette scenariet, da det fokuserer på hendelsesdrevne, distribuerte agentapplikasjoner og støtter avanserte designmønstre for flere agenter.

Spørsmål: Hva gjør AutoGen til et bedre valg enn Semantic Kernel og Azure AI Agent Service for dette bruksområdet?

Svar: AutoGen er spesifikt designet for hendelsesdrevne, distribuerte agentapplikasjoner, noe som gjør det godt egnet for å automatisere kodegenerering og dataanalysetjenester. Det gir de nødvendige verktøyene og funksjonene for å bygge komplekse systemer med flere agenter effektivt.

Spørsmål: Det høres ut som Azure AI Agent Service også kunne fungere her, den har verktøy for kodegenerering og mer?

Svar: Ja, Azure AI Agent Service er en plattformtjeneste for agenter og har innebygde funksjoner for flere modeller, Azure AI Search, Bing Search og Azure Functions. Det gjør det enkelt å bygge agentene dine i Foundry Portal og distribuere dem i stor skala.

Spørsmål: Jeg er fortsatt forvirret, kan du bare gi meg ett alternativ?

Svar: Et godt valg er å bygge applikasjonen din i Semantic Kernel først og deretter bruke Azure AI Agent Service til å distribuere agenten din. Denne tilnærmingen lar deg enkelt vedlikeholde agentene dine samtidig som du utnytter kraften til å bygge systemer med flere agenter i Semantic Kernel. I tillegg har Semantic Kernel en kobling i AutoGen, noe som gjør det enkelt å bruke begge rammeverkene sammen.

La oss oppsummere de viktigste forskjellene i en tabell:

Rammeverk Fokus Kjernebegreper Bruksområder
AutoGen Hendelsesdrevne, distribuerte agentapplikasjoner Agenter, Personas, Funksjoner, Data Kodegenerering, dataanalysetjenester
Semantic Kernel Forståelse og generering av menneskelignende tekstinnhold Agenter, Modulære komponenter, Samarbeid Naturlig språkforståelse, innholdsgenerering
Azure AI Agent Service Fleksible modeller, sikkerhet for bedrifter, Kodegenerering, Verktøykall Modularitet, Samarbeid, Prosessorkestrering Sikker, skalerbar og fleksibel distribusjon av AI-agenter

Hva er det ideelle bruksområdet for hvert av disse rammeverkene?

Kan jeg integrere mine eksisterende Azure-økosystemverktøy direkte, eller trenger jeg frittstående løsninger?

Svaret er ja, du kan integrere dine eksisterende Azure-økosystemverktøy direkte med Azure AI Agent Service, spesielt fordi den er bygget for å fungere sømløst med andre Azure-tjenester. Du kan for eksempel integrere Bing, Azure AI Search og Azure Functions. Det er også dyp integrasjon med Azure AI Foundry.

For AutoGen og Semantic Kernel kan du også integrere med Azure-tjenester, men det kan kreve at du kaller Azure-tjenestene fra koden din. En annen måte å integrere på er å bruke Azure SDK-er for å samhandle med Azure-tjenester fra agentene dine. I tillegg, som nevnt, kan du bruke Azure AI Agent Service som en orkestrator for agentene dine bygget i AutoGen eller Semantic Kernel, noe som gir enkel tilgang til Azure-økosystemet.

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

Bli med i Azure AI Foundry Discord for å møte andre lærere, delta på kontortid og få svar på spørsmålene dine om AI-agenter.

Referanser

Forrige leksjon

Introduksjon til AI-agenter og bruksområder

Neste leksjon

Forstå designmønstre for agenter

Ansvarsfraskrivelse:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten Co-op Translator. Selv om vi tilstreber nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

This site is open source. Improve this page.