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?

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

AutoGen

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

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

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

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

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

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

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

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

שירות Azure AI Agent

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

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

השירות עובד באופן מובנה עם מסגרות תזמור מרובות-סוכנים כמו 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 Agent יש את המושגים המרכזיים הבאים:

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

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

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

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

מקרי שימוש

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

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

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

ש: מה הופך את AutoGen לבחירה טובה יותר מ-Semantic Kernel ו-Azure AI Agent Service למקרה שימוש זה?

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

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

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

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

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

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

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

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

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

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

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

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

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

מקורות

שיעור קודם

מבוא לסוכני AI ומקרי שימוש

שיעור הבא

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

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

This site is open source. Improve this page.