ai-agents-for-beginners

חקר מסגרות סוכנים של AI

(לחצו על התמונה למעלה לצפייה בסרטון של השיעור הזה)

חקר מסגרות סוכנים של AI

מסגרות סוכנים של AI הן פלטפורמות תוכנה שנועדו לפשט את יצירתם, פריסתם וניהולם של סוכני AI. מסגרות אלו מספקות למפתחים רכיבים מוכנים מראש, הפשטות וכלים שמייעלים את פיתוחם של מערכות AI מורכבות.

מסגרות אלו עוזרות למפתחים להתמקד בהיבטים הייחודיים של היישומים שלהם על ידי מתן גישות סטנדרטיות לאתגרים נפוצים בפיתוח סוכני AI. הן משפרות את יכולת ההרחבה, הנגישות והיעילות בבניית מערכות AI.

מבוא

השיעור הזה יעסוק ב:

מטרות למידה

מטרות השיעור הן לעזור לכם להבין:

מהן מסגרות סוכנים של AI ומה הן מאפשרות למפתחים לעשות?

מסגרות AI מסורתיות יכולות לעזור לכם לשלב AI באפליקציות שלכם ולשפר אותן בדרכים הבאות:

זה נשמע נהדר, נכון? אז למה אנחנו צריכים את מסגרות הסוכנים של AI?

מסגרות סוכנים של AI מייצגות משהו מעבר למסגרות AI רגילות. הן נועדו לאפשר יצירת סוכנים חכמים שיכולים לתקשר עם משתמשים, סוכנים אחרים והסביבה כדי להשיג מטרות ספציפיות. סוכנים אלו יכולים להציג התנהגות אוטונומית, לקבל החלטות ולהתאים את עצמם לתנאים משתנים. בואו נבחן כמה יכולות מרכזיות שמאפשרות מסגרות סוכנים של AI:

לסיכום, סוכנים מאפשרים לכם לעשות יותר, לקחת את האוטומציה לשלב הבא, ליצור מערכות חכמות יותר שיכולות להסתגל וללמוד מהסביבה שלהן.

כיצד ליצור אב-טיפוס במהירות, לשפר ולשדרג את יכולות הסוכן?

זהו תחום שמתפתח במהירות, אך ישנם דברים משותפים לרוב מסגרות הסוכנים של AI שיכולים לעזור לכם ליצור אב-טיפוס ולשדרג במהירות, כמו רכיבים מודולריים, כלים לשיתוף פעולה ולמידה בזמן אמת. בואו נעמיק בהם:

שימוש ברכיבים מודולריים

ערכות SDK כמו Microsoft Semantic Kernel ו-LangChain מציעות רכיבים מוכנים מראש כמו מחברים ל-AI, תבניות הנחיה וניהול זיכרון.

כיצד צוותים יכולים להשתמש בזה: צוותים יכולים להרכיב במהירות את הרכיבים הללו כדי ליצור אב-טיפוס פונקציונלי מבלי להתחיל מאפס, מה שמאפשר ניסויים ושדרוגים מהירים.

כיצד זה עובד בפועל: ניתן להשתמש במנתח מוכן מראש כדי לחלץ מידע מקלט משתמש, מודול זיכרון לאחסון ושליפת נתונים, וגenerator הנחיות כדי לתקשר עם משתמשים, כל זאת מבלי לבנות את הרכיבים הללו מאפס.

דוגמת קוד. בואו נבחן דוגמאות כיצד ניתן להשתמש במחבר AI מוכן מראש עם Semantic Kernel Python ו-.Net שמשתמש בקריאה אוטומטית לפונקציות כדי שהמודל יגיב לקלט משתמש:

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

מה שאתם רואים בדוגמה הזו הוא כיצד ניתן לנצל מנתח מוכן מראש כדי לחלץ מידע מרכזי מקלט משתמש, כמו מקור, יעד ותאריך של בקשת הזמנת טיסה. הגישה המודולרית הזו מאפשרת לכם להתמקד בלוגיקה ברמה גבוהה.

