ai-agents-for-beginners

Utforska AI-agentramverk

(Klicka på bilden ovan för att se videon av denna lektion)

Utforska AI-agentramverk

AI-agentramverk är mjukvaruplattformar som är utformade för att förenkla skapandet, implementeringen och hanteringen av AI-agenter. Dessa ramverk erbjuder utvecklare förbyggda komponenter, abstraktioner och verktyg som effektiviserar utvecklingen av komplexa AI-system.

Ramverken hjälper utvecklare att fokusera på de unika aspekterna av sina applikationer genom att tillhandahålla standardiserade lösningar på vanliga utmaningar inom AI-agentutveckling. De förbättrar skalbarhet, tillgänglighet och effektivitet vid byggandet av AI-system.

Introduktion

Denna lektion kommer att täcka:

Lärandemål

Målen med denna lektion är att hjälpa dig förstå:

Vad är AI-agentramverk och vad möjliggör de för utvecklare att göra?

Traditionella AI-ramverk kan hjälpa dig att integrera AI i dina appar och förbättra dessa appar på följande sätt:

Det låter ju bra, så varför behöver vi AI-agentramverk?

AI-agentramverk representerar något mer än bara AI-ramverk. De är utformade för att möjliggöra skapandet av intelligenta agenter som kan interagera med användare, andra agenter och miljön för att uppnå specifika mål. Dessa agenter kan uppvisa autonomt beteende, fatta beslut och anpassa sig till förändrade förhållanden. Låt oss titta på några nyckelkapabiliteter som möjliggörs av AI-agentramverk:

Sammanfattningsvis möjliggör agenter att göra mer, att ta automatisering till nästa nivå, att skapa mer intelligenta system som kan anpassa sig och lära sig från sin miljö.

Hur snabbt skapa prototyper, iterera och förbättra agentens kapabiliteter?

Detta är ett snabbt föränderligt landskap, men det finns några saker som är gemensamma för de flesta AI-agentramverk som kan hjälpa dig att snabbt skapa prototyper och iterera, nämligen modulkomponenter, samarbetsverktyg och realtidslärande. Låt oss dyka in i dessa:

Använd modulkomponenter

SDK:er som Microsoft Semantic Kernel och LangChain erbjuder förbyggda komponenter såsom AI-anslutningar, promptmallar och minneshantering.

Hur team kan använda dessa: Team kan snabbt sätta ihop dessa komponenter för att skapa en fungerande prototyp utan att börja från grunden, vilket möjliggör snabb experimentering och iteration.

Hur det fungerar i praktiken: Du kan använda en förbyggd parser för att extrahera information från användarinmatning, en minnesmodul för att lagra och hämta data, och en promptgenerator för att interagera med användare, allt utan att behöva bygga dessa komponenter från grunden.

Exempel på kod. Låt oss titta på exempel på hur du kan använda en förbyggd AI-anslutning med Semantic Kernel Python och .Net som använder autofunktionsanrop för att få modellen att svara på användarinmatning:

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

Vad du kan se från detta exempel är hur du kan utnyttja en förbyggd parser för att extrahera nyckelinformation från användarinmatning, såsom ursprung, destination och datum för en flygbokningsförfrågan. Denna modulära metod gör att du kan fokusera på den övergripande logiken.

Utnyttja samarbetsverktyg

Ramverk som CrewAI, Microsoft AutoGen och Semantic Kernel underlättar skapandet av flera agenter som kan arbeta tillsammans.

Hur team kan använda dessa: Team kan designa agenter med specifika roller och uppgifter, vilket gör det möjligt att testa och förfina samarbetsarbetsflöden och förbättra den övergripande systemeffektiviteten.

Hur det fungerar i praktiken: Du kan skapa ett team av agenter där varje agent har en specialiserad funktion, såsom datainhämtning, analys eller beslutsfattande. Dessa agenter kan kommunicera och dela information för att uppnå ett gemensamt mål, såsom att svara på en användarfråga eller slutföra en uppgift.

Exempel på kod (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)

