OpenAI Builder

הכירו את ה-Responses API, האבולוציה החדשה של OpenAI שנועדה להחליף בהדרגה את ממשק ה-Chat Completions המוכר. בעוד ש-Chat Completions שירת אותנו נאמנה בעידן של שיחות פשוטות, עולם הפיתוח הנוכחי נע לכיוון של סוכני AI עצמאיים (Agents) ומערכות מורכבות המשלבות כלים (Tools) וקבלת החלטות דינמית. ה-Responses API נולד כדי לתת מענה מובנה בדיוק לצורך הזה, כפי שניתן לראות בעדכונים האחרונים של OpenAI Agents v0.16.0.

מדוע השינוי הזה קריטי? בעבר, כדי לממש סוכן חכם שיודע להפעיל פונקציות (Tool Calling), נדרשנו לכתוב לולאות קוד מורכבות שמנהלות את מצב השיחה (State), מפענחות את קריאות הכלים, מריצות אותן ומחזירות את התוצאות למודל. ה-Responses API מפשט את התהליך הזה באופן דרמטי על ידי ניהול מחזור החיים של הריצה (Run Lifecycle) בצד השרת, מה שמאפשר אינטגרציה חלקה ומהירה יותר עם ספריות סוכנים מודרניות כמו smolagents.

כדי להתחיל לעבוד עם ה-API החדש, אנו משתמשים בשיטות העבודה המעודכנות של ה-SDK. הנה דוגמה בסיסית המציגה כיצד ליצור תגובה תוך שימוש ביכולות החדשות:

from openai import OpenAI

client = OpenAI()

# שימוש ב-Responses API החדש ליצירת אינטראקציה מנוהלת
response = client.responses.create(
    model="gpt-4o",
    input=[{"role": "user", "content": "מהם היתרונות של Responses API?"}],
    tools=[{"type": "web_search"}]  # שילוב כלים מובנה
)

print(response.output[0].text)

המעבר ל-Responses API מאפשר לכם לכתוב קוד נקי יותר, חסין לשגיאות וקל לתחזוקה. במקום להתעסק בלוגיקה של "איך להריץ את המודל", אתם יכולים להתרכז ב"מה המודל צריך לעשות". הממשק החדש תומך בצורה טבעית יותר בסטרימינג (Streaming) של תגובות ובניהול הקשר (Context) ארוך טווח, מה שהופך אותו לבחירה האידיאלית עבור פרויקטים מתקדמים. למידע נוסף על הארכיטקטורה של סוכנים אלו, מומלץ לעיין גם ב-OpenAI Agents v0.17.0.

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

ה-OpenAI Agents SDK הוא כלי פיתוח רשמי המאפשר לבנות מערכות מרובות סוכנים (Multi-Agent Systems) בצורה פשוטה, מובנית ויציבה. במקום להסתמך על קריאות API בודדות ומורכבות, ה-SDK מספק ארכיטקטורה ממוקדת-סוכנים המאפשרת להגדיר ישויות עצמאיות בעלות תפקידים מוגדרים, שיכולות לשתף פעולה, לנהל זיכרון ולבצע משימות מורכבות בעולם האמיתי.

ה-SDK מבוסס על ארבעה עקרונות ליבה: Tools (כלים) המאפשרים לסוכנים להריץ קוד או לגשת ל-APIs חיצוניים; Handoffs (העברות) המאפשרים לסוכן אחד להעביר את השיחה וההקשר לסוכן אחר המתמחה בנושא הספציפי; Guardrails (מגבלות בטיחות) המבטיחים שהסוכנים פועלים בתוך גבולות מוגדרים מראש; ו-Sessions (סשנים) המנהלים את מצב השיחה (State) והזיכרון לאורך זמן בצורה אוטומטית.

השימוש ב-SDK זה חיוני כאשר רוצים לבנות אפליקציות AI מורכבות הדורשות התמחות. במקום לבנות סוכן אחד ענק שמנסה לעשות הכל (ולעיתים קרובות נכשל או חורג ממגבלת הטוקנים), אנו מחלקים את העבודה בין סוכנים קטנים וממוקדים. היתרון הגדול של ה-SDK הרשמי על פני ספריות צד-שלישי כמו LangGraph או AutoGen הוא האינטגרציה הטבעית והאופטימיזציה המובנית למודלים של OpenAI, לצד ניהול Tracing מובנה.

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

