لانغ تشين أم لانغ غراف؟ متى تكتب على الأولى ومتى تحتاج الثانية تحت الوكيل

لانغ تشين (LangChain) هي الحزمة التي تصنع بها وكيلاً، ولانغ غراف (LangGraph) هي الطبقة التي يعمل عليها ذلك الوكيل تحت الغطاء. الإجابة العملية المختصرة: ابدأ بـ create_agent وحدها، ولا تفتح ملف langgraph إلا إذا احتجت حفظاً للحالة بين النداءات، أو تحكماً صريحاً في ترتيب الخطوات، أو بوابة موافقة بشرية.

المصطلحات في سطر واحد: وكيل (agent) هو نموذج يستدعي أدواته في حلقة حتى تنتهي المهمة. إطار العمل (framework) هو مستوى عالٍ من التجريد. بيئة التشغيل (runtime) هي الطبقة التي تدير الحالة والبثّ والتدخّل البشري. بنية تشغيل الوكيل (harness) هي كل ما يحيط بحلقة النموذج. الطبقة الوسيطة (middleware) هي كود يتدخّل في الحلقة عند نقاط محدّدة بدل أن تكتب الحلقة بنفسك.

ملاحظة للمتابعين لدروس قديمة: إن كان كودك يستدعي create_react_agent فهو كود ما قبل 1.0؛ فـcreate_agent حلّت محلّه. أما إصدارا 0.3 و0.4 فما زالا في وضع الصيانة حتى ديسمبر 2026، فلا تبني مشروعاً جديداً عليهما.

أيّ الحزمتين أستخدم: لانغ تشين أم لانغ غراف؟

ابدأ بحزمة langchain وحدها. create_agent تصنع الوكيل كاملاً، وlanggraph لا تُستدعى إلا لأربع حالات محدّدة نعدّها في القسم الخامس.

الطبقة	الحزمة	ما تقدّمه	متى تستوردها
إطار العمل	langchain	تجريدات جاهزة: create_agent، الرسائل، الأدوات، الطبقة الوسيطة	في كل الحالات، ابدأ من هنا
بيئة التشغيل	langgraph	التنفيذ المتين، البثّ، التدخّل البشري في الحلقة، حفظ نقاط التقدّم	عند الحاجة إلى أيٍّ منها
بنية جاهزة	deepagents	كل ما سبق في قالب واحد	لا — ما زالت قبل 1.0

من يقرّر المسار؟
├── النموذج  →  langchain وحدها:  create_agent(model, tools=[...], system_prompt=...)
└── أنت      →  أضف langgraph:   StateGraph ← add_node / add_edge ← compile()

ما الفرق بين إطار العمل وبيئة التشغيل؟

لانغ تشين هي إطار العمل، ولانغ غراف هي بيئة التشغيل منخفضة المستوى: أطر العمل أعلى مستوى وتعمل على بيئات تشغيل الوكلاء، ولانغ تشين 1.0 مبنية فوق لانغ غراف.

الفرق هنا في الارتفاع لا في القوة. إطار العمل يعطيك تجريدات جاهزة — حلقة وكيل، رسائل، أدوات — فتكتب سطرين بدل مئة. بيئة التشغيل لا تعطيك تجريداً بل تحفظ لك ما تحتاجه لتدوم العملية: التنفيذ المتين، والبثّ، والتدخّل البشري في الحلقة، والاستمرارية. والمفارقة أن الطبقتين تُستخدمان معاً في الغالب: حين تبني وكيلاً عبر create_agent فأنت في الواقع تستدعي المنطق الذي يعمل تحت لانغ غراف، لكنك لا تحتاج أن تعرف ذلك لتبدأ.

الطبقة	ما تضيفه فوق ما تحتها
بيئة التشغيل	التنفيذ المتين، البثّ، التدخّل البشري، الاستمرارية
إطار العمل	التجريدات والتكاملات
البنية	الأدوات الجاهزة، الموجّهات، الوكلاء الفرعيون