ניצול כלים לשיתוף פעולה

מסגרות כמו CrewAI, Microsoft AutoGen ו-Semantic Kernel מאפשרות יצירת סוכנים מרובים שיכולים לעבוד יחד.

כיצד צוותים יכולים להשתמש בזה: צוותים יכולים לעצב סוכנים עם תפקידים ומשימות ספציפיים, מה שמאפשר להם לבדוק ולשפר תהליכי עבודה שיתופיים ולשפר את יעילות המערכת הכוללת.

כיצד זה עובד בפועל: ניתן ליצור צוות של סוכנים שבו לכל סוכן יש פונקציה מיוחדת, כמו שליפת נתונים, ניתוח או קבלת החלטות. סוכנים אלו יכולים לתקשר ולשתף מידע כדי להשיג מטרה משותפת, כמו מענה לשאלת משתמש או השלמת משימה.

דוגמת קוד (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)

מה שאתם רואים בקוד הקודם הוא כיצד ניתן ליצור משימה שכוללת סוכנים מרובים שעובדים יחד לניתוח נתונים. כל סוכן מבצע פונקציה ספציפית, והמשימה מתבצעת על ידי תיאום הסוכנים כדי להשיג את התוצאה הרצויה. על ידי יצירת סוכנים ייעודיים עם תפקידים מיוחדים, ניתן לשפר את יעילות המשימה וביצועיה.

למידה בזמן אמת

מסגרות מתקדמות מספקות יכולות להבנה והסתגלות בהקשר בזמן אמת.

כיצד צוותים יכולים להשתמש בזה: צוותים יכולים ליישם לולאות משוב שבהן סוכנים לומדים מאינטראקציות ומעדכנים את התנהגותם באופן דינמי, מה שמוביל לשיפור מתמשך ושדרוג יכולות.

כיצד זה עובד בפועל: סוכנים יכולים לנתח משוב משתמשים, נתוני סביבה ותוצאות משימות כדי לעדכן את בסיס הידע שלהם, להתאים אלגוריתמים לקבלת החלטות ולשפר ביצועים לאורך זמן. תהליך הלמידה האיטרטיבי הזה מאפשר לסוכנים להסתגל לתנאים משתנים ולהעדפות משתמשים, ומשפר את יעילות המערכת הכוללת.

מה ההבדלים בין המסגרות AutoGen, Semantic Kernel ו-Azure AI Agent Service?

ישנן דרכים רבות להשוות בין המסגרות הללו, אך בואו נבחן כמה הבדלים מרכזיים מבחינת העיצוב, היכולות ומקרי השימוש המיועדים:

AutoGen

AutoGen היא מסגרת קוד פתוח שפותחה על ידי מעבדת AI Frontiers של Microsoft Research. היא מתמקדת ביישומים מבוססי אירועים, מבוזרים וסוכניים, ומאפשרת שימוש במספר LLMs ו-SLMs, כלים ותבניות עיצוב מתקדמות של סוכנים מרובים.

AutoGen בנויה סביב הרעיון המרכזי של סוכנים, שהם ישויות אוטונומיות שיכולות לתפוס את סביבתן, לקבל החלטות ולנקוט פעולות כדי להשיג מטרות ספציפיות. סוכנים מתקשרים באמצעות הודעות אסינכרוניות, מה שמאפשר להם לעבוד באופן עצמאי ובמקביל, ומשפר את יכולת ההרחבה והתגובה של המערכת.

סוכנים מבוססים על מודל השחקן. לפי ויקיפדיה, שחקן הוא הבלוק הבסיסי של חישוב מקבילי. בתגובה להודעה שהוא מקבל, שחקן יכול: לקבל החלטות מקומיות, ליצור שחקנים נוספים, לשלוח הודעות נוספות ולקבוע כיצד להגיב להודעה הבאה שיקבל.

