LangChain ו-LangGraph

פיתוח עם מודלי שפה גדולים (LLM) מתחיל בדרך כלל בלולאת בקשה-תגובה פשוטה. אך ברגע שהמשימה חורגת מגבולות צ'אטבוט פשוט ודורשת מהמודל לבצע פעולות ממשיות — כמו שילוב כלים (tools) חיצוניים, עבודה עם מסדי נתונים או גישה למערכת הקבצים — אנו נתקלים באתגר יסודי. ה-API הסטנדרטי של המודל הוא חסר מצב (stateless) מטבעו ואין לו מנגנונים מובנים לניהול לוגיקה מורכבת.

משימה שנראית פשוטה, כמו "נתח את הקובץ הזה, מצא נתונים רלוונטיים באינטרנט והפק דוח", הופכת לאתגר תזמור (orchestration) מורכב:

• כיצד מנהלים מצב (state) ומעבירים הקשר (context) בין קריאות מרובות ל-LLM?
• כיצד מממשים לוגיקה מחזורית (cyclical), שבה סוכן מקיים אינטראקציה חוזרת ונשנית עם כלים עד להשגת המטרה?
• כיצד מתקננים חיבורים למודלים שונים (OpenAI, Gemini, מקומיים) ולכלים, מבלי לשכתב את הקוד בכל פעם?

LangChain ו-LangGraph נוצרו כדי לפשט את הפיתוח של מערכות כאלה ולספק למפתחים גישה סטנדרטית לאתגר התזמור הזה:

• LangChain מספק ערכת כלים מאוחדת: ממשקים סטנדרטיים למודלים, רכיבים לפרומפטים וכלים.
• LangGraph היא מסגרת פיתוח (framework) הבנויה על גבי LangChain, המאפשרת לבנות את לוגיקת קבלת ההחלטות של הסוכן כגרף מצבים (state graph), ובכך פותרת באלגנטיות את בעיית הלולאות וההסתעפויות.

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

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

בעולם של סוכני בינה מלאכותית:

• LangChain הוא ערכת קוביות הלגו המתקדמת שלכם.
• LangGraph הוא ספר ההוראות המשוכלל המאפשר לכם להרכיב מהקוביות הללו לא רק מודלים סטטיים, אלא מנגנונים דינמיים ו'חכמים' המסוגלים לקבל החלטות.

…

בואו נפרק כל אחד מהכלים הללו בנפרד.

חלק 1: LangChain — ארגז הכלים לעבודה עם LLMs

המטרה העיקרית של LangChain: לפשט ולתקנן את האינטראקציה בין הקוד שלכם למודלי שפה גדולים (LLMs). הוא מספק רכיבים מוכנים לשימוש ("קוביות") לפתרון משימות נפוצות.

רכיבי מפתח ב-LangChain (ה"קוביות" שלנו):

1. מודלים (Models)
אלו הן "עטיפות" (wrappers) לאינטראקציה ישירה עם רשתות נוירונים. LangChain מחלק אותם לשני סוגים:

• LLMs: הממשק הישן יותר. מקבל מחרוזת טקסט כקלט, ומחזיר מחרוזת טקסט.
  • דוגמה: llm.invoke("What color is the sky?") ← "The sky is blue."
• ChatModels: הממשק המודרני והחזק יותר. עובד עם רשימת הודעות (HumanMessage, AIMessage, SystemMessage). זה מאפשר למודל להבין טוב יותר את ההקשר של השיחה.
  • דוגמה: chat.invoke([HumanMessage(content="What color is the sky?")]) ← AIMessage(content="The sky is usually blue...")

LangChain מאחד את ה-API. אתם לא צריכים ללמוד איך לעבוד בנפרד עם OpenAI, Gemini או Ollama מקומי. אתם פשוט מחליפים אובייקט אחד כמו ChatOpenAI ב-ChatGoogleGenerativeAI או ChatOllama, ושאר הקוד שלכם ממשיך לעבוד.

2. פרומפטים (Prompts)
אלו הן תבניות לבקשות שלכם למודל. במקום להרכיב ידנית את טקסט הבקשה בכל פעם, אתם יוצרים תבנית עם משתנים.

from langchain_core.prompts import ChatPromptTemplate

template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant that translates text into {output_language}."),
    ("human", "{text_to_translate}")
])

prompt_value = template.invoke({"output_language": "French", "text_to_translate": "I love programming."})

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

3. שרשראות (Chains ושפת LCEL)
זהו הלב של LangChain המוקדם. שרשרת היא חיבור רציף של מספר רכיבים. כיום, משתמשים לשם כך ב-LangChain Expression Language (LCEL), שנראה כמו צינור (|).

השרשרת הפשוטה ביותר: פרומפט | מודל.

chain = template | get_gemini_llm()
response = chain.invoke({"output_language": "German", "text_to_translate": "Hello, world!"})
# response.content יכיל "Hallo, Welt!"

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

4. מנתחי פלט (Output Parsers)
מודלים מחזירים טקסט, אבל ביישומים אנחנו לעיתים קרובות צריכים נתונים מובנים (JSON, רשימה, מספר). מנתחי הפלט ממירים את תגובת הטקסט ה"גולמית" של המודל לפורמט הרצוי.

