ai-agents-for-beginners

חקירת Microsoft Agent Framework

מסגרת הסוכנים

מבוא

השיעור הזה יכסה:

מטרות הלמידה

בסיום שיעור זה, תדעו כיצד:

דוגמאות קוד

דוגמאות קוד עבור Microsoft Agent Framework (MAF) נמצאות במאגר זה תחת הקבצים xx-python-agent-framework ו-xx-dotnet-agent-framework.

הבנת Microsoft Agent Framework

הקדמת המסגרת

Microsoft Agent Framework (MAF) היא המסגרת המאוחדת של Microsoft לבניית סוכני AI. היא מציעה גמישות לטיפול במגוון רחב של מקרי שימוש סוכניים הנראים הן בסביבות פרודקשן והן במחקר, כולל:

כדי לספק סוכני AI בפרודקשן, MAF כוללת גם תכונות עבור:

Microsoft Agent Framework מתמקדת גם באינטרופרביליות על ידי:

בואו נבחן כיצד תכונות אלו מיושמות על חלק מהמושגים המרכזיים של Microsoft Agent Framework.

המושגים המרכזיים של Microsoft Agent Framework

סוכנים

מסגרת הסוכנים

יצירת סוכנים

יצירת סוכן נעשית על ידי הגדרת שירות ההסקה (LLM Provider), סט הוראות שהסוכן אמור לעקוב אחריהן, ושם מוקצה name:

agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent( instructions="You are good at recommending trips to customers based on their preferences.", name="TripRecommender" )

מעלה משתמש ב-Azure OpenAI, אך ניתן ליצור סוכנים באמצעות מגוון שירותים כולל Microsoft Foundry Agent Service:

AzureAIAgentClient(async_credential=credential).create_agent( name="HelperAgent", instructions="You are a helpful assistant." ) as agent

OpenAI Responses, ChatCompletion APIs

agent = OpenAIResponsesClient().create_agent( name="WeatherBot", instructions="You are a helpful weather assistant.", )

agent = OpenAIChatClient().create_agent( name="HelpfulAssistant", instructions="You are a helpful assistant.", )

או סוכנים מרוחקים באמצעות פרוטוקול A2A:

agent = A2AAgent( name=agent_card.name, description=agent_card.description, agent_card=agent_card, url="https://your-a2a-agent-host" )

הרצת סוכנים

סוכנים מורצים באמצעות המתודות .run או .run_stream עבור תגובות לא-סטרימינג או תגובות סטרימינג.

result = await agent.run("What are good places to visit in Amsterdam?")
print(result.text)

async for update in agent.run_stream("What are the good places to visit in Amsterdam?"):
    if update.text:
        print(update.text, end="", flush=True)

לכל הרצה של סוכן יכולות להיות גם אפשרויות להתאמת פרמטרים כגון max_tokens שהסוכן משתמש בו, tools שהסוכן יכול לקרוא, ואף ה-model עצמו המשמש את הסוכן.

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

כלים

ניתן להגדיר כלים הן בעת הגדרת הסוכן:

def get_attractions( location: Annotated[str, Field(description="The location to get the top tourist attractions for")], ) -> str: """Get the top tourist attractions for a given location.""" return f"The top attractions for {location} are." 


# כאשר יוצרים את ה-ChatAgent ישירות