מקרי שימוש: אוטומציה של יצירת קוד, משימות ניתוח נתונים ובניית סוכנים מותאמים אישית לפונקציות תכנון ומחקר.

הנה כמה מושגים מרכזיים של AutoGen:

Semantic Kernel + מסגרת סוכנים

Semantic Kernel הוא SDK לתזמור AI ברמה ארגונית. הוא מורכב ממחברים ל-AI ולזיכרון, יחד עם מסגרת סוכנים.

בואו נתחיל עם כמה רכיבים מרכזיים:

העובדות הללו נשמרות לאחר מכן באוסף הזיכרון SummarizedAzureDocs. זהו דוגמה מאוד פשוטה, אך ניתן לראות כיצד ניתן לשמור מידע בזיכרון לשימוש של ה-LLM.

אז אלו הם היסודות של מסגרת Semantic Kernel, ומה לגבי מסגרת הסוכנים?

שירות הסוכנים של Azure AI

שירות הסוכנים של Azure AI הוא תוספת חדשה יחסית, שהוצגה בכנס Microsoft Ignite 2024. הוא מאפשר פיתוח ופריסה של סוכני AI עם מודלים גמישים יותר, כמו קריאה ישירה ל-LLMs בקוד פתוח כגון Llama 3, Mistral, ו-Cohere.

שירות הסוכנים של Azure AI מספק מנגנוני אבטחה חזקים ושיטות אחסון נתונים, מה שהופך אותו למתאים ליישומים ארגוניים.

השירות עובד באופן מובנה עם מסגרות תזמור רב-סוכנים כמו AutoGen ו-Semantic Kernel.

השירות נמצא כרגע בתצוגה ציבורית ותומך ב-Python וב-C# לבניית סוכנים.

באמצעות Semantic Kernel Python, ניתן ליצור סוכן Azure AI עם תוסף מוגדר על ידי המשתמש:

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

מושגים מרכזיים

שירות הסוכנים של Azure AI כולל את המושגים המרכזיים הבאים:

שימושים: שירות הסוכנים של Azure AI מיועד ליישומים ארגוניים שדורשים פריסה של סוכני AI מאובטחים, ניתנים להרחבה וגמישים.

מה ההבדל בין המסגרות הללו?

נראה שיש הרבה חפיפה בין המסגרות הללו, אך ישנם הבדלים מרכזיים מבחינת העיצוב, היכולות, והשימושים המיועדים:

עדיין לא בטוחים מה לבחור?

שימושים

בואו נראה אם נוכל לעזור לכם על ידי מעבר על כמה שימושים נפוצים:

ש: אני מתנסה, לומד ובונה יישומי סוכנים כהוכחת יכולת, ואני רוצה לבנות ולהתנסות במהירות

ת: AutoGen תהיה בחירה טובה לתרחיש זה, מכיוון שהיא מתמקדת ביישומים סוכניים מבוססי אירועים ומבוזרים ותומכת בדפוסי עיצוב מתקדמים של רב-סוכנים.

ש: מה הופך את AutoGen לבחירה טובה יותר מ-Semantic Kernel ושירות הסוכנים של Azure AI עבור שימוש זה?

ת: AutoGen תוכננה במיוחד עבור יישומים סוכניים מבוססי אירועים ומבוזרים, מה שהופך אותה למתאימה היטב לאוטומציה של משימות יצירת קוד וניתוח נתונים. היא מספקת את הכלים והיכולות הנדרשים לבניית מערכות רב-סוכנים מורכבות ביעילות.

ש: נשמע שגם שירות הסוכנים של Azure AI יכול לעבוד כאן, יש לו כלים ליצירת קוד ועוד?