from langchain_core.output_parsers import JsonOutputParser

# ... יוצרים פרומפט שמבקש מהמודל להשיב בפורמט JSON
parser = JsonOutputParser()
chain = template | get_openai_llm() | parser

# כעת chain.invoke(...) לא יחזיר אובייקט טקסט, אלא מילון פייתון (dict)

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

5. כלים (Tools)
זה מה שנותן למודל "ידיים". כלי הוא כל פונקציה שסוכן יכול להפעיל. זה יכול להיות:

• חיפוש באינטרנט (TavilySearch, BraveSearch).
• מחשבון.
• פונקציה לקריאת קובץ מהדיסק.
• קריאה ל-API הפנימי שלכם.

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

---

חלק 2: LangGraph — המנצח (Orchestrator) ליצירת סוכנים

אם LangChain הוא ערכת החלקים, אז LangGraph הוא מערכת הבקרה שמחליטה באיזה חלק להשתמש ומתי.

הבעיה ש-LangGraph פותר: שרשראות קלאסיות ב-LangChain הן לינאריות. הן הולכות מנקודה א' לנקודה ב'. אבל משימות אמיתיות אינן לינאריות. הן דורשות לולאות, הסתעפויות וקבלת החלטות.

לדוגמה, סוכן-חוקר חייב:

1. להבין את הבקשה.
2. להחליט: האם יש צורך בחיפוש באינטרנט?
3. אם כן ← להשתמש בכלי החיפוש.
4. לנתח את התוצאות.
5. להחליט: האם המידע מספיק?
6. אם לא ← לחזור לשלב 3 עם שאילתה מדויקת יותר (זו לולאה).
7. אם כן ← לייצר את התשובה הסופית.

לוגיקה מורכבת כזו לא ניתנת לתיאור באמצעות שרשרת פשוטה.

הרעיון המרכזי של LangGraph: להציג את פעולת הסוכן כגרף מצבים (או תרשים זרימה).

רכיבי מפתח ב-LangGraph (רכיבי תרשים הזרימה):

1. מצב (State)
זהו הזיכרון המרכזי של כל התהליך. בדרך כלל זהו מילון פייתון (TypedDict) המועבר משלב אחד לשני. כל שלב יכול לקרוא ממנו נתונים ולכתוב אליו נתונים חדשים.

דוגמה למצב: {"user_request": "...", "search_results": [], "final_answer": None}.

2. צמתים (Nodes)
אלו הם בלוקי הפעולה בתרשים הזרימה שלכם. כל צומת הוא פונקציית פייתון אשר:

• מקבלת את המצב הנוכחי כקלט.
• מבצעת פעולה כלשהי (קוראת ל-LLM, משתמשת בכלי).
• מחזירה את המצב המעודכן.

דוגמאות לצמתים: call_model_node, execute_tool_node, analyze_results_node.

3. קשתות (Edges)
אלו הם החיצים המחברים בין הצמתים. הם קובעים איזה צומת יופעל הבא. ישנם שני סוגים של קשתות:

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

דוגמה לקשת מותנית:

• לאחר קריאה למודל (בצומת agent_node), אנו בודקים את המצב.
• אם בתגובת המודל יש קריאה לכלי ← אנו הולכים לצומת execute_tool_node.
• אם אין קריאה לכלי ← אנו הולכים לצומת הסופי END.

---

LangChain מול LangGraph: מתי להשתמש במה?

קריטריון	LangChain (שרשראות LCEL)	LangGraph
שימוש עיקרי	משימות פשוטות ולינאריות	משימות מורכבות וציקליות (סוכנים)
מבנה	צינור (א' ← ב' ← ג')	גרף (תרשים זרימה עם הסתעפויות ולולאות)
בקרת זרימה	דטרמיניסטית, מוגדרת מראש	דינמית, נקבעת בזמן ריצה
דוגמת משימה	1. לקחת טקסט. 2. לסכם אותו. 3. לתרגם אותו לשפה אחרת.	1. לקבל שאלה. 2. לחפש באינטרנט עד למציאת תשובה. 3. לסכם את הממצאים ולהשיב.
אנלוגיה	פס ייצור במפעל	צוות של אנשים שמתייעץ ומקבל החלטות

חיבור כל החלקים

1. קלט המשתמש נכנס למצב ההתחלתי של LangGraph.
2. הצומת "סוכן" מקבל את המצב. בתוך צומת זה נמצאת שרשרת LangChain (פרומפט | מודל | מנתח פלט). המודל, באמצעות כלים מ-LangChain, מחליט מה לעשות הלאה (למשל, "להפעיל חיפוש"). החלטתו נכתבת למצב.
3. קשת מותנית מנתחת את המצב ומכוונת את הזרימה לצומת "מפעיל כלים".
4. צומת זה מבצע את הקריאה האמיתית לכלי (למשל, מבצע חיפוש באינטרנט) וכותב את התוצאה בחזרה למצב.
5. הזרימה חוזרת לצומת "סוכן" (זו לולאה). כעת המודל רואה את תוצאת החיפוש ומקבל החלטה חדשה.
6. הלולאה חוזרת על עצמה עד שהמודל מחליט שהמשימה הושלמה. אז, הקשת המותנית תכוון את הזרימה לסיום.