هذه الطبقات الثلاث موصوفة بالتفصيل في دليل المطوّر العربي الكامل، ونكتفي هنا بالحدّ الأدنى الذي يخدم قرارك بين الحزمتين.

كيف تفكّك create_agent معادلة «الوكيل = نموذج + بنية»؟

المعادلة الرسمية مختصرة: الوكيل = النموذج + بنته التشغيل. وتوفّر create_agent تلك البنية — صغيرة وقابلة للتخصيص إلى حدٍّ كبير — وهي كل ما حول حلقة النموذج: الموجّه، والأدوات، وأي طبقة وسيطة تشكّل السلوك. أي أن المعادلة تُترجم إلى أربعة معاملات في الدالة نفسها:

create_agent(
    model            ← النموذج اللغوي: من يقرّر الخطوة التالية
    tools=[...]      ← الأدوات: ما يستطيع فعله فعلياً، لا ما نظنّه ممكناً
    system_prompt=   ← الموجّه النظامي: نبرة الوكيل وحدود مهمته
    middleware=[...] ← البنية: كيف تتصرّف الحلقة عند كل نقطة بداخلها

from langchain.agents import create_agent


def get_weather(city: str) -> str:
    """Return the current weather in a given city."""
    return f"It's always sunny in {city}!"


def build_agent(model):
    return create_agent(
        model,
        tools=[get_weather],
        system_prompt="أنت مساعد ودود. أجب بإيجاز.",
    )


agent = build_agent(model)
result = agent.invoke(
    {"messages": [{"role": "user", "content": "ما حالة الطقس في القاهرة؟"}]}
)
print(result["messages"][-1].content)

نقطة أمانة عن الشيفرة: مرّرنا model كوسيط إلى الدالة ولم نضع معرّفاً لنموذج بعينه، لأن تثبيت مورّد واحد هنا يجعل المثال يفشل عند أول تبديل. ابنِ كائن النموذج عبر init_chat_model — وصيغته وقائمة المزوّدين مشروحة في مقال الواجهة الموحّدة للنماذج.

المعامل الرابع هو الذي يصنع الفرق. الطبقة الوسيطة هي الميزة المميِّزة لـcreate_agent، ولها ستّة خطّافات (hooks) موثّقة تعمل حول الحلقة: before_agent وbefore_model وwrap_model_call وwrap_tool_call وafter_model وafter_agent، والشيفرة أعلاه هي الوكيل كاملاً — النموذج والأدوات والموجّه النظامي؛ أما الوسيطة فهي ما تضيفه فوقه لاحقاً دون إعادة كتابة أي سطر. تفصيلها كله في مقال create_agent والطبقة الوسيطة.

متى لا تحتاج لانغ غراف إطلاقاً؟

لا تحتاجها في أغلب الحالات. وهذه العبارة من وثائقهم حرفياً: You do not need to know LangGraph for basic LangChain agent usage. وهذا ليس تبسيطاً تسويقياً بل وصف دقيق للاختلاف، لأن الكود الذي كتبناه أعلاه لا يستورد منها حرفاً.

تنطبق المعايير التالية كلّها على مشروعك إن كان:

• المسار هو: سؤال، فيقرّر النموذج أداة، تُنفَّذ، فيجيب. لا خطوتان تتشابكان، ولا فرعان متوازيان.
• مجموعة أدواتك ثابتة ومعروفة منذ اليوم الأول.
• لا تحتاج موافقة إنسان قبل أي إجراء، ولا أن تعود العملية من حيث توقّفت بعد انقطاع.
• حفظ الحالة بين النداءات متغيّر تكتبه عندك أو ملف منطقي، لا مُحافِظ نقاط (checkpointer).

في هذه الحالة الاستيراد الصحيح هو سطر واحد: from langchain.agents import create_agent، ثم pip install -U langchain. ولا تحتاج إلى ذكر langgraph في requirements.txt كي تعمل.

وكن صريحاً مع نفسك في نقطة واحدة: لأن لانغ تشين مبنية فوق لانغ غراف، فإن تثبيت langchain يجلب معه الحزمة الثانية في تبعياته. أنت لا تختار بين تثبيت حزمة أو لا شيء، بل تختار أي طبقة تكتب أنت كودك فوقها.

متى تحتاج لانغ غراف تحت الوكيل؟

تحتاجها حين تتوقّف عن سؤال «ماذا يفعل الوكيل؟» وتبدأ بسؤال «متى ينتقل التنفيذ ولماذا». تركّز لانغ غراف على القدرات التي تهم تنسيق الوكلاء — التنفيذ المتين، والبثّ، والتدخّل البشري في الحلقة — وهي في المقابل لا تجرّد الموجّهات ولا البنية، فتترك قرار ترتيب الخطوات بيدك.

هناك أربع إشارات عملية واضحة:

أولاً: تريد أنت أن تقرّر الخطوة التالية، لا النموذج. تدفّق فيه تصنيف، ثم مراجعة، ثم إعادة محاولة، ثم مخرج نهائي — خطوات معروفة قبل التشغيل.

ثانياً: تريد مزج خطوة حتمية بخطوة يقودها النموذج. استعلام قاعدة بيانات مثلاً، ثم دعوة النموذج يقرّر ماذا يفعل بها. الوكيل وحده يجيد الجزء الثاني ولا يعرف الأول.

ثالثاً: التنفيذ طويل وقد ينقطع. هنا يظهر ما يسمّونه «التنفيذ المتين» (durable execution) — وهو في التطبيق العملي كله يعني شيئاً واحداً: الرسم يكتب نقاط حفظ ويستأنف منها عند رجوعه. لا يوجد مفتاح سحري اسمه durable_execution؛ ابحث عن thread_id وcheckpointer فقط.

رابعاً: تريد تدخّلاً بشرياً. أوقف قبل الحجز وانتظر موافقة، ثم استأنف. هذا يحتاج بنية رسم وسجلّ نقاط، لا حلقة نموذج.

from typing import TypedDict

from langgraph.graph import END, START, StateGraph


class State(TypedDict):
    name: str


def greet(state: State) -> State:
    return {"name": "أهلاً، " + state["name"]}


builder = StateGraph(State)
builder.add_node("greet", greet)
builder.add_edge(START, "greet")
builder.add_edge("greet", END)

graph = builder.compile()

print(graph.invoke({"name": "مطوّر"}))

هذا أصغر رسم نافع يمكن كتابته: حالة (State)، عقدة (greet)، حافيتان من نقطة الدخول إلى النهاية. لاحظ أمرين عمليين: العقدة والحوافة دوالّ عادية لا سحر فيها، وbuilder.compile() ليست اختيارية — الدالة تُعيد الرسم النهائي الذي يُستدعى، وبدونها لا يوجد ما تناديه.

وحين تجمع بين العالمين، انتقل إلى مقال أنماط سير العمل والمقاطعات التفاعلية — فعامل التوقّف والاستئناف هو بالضبط ما يميّز هذه الطبقة.

لماذا لا نبني توصياتنا على Deep Agents؟

السبب واحد ومعلن في صفحة الإصدارات: حزمة deepagents ما زالت حزمة ما قبل 1.0 قيد تطوير نشط. وفي المقابل فإن إصدارَي 1.0 من لانغ تشين ولانغ غراف مُعلَّنان من فئة الإصدارات طويلة الدعم (LTS)، ويبقىان نشطين حتى إصدار 2.0.

موقفنا في هذا الدليل واضح ومقصود: لا نكتب فوق deepagents توصية ولا مثالاً، لا في هذا المقال ولا في بقية السلسلة. لو أردت بنية جاهزة تضم كل شيء في قالب واحد فهذا خيارك، لكن على علمك بأن واجهتها قد تتغيّر، وأن ما يكتب في مقال اليوم قد يحتاج تعديلاً غداً. الأساس المزدوج — langchain فوق langgraph — هو ما نضع عليه كل تسمية في هذا الدليل.

شجرة القرار العملية: ماذا أستورد الآن بالضبط؟

هذه هي الشجرة التي نريدك أن تعود إليها، وقد رتّبناها بحيث يكون لكل فرع سطر استيراد واحد واضح.

السؤال الأول: هل يكفي أن يختار النموذج أدواته ثم ينهي؟
│
├── نعم، يكفي
│   → لا تستورد langgraph إطلاقاً
│     from langchain.agents import create_agent
│     ● تحكّم إضافي في سلوك الحلقة؟ أضف الطبقات الوسيطة (middleware)
│     ● هل يحتاج الوكيل أن يتذكّر بين النداءات؟ أضف مُحافِظ نقاط و thread_id
│
└── لا، أنا أرسم المسار بنفسي
    │
    ├── الخطوات كلها معروفة ومتسلسلة، بلا قرار من النموذج
    │   → لا تحتاج رسماً بيانياً أصلاً: سياق + أدوات + منطق عادي يكفي
    │
    └── فيها خطوة حتمية وخطوة يقرّرها النموذج  →  StateGraph
        from langgraph.graph import START, StateGraph
        ثم add_node و add_edge ثم compile()
        ● والوكيل هنا عقدة داخل رسم أكبر، لا بديل عن create_agent

ولأن تثبيت langchain يجلب معه langgraph، إليك الأمر الواحد الذي يغطّي الحالتين، بشرط Python <4.0.0, >=3.10.0:

pip install -U langchain langgraph

ثم قاعدة واحدة تختصر الباقي: ابدأ بـ create_agent بلا تردّد، وأضف ما ينقصك بالترتيب — الموجّه النظامي، ثم الطبقة الوسيطة، ثم حفظ الحالة. أمّا رسم الحالة (StateGraph) فلا تبدأ به إلا حين يكون أمامك سؤال «متى ينتقل التنفيذ؟» لا «ماذا يفعل الوكيل؟». ولماذا هذه الطبقات تحديداً تشرحه دليل المطوّر العربي الكامل من زاوية المستويات الثلاث.

ماذا سأبني عملياً بعد هذا المقال؟

خذ ثلاث خطوات قصيرة، كلٌّ منها قابلة للاختبار في جلسة واحدة:

أولاً: شغّل المثال أعلاه كما هو. النتيجة تثبت لك أن الوكيل يعمل بلا أي سطر من لانغ غراف.

ثانياً: عدّل system_prompt وحده، وأعد التشغيل. لاحظ كيف يتغيّر السلوك دون أن تلمس الأدوات — هذه هي حدود المعاملات الأربعة عملياً.

ثالثاً: أضف خطوة تحتاج تدخلاً بشرياً، أو اسأل نفسك: هل يهمّني لو انقطعت العملية في منتصفها؟ إن كانت الإجابة نعم فأنت الآن تعرف سبباً محدّداً تستورد لأجله الحزمة الثانية — لا لأسباب دعائية، بل لأن متطلباً حقيقياً دفعك إليها.

القراءة التالية: الواجهة الموحّدة للنماذج لتبديل المزوّد، ثم create_agent والطبقة الوسيطة لبناء وكيل إنتاجي، ثم الحالة ونقاط الحفظ لتخزين الذاكرة.

---

تحتاج وكيلاً يعمل لفريقك؟

نصمّم ونبني أنظمة وكلاء للشركات والأفراد فوق لانغ تشين (LangChain) ولانغ غراف (LangGraph) — من إثبات المفهوم في أسبوع إلى نظام إنتاجي يُشغَّل يومياً. ابدأ بطلبك من صفحة التواصل.