ת: כן, שירות הסוכנים של Azure AI הוא שירות פלטפורמה עבור סוכנים ומוסיף יכולות מובנות למודלים מרובים, Azure AI Search, Bing Search ו-Azure Functions. הוא מקל על בניית הסוכנים בפורטל Foundry ופריסתם בקנה מידה רחב.

ש: אני עדיין מבולבל, פשוט תנו לי אפשרות אחת

ת: בחירה מצוינת היא לבנות את האפליקציה שלכם ב-Semantic Kernel תחילה ואז להשתמש בשירות הסוכנים של Azure AI כדי לפרוס את הסוכן שלכם. גישה זו מאפשרת לכם לשמר את הסוכנים שלכם בקלות תוך ניצול הכוח לבנות מערכות רב-סוכנים ב-Semantic Kernel. בנוסף, ל-Semantic Kernel יש מחבר ב-AutoGen, מה שמקל על השימוש בשתי המסגרות יחד.

בואו נסכם את ההבדלים המרכזיים בטבלה:

מסגרת מיקוד מושגים מרכזיים שימושים
AutoGen יישומים סוכניים מבוססי אירועים ומבוזרים סוכנים, פרסונות, פונקציות, נתונים יצירת קוד, משימות ניתוח נתונים
Semantic Kernel הבנה ויצירת תוכן דמוי אנושי סוכנים, רכיבים מודולריים, שיתוף פעולה הבנת שפה טבעית, יצירת תוכן
שירות הסוכנים של Azure AI מודלים גמישים, אבטחה ארגונית, יצירת קוד, קריאת כלים מודולריות, שיתוף פעולה, תזמור תהליכים פריסה מאובטחת, ניתנת להרחבה וגמישה של סוכני AI

מהו השימוש האידיאלי עבור כל אחת מהמסגרות הללו?

האם אני יכול לשלב את הכלים הקיימים שלי באקוסיסטם של Azure ישירות, או שאני צריך פתרונות עצמאיים?

התשובה היא כן, ניתן לשלב את הכלים הקיימים שלכם באקוסיסטם של Azure ישירות עם שירות הסוכנים של Azure AI במיוחד, מכיוון שהוא נבנה לעבוד בצורה חלקה עם שירותי Azure אחרים. לדוגמה, ניתן לשלב Bing, Azure AI Search, ו-Azure Functions. יש גם אינטגרציה עמוקה עם Azure AI Foundry.

עבור AutoGen ו-Semantic Kernel, ניתן גם לשלב עם שירותי Azure, אך ייתכן שתצטרכו לקרוא לשירותי Azure מתוך הקוד שלכם. דרך נוספת לשלב היא להשתמש ב-SDKs של Azure כדי לתקשר עם שירותי Azure מתוך הסוכנים שלכם. בנוסף, כמו שהוזכר, ניתן להשתמש בשירות הסוכנים של Azure AI כמנהל תזמור עבור הסוכנים שנבנו ב-AutoGen או Semantic Kernel, מה שיאפשר גישה קלה לאקוסיסטם של Azure.

יש לכם עוד שאלות על מסגרות סוכני AI?

הצטרפו ל-Discord של Azure AI Foundry כדי לפגוש לומדים אחרים, להשתתף בשעות קבלה ולקבל תשובות לשאלות שלכם על סוכני AI.

מקורות

שיעור קודם

מבוא לסוכני AI ושימושים

שיעור הבא

הבנת דפוסי עיצוב סוכניים

כתב ויתור:
מסמך זה תורגם באמצעות שירות תרגום מבוסס בינה מלאכותית Co-op Translator. למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עשויים להכיל שגיאות או אי דיוקים. המסמך המקורי בשפתו המקורית צריך להיחשב כמקור סמכותי. עבור מידע קריטי, מומלץ להשתמש בתרגום מקצועי על ידי אדם. איננו נושאים באחריות לאי הבנות או לפרשנויות שגויות הנובעות משימוש בתרגום זה.

This site is open source. Improve this page.