from openai_agents import Agent, Runner

finance_agent = Agent(name="FinanceAgent", instructions="You handle money queries.")

def transfer_to_finance():
    return finance_agent

triage_agent = Agent(
    name="TriageAgent",
    instructions="Determine if the user needs finance help.",
    tools=[transfer_to_finance]
)

result = Runner.run(triage_agent, user_input="I need help with my bill")
print(result.active_agent.name)

כדי להעמיק ביכולות החדשות של ה-SDK, מומלץ לעיין בתיעוד השחרור של גרסה OpenAI Agents v0.16.0 שהציגה את יסודות הניהול של סוכנים וסשנים, וכן בעדכון האחרון OpenAI Agents v0.17.2 המציג שיפורים בניהול ה-State וה-Traces של הריצות.

הצעד הבא שלכם הוא לשכפל את מאגר הקוד הרשמי OpenAI Agents Python (או את גרסת ה-JS/TS ב-OpenAI Agents JS אם אתם מפתחים ל-Web), להריץ את דוגמת ה-Triage המובנית בתיקיית ה-examples, ולהוסיף לה כלי (Tool) משלכם שמבצע קריאת API אמיתית.

טכנולוגיית ה-Realtime API מייצגת קפיצת מדרגה משמעותית באינטראקציה בין אדם למכונה, ומאפשרת תקשורת דו-כיוונית ישירה של קול לקול (speech-to-speech) עם שיהוי (latency) נמוך במיוחד. בניגוד לגישות המסורתיות שדרשו שרשור של שלושה מודלים נפרדים (Speech-to-Text, LLM, ו-Text-to-Speech), ה-Realtime API של OpenAI ומודלים מתקדמים אחרים מעבדים את גלי הקול ישירות ומייצרים פלט קולי באופן נייטיב. הדבר מאפשר שיחה זורמת, קטועה (interrupted) באופן טבעי, וחוויית משתמש אנושית לחלוטין.

הצורך בפתרון זה עולה כאשר בונים סוכני קול חכמים (Voice Agents) הדורשים תגובה מיידית, כגון מוקדי שירות לקוחות, עוזרים אישיים אינטראקטיביים, או מערכות למידת שפות. היתרון העצום של ה-Realtime API טמון ביכולת לשלב Function Calling בזמן אמת. המשמעות היא שהסוכן הקולי יכול לא רק לדבר, אלא גם להפעיל פונקציות במערכת שלכם (כמו שליפת נתונים ממסד הנתונים או ביצוע פעולה באפליקציה) תוך כדי שיחה, ולעדכן את המשתמש בתוצאות ללא שיהוי מורגש.

העבודה עם Realtime API מתבצעת לרוב מעל פרוטוקול WebSockets המאפשר הזרמת נתונים (streaming) דו-כיוונית של אודיו ואירועים (events). ספריות חדשות כמו OpenAI Agents (py) v0.17.0 או גרסת OpenAI Agents (py) v0.16.0 מפשטות את ניהול מצב השיחה (session state) והגדרת הכלים (tools) שהסוכן יכול להפעיל בזמן אמת.

הנה דוגמה בסיסית המציגה כיצד לאתחל חיבור Realtime ולקשר אליו כלי (tool) פשוט באמצעות ה-SDK החדש של OpenAI:

from openai import OpenAI

client = OpenAI()

async def get_weather(location: str):
    return f"The weather in {location} is sunny."

session = await client.beta.realtime.sessions.create(
    model="gpt-4o-realtime-preview",
    modalities=["audio", "text"],
    instructions="You are a helpful voice assistant.",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"location": {"type": "string"}}}
    }]
)