agent = ChatAgent( chat_client=OpenAIChatClient(), instructions="You are a helpful assistant", tools=[get_attractions]

וגם בעת הרצת הסוכן:


result1 = await agent.run( "What's the best place to visit in Seattle?", tools=[get_attractions] # הכלי מסופק רק עבור ריצה זו )

שרשורי סוכן

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

ליצירת שרשור, הקוד נראה כך:

# צור חוט ביצוע חדש.
thread = agent.get_new_thread() # הפעל את הסוכן באמצעות חוט הביצוע.
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

ניתן אז לסריאליז את השרשור כדי לאחסן אותו לשימוש עתידי:

# צור חוט חדש.
thread = agent.get_new_thread() 

# הרץ את הסוכן עם החוט.

response = await agent.run("Hello, how are you?", thread=thread) 

# בצע סיריאליזציה של החוט לאחסון.

serialized_thread = await thread.serialize() 

# בצע דסיריאליזציה של מצב החוט לאחר טעינה מהאחסון.

resumed_thread = await agent.deserialize_thread(serialized_thread)

Middleware של סוכן

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

Function Middleware

Middleware זה מאפשר לנו לבצע פעולה בין הסוכן לבין פונקציה/כלי שהוא יקרא. דוגמה לשימוש תהיה כאשר תרצה לבצע רישום (logging) על קריאת הפונקציה.

בקוד שלמטה next מגדיר האם יש לקרוא למידלוואר הבא או לפונקציה עצמה.

async def logging_function_middleware(
    context: FunctionInvocationContext,
    next: Callable[[FunctionInvocationContext], Awaitable[None]],
) -> None:
    """Function middleware that logs function execution."""
    # עיבוד מקדים: רישום לפני ביצוע הפונקציה
    print(f"[Function] Calling {context.function.name}")

    # המשך למידלוור הבא או לביצוע הפונקציה
    await next(context)

    # עיבוד לאחר הביצוע: רישום לאחר ביצוע הפונקציה
    print(f"[Function] {context.function.name} completed")

Chat Middleware

Middleware זה מאפשר לנו לבצע או לרשום פעולה בין הסוכן לבין הבקשות ל-LLM.

זה מכיל מידע חשוב כגון ה-messages שנשלחות לשירות ה-AI.

async def logging_chat_middleware(
    context: ChatContext,
    next: Callable[[ChatContext], Awaitable[None]],
) -> None:
    """Chat middleware that logs AI interactions."""
    # עיבוד מקדים: רישום לפני קריאה ל-AI
    print(f"[Chat] Sending {len(context.messages)} messages to AI")

    # המשך לרכיב התווך הבא או לשירות ה-AI
    await next(context)

    # עיבוד לאחר מכן: רישום לאחר תגובת ה-AI
    print("[Chat] AI response received")

זיכרון הסוכן

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

In-Memory Storage

זהו הזיכרון המאוחסן בשרשורים במהלך זמן ריצת היישום.

# צור חוט חדש.
thread = agent.get_new_thread() # הרץ את הסוכן עם החוט.
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

Persistent Messages

זיכרון זה משמש לאחסון היסטוריית שיחה על פני מושבים (sessions) שונים. הוא מוגדר באמצעות chat_message_store_factory :

from agent_framework import ChatMessageStore

# צור מאגר הודעות מותאם אישית
def create_message_store():
    return ChatMessageStore()

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a Travel assistant.",
    chat_message_store_factory=create_message_store
)

Dynamic Memory

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

from agent_framework.mem0 import Mem0Provider

# שימוש ב-Mem0 עבור יכולות זיכרון מתקדמות
memory_provider = Mem0Provider(
    api_key="your-mem0-api-key",
    user_id="user_123",
    application_id="my_app"
)

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a helpful assistant with memory.",
    context_providers=memory_provider
)

נראות של הסוכן

נראות חשובה לבניית מערכות סוכניות אמינות וניתנות לתחזוקה. MAF משתלבת עם OpenTelemetry כדי לספק טרייסינג ומדדים לנראות טובה יותר.

from agent_framework.observability import get_tracer, get_meter

tracer = get_tracer()
meter = get_meter()
with tracer.start_as_current_span("my_custom_span"):
    # עשה משהו
    pass
counter = meter.create_counter("my_custom_counter")
counter.add(1, {"key": "value"})

תזרימי עבודה

MAF מציעה תזרימי עבודה שהם שלבים מוגדרים מראש להשלמת משימה וכוללים סוכני AI כמרכיבים בשלבים אלה.

תזרימי עבודה מורכבים מרכיבים שונים שמאפשרים זרימת בקרה טובה יותר. תזרימי עבודה גם מאפשרים multi-agent orchestration ו-checkpointing כדי לשמור מצבי תזרימ עבודה.

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

Executors

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

Edges

Edges משמשים להגדיר את זרימת ההודעות בתזרימ עבודה. אלה יכולים להיות:

Direct Edges - חיבורים פשוטים אחד-ל-אחד בין Executors:

from agent_framework import WorkflowBuilder

builder = WorkflowBuilder()
builder.add_edge(source_executor, target_executor)
builder.set_start_executor(source_executor)
workflow = builder.build()

Conditional Edges - מופעלים לאחר שמתקיים תנאי מסוים. לדוגמה, כאשר חדרי המלון אינם זמינים, Executor יכול להציע אפשרויות אחרות.

Switch-case Edges - מנתבים הודעות ל-Executors שונים על בסיס תנאים מוגדרים. לדוגמה, אם ללקוח הנוסע יש גישת עדיפות והמשימות שלו יטופלו באמצעות תזרימ עבודה אחר.

Fan-out Edges - שולחים הודעה אחת למספר יעדים.

Fan-in Edges - אוספים הודעות מרובות ממספר Executors ושולחים ליעד אחד.

אירועים

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

תבניות מתקדמות של MAF

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

דוגמאות קוד

דוגמאות קוד עבור Microsoft Agent Framework נמצאות במאגר זה תחת הקבצים xx-python-agent-framework ו-xx-dotnet-agent-framework.

יש לכם שאלות נוספות לגבי Microsoft Agent Framework?

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

הצהרת אחריות: מסמך זה תורגם בעזרת שירות תרגום מבוסס בינה מלאכותית Co-op Translator (https://github.com/Azure/co-op-translator). אף שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי‑דיוקים. המסמך המקורי בשפתו מהווה את הגרסה הסמכותית. למידע קריטי מומלץ להיעזר בתרגום מקצועי שנערך על ידי מתרגם אנושי. איננו אחראים לכל אי‑הבנות או פרשנויות שגויות הנובעות משימוש בתרגום זה.

This site is open source. Improve this page.