Vad du ser i föregående kod är hur du kan skapa en uppgift som involverar flera agenter som arbetar tillsammans för att analysera data. Varje agent utför en specifik funktion, och uppgiften utförs genom att koordinera agenterna för att uppnå önskat resultat. Genom att skapa dedikerade agenter med specialiserade roller kan du förbättra uppgiftseffektiviteten och prestandan.

Lär dig i realtid

Avancerade ramverk erbjuder kapabiliteter för realtidskontextförståelse och anpassning.

Hur team kan använda dessa: Team kan implementera feedbackloopar där agenter lär sig från interaktioner och justerar sitt beteende dynamiskt, vilket leder till kontinuerlig förbättring och förfining av kapabiliteter.

Hur det fungerar i praktiken: Agenter kan analysera användarfeedback, miljödata och uppgiftsresultat för att uppdatera sin kunskapsbas, justera beslutsalgoritmer och förbättra prestandan över tid. Denna iterativa inlärningsprocess gör det möjligt för agenter att anpassa sig till förändrade förhållanden och användarpreferenser, vilket förbättrar den övergripande systemeffektiviteten.

Vilka är skillnaderna mellan ramverken AutoGen, Semantic Kernel och Azure AI Agent Service?

Det finns många sätt att jämföra dessa ramverk, men låt oss titta på några nyckelskillnader när det gäller deras design, kapabiliteter och målgrupper:

AutoGen

AutoGen är ett open-source-ramverk utvecklat av Microsoft Research’s AI Frontiers Lab. Det fokuserar på händelsedrivna, distribuerade agentiska applikationer, vilket möjliggör flera LLM:er och SLM:er, verktyg och avancerade designmönster för multi-agent.

AutoGen är byggt kring kärnkonceptet agenter, som är autonoma enheter som kan uppfatta sin miljö, fatta beslut och vidta åtgärder för att uppnå specifika mål. Agenter kommunicerar via asynkrona meddelanden, vilket gör att de kan arbeta självständigt och parallellt, vilket förbättrar systemets skalbarhet och responsivitet.

Agenter är baserade på aktörsmodellen. Enligt Wikipedia är en aktör den grundläggande byggstenen för samtidig beräkning. Som svar på ett meddelande det tar emot kan en aktör: fatta lokala beslut, skapa fler aktörer, skicka fler meddelanden och bestämma hur man ska svara på nästa meddelande som tas emot.

Användningsområden: Automatisering av kodgenerering, dataanalysuppgifter och byggande av anpassade agenter för planerings- och forskningsfunktioner.

Här är några viktiga kärnkoncept för AutoGen:

Semantic Kernel + Agent Framework

Semantic Kernel är en företagsklar AI Orchestration SDK. Den består av AI- och minnesanslutningar, tillsammans med ett agentramverk.

Låt oss först täcka några kärnkomponenter:

Dessa fakta lagras sedan i minnessamlingen SummarizedAzureDocs. Detta är ett mycket förenklat exempel, men du kan se hur information kan lagras i minnet för att LLM ska kunna använda det.

Så det är grunderna i Semantic Kernel-ramverket, men hur är det med Agent Framework?

Azure AI Agent Service

Azure AI Agent Service är en nyare funktion som introducerades på Microsoft Ignite 2024. Den möjliggör utveckling och implementering av AI-agenter med mer flexibla modeller, såsom att direkt anropa öppna LLM:er som Llama 3, Mistral och Cohere.

Azure AI Agent Service erbjuder starkare säkerhetsmekanismer för företag och metoder för datalagring, vilket gör den lämplig för företagsapplikationer.

Den fungerar direkt med orkestreringsramverk för flera agenter, såsom AutoGen och Semantic Kernel.

Tjänsten är för närvarande i Public Preview och stöder Python och C# för att bygga agenter.

Med Semantic Kernel Python kan vi skapa en Azure AI Agent med ett användardefinierat 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())

Grundläggande koncept

Azure AI Agent Service har följande grundläggande koncept:

Användningsområden: Azure AI Agent Service är utformad för företagsapplikationer som kräver säker, skalbar och flexibel implementering av AI-agenter.

Vad är skillnaden mellan dessa ramverk?

Det verkar som om det finns mycket överlapp mellan dessa ramverk, men det finns några viktiga skillnader när det gäller deras design, kapacitet och målgrupper:

Fortfarande osäker på vilken du ska välja?

Användningsområden

Låt oss se om vi kan hjälpa dig genom att gå igenom några vanliga användningsområden:

Q: Jag experimenterar, lär mig och bygger proof-of-concept-applikationer med agenter, och jag vill kunna bygga och experimentera snabbt

A: AutoGen skulle vara ett bra val för detta scenario, eftersom det fokuserar på händelsedrivna, distribuerade applikationer med agenter och stöder avancerade designmönster för flera agenter.

Q: Vad gör AutoGen till ett bättre val än Semantic Kernel och Azure AI Agent Service för detta användningsområde?

A: AutoGen är specifikt utformat för händelsedrivna, distribuerade applikationer med agenter, vilket gör det väl lämpat för att automatisera kodgenerering och dataanalysuppgifter. Det erbjuder de nödvändiga verktygen och kapaciteterna för att bygga komplexa system med flera agenter effektivt.

Q: Det låter som att Azure AI Agent Service också skulle kunna fungera här, den har verktyg för kodgenerering och mer?

A: Ja, Azure AI Agent Service är en plattformstjänst för agenter och har inbyggda funktioner för flera modeller, Azure AI Search, Bing Search och Azure Functions. Det gör det enkelt att bygga dina agenter i Foundry Portal och implementera dem i stor skala.

Q: Jag är fortfarande förvirrad, ge mig bara ett alternativ

A: Ett bra val är att först bygga din applikation i Semantic Kernel och sedan använda Azure AI Agent Service för att implementera din agent. Denna metod gör det enkelt att bevara dina agenter samtidigt som du utnyttjar kraften i att bygga system med flera agenter i Semantic Kernel. Dessutom har Semantic Kernel en anslutning i AutoGen, vilket gör det enkelt att använda båda ramverken tillsammans.

Låt oss sammanfatta de viktigaste skillnaderna i en tabell:

Ramverk Fokus Grundläggande koncept Användningsområden
AutoGen Händelsedrivna, distribuerade applikationer med agenter Agenter, Personas, Funktioner, Data Kodgenerering, dataanalysuppgifter
Semantic Kernel Förståelse och generering av mänskligt liknande textinnehåll Agenter, Modulära komponenter, Samarbete Naturlig språkförståelse, innehållsgenerering
Azure AI Agent Service Flexibla modeller, företagsäkerhet, Kodgenerering, Verktygsanrop Modularitet, Samarbete, Processorkestrering Säker, skalbar och flexibel implementering av AI-agenter

Vad är det ideala användningsområdet för vart och ett av dessa ramverk?

Kan jag integrera mina befintliga Azure-verktyg direkt, eller behöver jag fristående lösningar?

Svaret är ja, du kan integrera dina befintliga Azure-verktyg direkt med Azure AI Agent Service, särskilt eftersom den har byggts för att fungera sömlöst med andra Azure-tjänster. Du kan till exempel integrera Bing, Azure AI Search och Azure Functions. Det finns också en djup integration med Azure AI Foundry.

För AutoGen och Semantic Kernel kan du också integrera med Azure-tjänster, men det kan kräva att du anropar Azure-tjänster från din kod. Ett annat sätt att integrera är att använda Azure SDK:er för att interagera med Azure-tjänster från dina agenter. Dessutom, som nämnts, kan du använda Azure AI Agent Service som en orkestrator för dina agenter byggda i AutoGen eller Semantic Kernel, vilket skulle ge enkel åtkomst till Azure-ekosystemet.

Har du fler frågor om AI Agent Frameworks?

Gå med i Azure AI Foundry Discord för att träffa andra som lär sig, delta i öppet hus och få svar på dina frågor om AI-agenter.

Referenser

Föregående lektion

Introduktion till AI-agenter och användningsområden

Nästa lektion

Förstå designmönster för agenter

Ansvarsfriskrivning:
Detta dokument har översatts med hjälp av AI-översättningstjänsten Co-op Translator. Även om vi strävar efter noggrannhet, bör det noteras att automatiserade översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.

This site is open source. Improve this page.