בפיתוח מערכות Realtime מתקדמות, תתקלו באתגרים מורכבים כמו ניהול חציצות קול (audio buffering), זיהוי קטיעות שיחה מצד המשתמש (barge-in handling), וסנכרון מצב ה-UI בזמן שהסוכן מדבר ומבצע פעולות ברקע. לשם כך, מומלץ להכיר את הארכיטקטורה של סוכנים מבוססי אירועים (event-driven agents) המאפשרת להאזין לאירועים ספציפיים מהשרת ולהגיב אליהם בצורה אסינכרונית.

הצעד הבא שלכם להתנסות מעשית הוא להוריד ולהריץ את פרויקט ה-Starter הרשמי: OpenAI Realtime Console. פרויקט זה מספק ממשק React מלא המציג כיצד לקלוט אודיו מהמיקרופון, לשלוח אותו ל-Realtime API, לנהל את ה-Websocket, ולהציג ויזואליזציה של גלי הקול והפעלת הפונקציות בזמן אמת.

Function calling (קריאה לפונקציות) הוא אחד הכלים החזקים ביותר בעולם ה-AI כיום, המאפשר למודלי שפה גדולים (LLMs) לא רק לייצר טקסט, אלא לפעול בעולם האמיתי. במקום שהמודל ינחש תשובות, הוא יכול לזהות מתי נדרש מידע חיצוני או ביצוע פעולה, ולנסח בקשה מובנית (Structured Output) המיועדת להרצה על ידי קוד חיצוני. המודל עצמו אינו מריץ את הקוד, אלא מחזיר אובייקט JSON המגדיר את שם הפונקציה והפרמטרים הנדרשים להפעלתה.

מדוע זה קריטי? ללא Function calling, מודלים מוגבלים למידע שעליו הם אומנו. באמצעות דפוס זה (Tool use patterns), אנו יכולים לחבר את המודל למאגרי מידע בזמן אמת, ל-APIs חיצוניים, למערכות קבצים או לכל כלי חישובי אחר. בנוסף, השימוש ב-Structured Outputs מבטיח שהתשובה שהמודל מחזיר תתאים בדיוק לסכמה (Schema) שהגדרנו מראש, מה שמונע שגיאות פענוח (parsing) ומאפשר אינטגרציה חלקה ובטוחה במערכות תוכנה פרודקשן.

תהליך העבודה מבוסס על הגדרת "כלים" (Tools) כחלק מה-Prompt או ה-API call. אנו מספקים למודל תיאור מילולי של הפונקציה ותיאור של הפרמטרים שלה בפורמט JSON Schema. המודל מנתח את בקשת המשתמש, מחליט באיזה כלי להשתמש, ומייצר את ה-JSON המתאים. לאחר מכן, הקוד שלנו מריץ את הפונקציה בפועל ומחזיר את התוצאה למודל, כדי שינסח את התשובה הסופית למשתמש.

נראה דוגמה פשוטה ב-Python המדגימה הגדרת כלי לקבלת מזג אוויר באמצעות ה-SDK של OpenAI:

tools = [{
    "type": "function",
    "function": {
        "name": "get_current_weather",
        "description": "Get the current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "The city, e.g. San Francisco"}
            },
            "required": ["location"]
        }
    }
}]

הטכנולוגיה הזו מתפתחת במהירות עצומה. ספריות מודרניות כמו smolagents v1.22.0 של Hugging Face מציעות דרכים קלות ומהירות יותר להפעלת סוכנים חכמים המבוססים על קריאה לפונקציות וכתיבת קוד דינמית. במקביל, עדכונים כמו OpenAI Agents py v0.17.0 מפשטים את ניהול מחזור החיים של סוכנים מרובי-כלים (Multi-agent systems).

הצעד הבא שלכם: כדי להתחיל להתנסות באופן מעשי ב-Structured Outputs ו-Function calling, אנו ממליצים לשכפל את מאגר הדוגמאות הרשמי Structured Outputs Examples של OpenAI. שם תוכלו למצוא מחברות Jupyter מוכנות להרצה המציגות כיצד להבטיח קבלת פלט במבנה JSON מדויק ללא פשרות, ולשלב אותו באפליקציות שלכם.