എജന്റ് പ്രവൃത്തികൾ വേഗത്തിൽ മാഷ്ടർ ചെയ്യാൻ 10 മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ
നിങ്ങൾ LangChain എജന്റുകളുമായി പരീക്ഷണങ്ങൾ നടത്തി, ഓർക്കസ്ട്രേഷൻ നിയന്ത്രിക്കാൻ ബുദ്ധിമുട്ടുണ്ടായിരുന്നെങ്കിൽ, ഇവിടെ ഒരു ധൈര്യമുള്ള വാദമുണ്ട്: മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ മാഷ്ടർ ചെയ്താൽ നിങ്ങൾ എങ്ങനെ AI സിസ്റ്റങ്ങൾ നിർമ്മിക്കുമെന്ന് മാറും. LangGraph എജന്റിക് പ്രവൃത്തികളിൽ ഗ്രാഫ് അടിസ്ഥാനത്തിലുള്ള കൺട്രോൾ, ശക്തമായ സ്റ്റേറ്റ്, മൾട്ടി-ആക്ടർ പാറ്റേണുകൾ ചേർക്കുന്നു — ലളിതമായ ചൈനുകൾ തകരാറിൽ കഴിയുമ്പോൾ ഉത്പാദന ടീമുകൾക്ക് ഇത് ആവശ്യമുള്ളതുതന്നെ.
ഈ പ്രായോഗികവും പരിഹാര-പരിപാടിയുള്ള ഗൈഡിൽ, മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ തിരഞ്ഞെടുത്ത് ഓരോതിന്റെയും പ്രയോഗം എന്താ എന്ന് കാണിക്കുകയും, അവയെ യാഥാർത്ഥ്യ ഉപയോഗങ്ങളുമായി ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു — ലളിതമായ ടൂൾ-കാലിങ് എജന്റുകളിൽ നിന്ന്_fault-tolerant, മൾട്ടി-ടേൺ പ്ലാനർമാരിലേക്ക്. ഇതോടൊപ്പം, നിങ്ങൾക്ക് ഉയർന്ന നിലവാരത്തിലേക്ക് എത്താനുള്ള റോഡ്മാപ്പ്, സാധാരണ പിഴവുകൾ ഒഴിവാക്കാനുള്ള വഴികൾ, ഇപ്പോഴുതന്നെ ഉപയോഗിക്കാൻ കഴിയുന്ന പ്ലഗ്-അൻഡ്-പ്ലേ പാറ്റേണുകളും ലഭിക്കും.
എജന്റ് നിര്മാതാക്കൾക്ക് LangGraph ട്യൂട്ടോറിയലുകൾ എത്ര പ്രധാനപ്പെട്ടതാണെന്ന്
- പ്രതീക്ഷിക്കാവുന്ന നിയന്ത്രിത പ്രവാഹം: LangGraph നിങ്ങളുടെ എജന്റിനെ നോഡുകളും എഡ്ജുകളും ഉള്ള ഒരു ഗ്രാഫായി മോഡൽ ചെയ്യുന്നു — ബ്രാഞ്ചിംഗും റീട്രൈകളും ഫാൾബാക്കുകളും വ്യക്തമായി കാണുന്നു.
- പങ്കിടുന്ന, സ്ഥിരമായ സ്റ്റേറ്റ്: സംവാദ ഓർമ്മ, ടൂൾ ഫലങ്ങൾ, ഇടനിലയിലുള്ള ആർട്ടിഫാക്ടുകൾ ഒരിടത്തിരിക്കുന്നു സൂക്ഷിക്കുക.
- മൾട്ടി-ആക്ടർ ഡിസൈൻ: പ്രത്യേക മസ്തിഷ്ക എജന്റുകൾ (പ്ലാനർ, റിസർച്ചർ, കോഡർ, ക്രിട്ടിക്) സ്പാഗറ്റി കോഡ് ഇല്ലാതെ സംയോജിപ്പിക്കുക.
- ഉത്പാദനക്കുള്ള മെച്ചപ്പെടുത്തൽ: ടൈമൗട്ടുകളും ഗാർഡുകളും കാണാനാകൽ സവിശേഷതകളും ചേർത്തുകൊണ്ട് ലജിക്ക് വായിക്കാൻ എളുപ്പമാക്കുന്നു.
നിങ്ങളുടെ ലക്ഷ്യം വിശ്വസനീയമായ അസിസ്റ്റന്റുകൾ, മൂല്യനിർണയകാരികൾ, സ്വയം-അധിഷ്ഠിത ഗവേഷണ ലോപ്പുകൾ നിർമ്മിക്കുകയാണ് എങ്കിൽ, മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ ഒരിക്കൽ വേണ്ട സന്ദർശനങ്ങൾ അല്ല, പുനരാവർത്തന സാധ്യതയുള്ള പാറ്റേണുകളാണ്.
ഈ പട്ടിക എങ്ങനെ പ്രവർത്തിക്കുന്നു
വിവിധ ആവശ്യങ്ങൾക്ക് ഏറ്റവും മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ ആക്കാൻ, അവയെ നൈപുണ്യ നിലവാരവും ഫലവും അടിസ്ഥാനപ്പെടുത്തി ക്രമീകരിച്ചിരിക്കുന്നു. ഓരോ ട്യൂട്ടോറിയലിലും ഈവിടെ ഉൾക്കൊള്ളുന്നു:
- നിങ്ങൾ നിർമിക്കാനിരിക്കുന്നത്
- നിഷ്കർഷിച്ച പഠകപ്രൊഫൈലുകൾക്കും ടീമുകൾക്കുമായി ഉത്തമം
ഓരോ ടിയറിന്റെയും ശേഷം അപ്ഗ്രേഡ് പാതകളും പ്രൊ ടിപ്പുകളും നമുക്ക് നൽകിയിട്ടുണ്ട്.
ടിയർ 1 — അടിസ്ഥാനങ്ങൾ: ഗ്രാഫ് ചിന്തനത്തിൽ പ്രാവീണ്യം നേടുക
1) ഹലോ, LangGraph: 30 മിനിറ്റിനുള്ളിൽ ചെയിൻ നിന്ന് ഗ്രാഫിലേക്ക്
- നിങ്ങൾ നിർമിക്കാനിരിക്കുന്നത്: രണ്ടു ടൂളുകൾ വിളിക്കുന്ന ലളിതമായ ഒരു എജന്റ് —
search പിന്നീട് summarize — തിരയൽ ഫലം ഇല്ലെങ്കിൽ ബ്രാഞ്ച് ചെയ്യുന്നു.
- അത് പ്രയോജനകരമായത്: ലീനിയർ ചെയിൻ ഒരു ഗ്രാഫായി_nodes_ഉം _edges_ഉം വ്യക്തമായി മാറ്റുന്നത് കാണാം.
- പ്രധാന ആശയങ്ങൾ: നോഡുകൾ, എഡ്ജുകൾ, പങ്കിട്ട സ്റ്റേറ്റ്, നിബന്ധനയുള്ള റൂട്ടിംഗ്.
- ഉത്തമം: LangChain Chains/Agents മുതൽ ഗ്രാഫ് അടിസ്ഥാനത്തിലുള്ള കണ്ട്രോളിലേക്ക് മാറുന്ന ഡെവലപ്പർമാർക്ക്.
ഉദാഹരണ ഘടന:
from langgraph.graph import StateGraph
# സ്റ്റേറ്റ് രൂപം നിർവചിക്കുക (ഉദാ: query, results, summary)
class State(dict):
query: str
results: list
summary: str
builder = StateGraph(State)
@builder.node("search")
def search_node(state: State):
# നിങ്ങളുടെ തിരയൽ ടൂൾ വിളിക്കുക
state["results"] = my_search(state["query"])
return state
@builder.node("summarize")
def summarize_node(state: State):
state["summary"] = summarize(state["results"])
return state
builder.edge("search", "summarize", condition=lambda s: len(s["results"]) > 0)
app = builder.compile
പ്രൊ ടിപ്പ്: സ്റ്റേറ്റ് കുറഞ്ഞയും ടൈപ്പ്ചെയ്തതുമായ നിലയിൽ സൂക്ഷിക്കുക. ഇത് നോഡുകൾ തമ്മിലുള്ള കരാറായി കാണുക.
2) ഗാർഡുകളും ടൈമൗട്ടുകളും ഉള്ള ടൂൾ-കാലിംഗ് എജന്റ്
- നിങ്ങൾ നിർമിക്കുന്നതു: റീട്രൈ ലജിക്കും ടൈമൗട്ടുകളും ഉള്ള ടൂൾസ് ഉപയോഗിക്കുന്ന എജന്റ് (വെബ് തിരയൽ, കലകുലേറ്റർ).
- അത് പ്രയോജനകരമായത്: ഉത്പാദന എജന്റുകൾ മടുപ്പുള്ളതായിരിക്കണം—ഈ ട്യൂട്ടോറിയൽ പ്രായോഗികമായ ഗാർഡറെയിൽസ് കാണിക്കുന്നു.
- പ്രധാന ആശയങ്ങൾ: ടൈമൗട്ടുകൾ, പിശക് നോഡുകൾ, റീട്രൈ ലൂപ്പുകൾ, കാണാനാകൽ ഫുൻസ്.
- ഉത്തമം: വെളിച്ചം ഉള്ള ഡിപെൻഡൻസികളുമായി എജന്റുകൾ ഉപയോഗിക്കാൻ തയ്യാറാകുന്ന ടീമുകൾക്ക്.
പ്രൊ ടിപ്പ്: പിശക് കൈകാര്യം ചെയ്യലിനെ മുൻനിര നോഡുകളായി കാണിക്കുക; പരീക്ഷണവും വികസനവും എളുപ്പം ആകും.
3) ഓർമ്മ & സ്റ്റേറ്റ്: തലവേദന കൂടാതെയുള്ള ചാറ്റ് ചരിത്രം
- നിങ്ങൾ നിർമിക്കുന്നതു: ഉപയോക്തൃ പ്രൊഫൈൽ, മുൻകാല ടാസ്കുകൾ ഓർക്കുന്ന സംഭാഷണ എജന്റ്.
- അത് പ്രയോജനകരമായത്: ഓർമ്മ ഗ്രാഫ് സ്റ്റേറ്റിൽ ആയാൽ സ്ഥിരതയും പരിശോധിക്കലും ഉണ്ട്.
- പ്രധാന ആശയങ്ങൾ: സ്റ്റേറ്റ് മർജ്ജിംഗ്, സന്ദേശ ബഫ്ഫറുകൾ, സംക്ഷിപ്തീകരണ വിൻഡോകൾ.
- ഉത്തമം: കസ്റ്റമർ സപ്പോർട്ട് ബോട്ടുകൾ, AI ടീമംഗങ്ങൾ, തുടർച്ചയുള്ള കോൺടെക്സ്റ്റ് ഉള്ള അസിസ്റ്റന്റുകൾ.
പ്രൊ ടിപ്പ്: സ്കെയിൽ ചെയ്യാൻ സ്റ്റേജ്ഡ് മെമ്മറി — ചെറു കാർയ്യസഞ്ചയം + സംക്ഷിപ്ത ദീർഘകാല സാരാംശം — പ്രയോജനിപ്പിക്കുക.
ടിയർ 2 — ഇടനിലക്കാരൻ: മൾട്ടി-പടി റീസണിംഗ് ഓർക്കസ്ട്രേറ്റ് ചെയ്യൽ
4) LangGraph ൽ പ്ലാനർ-എക്സിക്യൂട്ടർ പാറ്റേൺ
- നിങ്ങൾ നിർമിക്കുന്നതു: രണ്ട് എജന്റുള്ള സിസ്റ്റം, ഒരാൾ ടാസ്ക് വിഭജിച്ച് മറ്റാൾ പടി പൂർത്തിയാക്കുന്നു.
- അത് പ്രയോജനകരമായത്: വിജ്ഞാനം (എന്ത് ചെയ്യണം) പ്രവർത്തനത്തിന്ന് (ചെയ്യുന്നത്) വ്യത്യാസപ്പെടുത്തി, സുതാര്യതയും ടെസ്റ്റിങ് സൗകര്യവും.
- പ്രധാന ആശയങ്ങൾ: സബ്ഗ്രാഫുകൾ, മെസ്സേജ് പാസ്സിങ്, സമാപന നിലകൾ.
- ഉത്തമം: ഗവേഷണ ടാസ്കുകൾ, ഉള്ളടക്കം സൃഷ്ടിക്കൽ പൈപ്ലൈൻ, ഡാറ്റ കൈകാര്യം ഫ്ലോകൾ.
പ്രൊ ടിപ്പ്: പ്ലാനറെ “ടോകൺ-ഫ്രൂഗൽ” ആയി സൂക്ഷിക്കുക. ഔട്ട്പുട്ട് ഫോർമാറ്റ് പരിമിതപ്പെടുത്തുക മാറ്റം കുറയ്ക്കാൻ.
5) ഫീഡ്ബാക്ക് ലൂപ്പുകളോടെ Retrieval-Augmented Generation (RAG)
- നിങ്ങൾ നിർമിക്കുന്നതു: ഉത്തരം വിശ്വാസത്തെ അടിസ്ഥാനമാക്കി റിട്രീവൽ അനുകൂലിപ്പിക്കുന്ന RAG പൈപ്പ്ലൈൻ.
- അത് പ്രയോജനകരമായത്: ഹ്യാലുസിനേഷൻ ഒഴിവാക്കാൻ ലൂപ്പ്: റിട്രീവ് → ഡ്രാഫ് → മൂല്യനിർണയം → മെച്ചപ്പെടുത്തൽ → ഫൈനലൈസ്.
- പ്രധാന ആശയങ്ങൾ: വിശ്വാസ സ്കോറിങ്, മൂല്യനിർണയ നോഡുകൾ, നിബന്ധനയുള്ള മെച്ചപ്പെടുത്തൽ, വെക്റ്റർ സ്റ്റോർ മാനേജ്മെന്റ്.
- ഉത്തമം: അറിവ് ബേസുകൾ, ഡോക്യുമെന്റേഷൻ അസിസ്റ്റന്റുകൾ, നിയന്ത്രണ-സെൻസിറ്റീവ് ഉള്ളടക്കം.
പ്രൊ ടിപ്പ്: വിശ്വാസം നിശ്ചിത പരിധി തികയുമ്പോൾ “വേഗത്തിൽ നിർത്തുക” എന്ന എഡ്ജ് അടിപ്പിക്കുക ടോകണുകൾ ലാഭിക്കാൻ.
6) സ്വയം-സമീപനം ഉള്ള മൾട്ടി-ടൂൾ എജന്റ്
- നിങ്ങൾ നിർമിക്കുന്നതു: ഒരേസമയം പല ടൂളുകളും (വെബ്, കോഡ്, ടേബിൾസ്) വിളിച്ച് ഫലങ്ങൾ സ്വയം വിലയിരുത്തുന്ന എജന്റ്.
- അത് പ്രയോജനകരമായത്: സ്വയം-അവലോകനം അടിസ്ഥാനമായ ലാജിക്കൽ അല്ലെങ്കിൽ ഫോർമാറ്റ് പിഴവുകൾ ഉപയോക്താക്കളിൽ എത്തുന്നത് തടയുന്നു.
- പ്രധാന ആശയങ്ങൾ: ടൂൾ റൂട്ടിംഗ്, സ്കീമ വാർത്തീകരണം, ക്രിട്ടിക്-പുനഃപരിശോധന ലൂപ്പുകൾ.
- ഉത്തമം: റിപ്പോർട്ട് നിർമ്മാണം, അനലിറ്റിക്സ് വിശദീകരണങ്ങൾ, സെമി-സ്വതന്ത്ര ഗവേഷണ അസിസ്റ്റന്റുകൾ.
പ്രൊ ടിപ്പ്: ക്രിറ്റിക് ഒരു ലഘുലേഖ LLM ആയി കാണുക, കർശന റൂബ്രിക് പ്രോമ്പ്റ്റുകളോടെ സ്വതന്ത്രമായ വിമർശനം ഒഴിവാക്കാൻ.
ടിയർ 3 — മുൻനിര: ഉത്പാദന-ഗ്രേഡ് എജന്റ് സിസ്റ്റങ്ങൾ
7) മൾട്ടി-ആക്ടർ LangGraph: റിസർച്ചർ, കോഡർ, റിവ്യൂവർ
- നിങ്ങൾ നിർമിക്കുന്നതു: മൂന്നാർ എജന്റുകൾ ഉൾപ്പെടുന്ന ഒരു സിസ്റ്റം, ഓരോന്നിനും പ്രത്യേക specialization ഉണ്ട്, ജോലി കൈമാറുന്നു, ഒപ്പിടുന്നു.
- അത് പ്രയോജനകരമായത്: തൊഴിൽ വിഭജനം എൻകോഡ് ചെയ്യുന്നു, പ്രോമ്പ്റ്റുകളുടെ കോളവർക്ക് കുറവ്, ഗുണമേന്മ മെച്ചപ്പെടുത്തുന്നു.
- പ്രധാന ആശയങ്ങൾ: റോൾ-സ്പെസിഫിക്ക് സ്റ്റേറ്റ്, ഇന്റർ-എജന്റ് കരാർ, ഉയർന്ന തട്ടുകൾ.
- ഉത്തമം: ടെസ്റ്റ് സഹിതമുള്ള കോഡ് ജനറേഷൻ, മാർക്കറ്റ് റിസർച്ച്, നയ വിശകലനം.
പ്രൊ ടിപ്പ്: ഓരോ ആക്ടറുടെ ഇൻപുട്ട്/ഔട്ട്പ്പുട്ട് സ്കീമ നിർവചിക്കുക — JSON സ്കീമകൾ “റോൾ ലികേജ്” തടയുന്നു.
8) ഫോള്ട് ടോളറൻസ്: ചെക്ക്പോയിന്റുകൾ, റീട്രൈ, ഐഡംപൊട്ടൻസി
- നിങ്ങൾ നിർമിക്കുന്നതു: പിഴവ് സംഭവിച്ചാൽ വീണ്ടും തുടങ്ങാൻ കഴിയും, ചെക്ക്പോയിന്റുകൾ, ഐഡംപൊട്ടന്റ് നോഡുകൾ ഉള്ള എജന്റ്.
- അത് പ്രയോജനകരമായത്: യഥാർത്ഥ ജോലികൾ പരാജയപ്പെടും. ഈ ട്യൂട്ടോറിയൽ പുനരുദ്ധാരണം ഡിസൈനിന്റെ ഭാഗമായി ആക്കും.
- പ്രധാന ആശയങ്ങൾ: സ്ഥിരമായ സ്റ്റേറ്റ് സ്റ്റോറുകൾ, നിർബന്ധിത നോഡ് ഹാഷിംഗ്, റീട്രൈ ബഡ്ജറ്റുകൾ, സാഗാ-പോലെ പരിഹാര മാർഗ്ഗങ്ങൾ.
- ഉത്തമം: ദീർഘകാല ജോലികൾ, ബാച്ച് പ്രോസസ്സിംഗ്, വിലപ്പെട്ട API ചൈനുകൾ.
പ്രൊ ടിപ്പ്: നോഡ് ഇൻപുട്ടുകളും ഔട്ട്പുട്ടുകളും ശേഖരിക്കുക; റീട്രൈകൾ സ്റ്റേറ്റിന്റെ ഫംഗ്ഷൻ ആയിരിക്കണം, ഭാഗ്യത്തിന് അല്ല.
9) സ്കെയിൽൽ മേനിറ്ററിംഗ്, ട്രേസിംഗ്, മൂല്യനിർണയം
- നിങ്ങൾ നിർമിക്കുന്നത്: നിങ്ങളുടെ ഗ്രാഫിനു ചുറ്റും ട്രേസുകൾ, മീറ്റ്രിക്സ്, റാഗ്രെഷൻ ടെസ്റ്റുകൾ ഉൾപ്പെടുത്തിയ അളവുകൂടി.
- അത് പ്രയോജനകരമായത്: നിങ്ങൾ കാണാനാകാത്തതു മെച്ചപ്പെടുത്താനാകില്ല. കാണാനാകൽ rápidas തിരുത്തലുകൾക്ക് അവസരം നൽകും.
- പ്രധാന ആശയങ്ങൾ: സ്പാൻ ട്രേസിംഗ്, സ്ട്രക്ചർ ചെയ്ത ലോഗിംഗ്, ഗോൾഡൻ ഡാറ്റാസെറ്റുകൾ, ഓഫ്ലൈൻ/ഓൺലൈൻ മൂല്യനിർണയം.
- ഉത്തമം: SLA-ഉം സുരക്ഷാ പരിശോധനകളും ഉള്ള ഉയർന്ന ഗതാഗതമുള്ള ടീമുകൾക്ക്.
പ്രൊ ടിപ്പ്: “ഷാഡോ” മൂല്യനിർണയ നോഡുകൾ ചേർക്കുക, ഉത്പാദനത്തോടൊപ്പം അത്രയും പ്രവർത്തിച്ചുകൊണ്ട് ഔട്ട്പുട്ട് ബാധിക്കാതിരിക്കാൻ.
10) ഹ്യൂമൻ-ഇൻ-ദി-ലൂപ്പ് (HITL) റിവ്യൂ ഫ്ലോകൾ
- നിങ്ങൾ നിർമിക്കുന്നത്: അനിശ്ചിതമായ ഫോൾസുകൾ പൂർത്തിയാക്കുന്നതിന് മുമ്പ് മനുഷ്യനുമായി അവലോകനം നടത്തുന്ന ലൂപ്പ്.
- അത് പ്രയോജനകരമായത്: മോഡൽ വേഗതയും മനുഷ്യനിലെ നിർണായകതയും കൂട്ടിച്ചേർക്കുക.
- പ്രധാന ആശയങ്ങൾ: വിശ്വാസ പരിധികള്, അംഗീകാരം നോഡുകൾ, ഫീഡ്ബാക്ക് ഉൾക്കൊള്ളിക്കൽ, ഓഡിറ്റ് ട്രയലുകൾ.
- ഉത്തമം: നിയമം, ആരോഗ്യസംരക്ഷണം, ധനം, മറ്റു നിയന്ത്രിത മേഖലകൾക്ക്.
പ്രൊ ടിപ്പ്: മനുഷ്യന്റെ തീരുമാനവും കാരണം സ്റ്റേറ്റിൽ രേഖപ്പെടുത്തുക, ഭാവി റൂട്ടിംഗിന് സൂക്ഷിക്കുക.
ഉപയോക്തൃ കേസുകൾക്ക് ഏറ്റവും നല്ല LangGraph ട്യൂട്ടോറിയലുകൾ
ദ്രുതം തിരഞ്ഞെടുക്കാൻ സഹായിക്കാൻ, ലളിതമായ మ్యാപിംഗാണ് ഇവിടെ:
- കസ്റ്റമർ സപ്പോർട്ട് അസിസ്റ്റന്റ്: ട്യൂട്ടോറിയലുകൾ 1, 3, 5, 10 നീക്കംചെയ്യുക.
- ഗവേഷണവും റിപ്പോർട്ട് നിർമ്മാണവും: 2, 4, 6, 7, 9 ഉപയോഗിക്കുക.
- കോഡ് ജനറേഷൻ പൈപ്പ്ലൈൻ: 4, 6, 7, 8, 9 ശ്രദ്ധിക്കുക.
- നിയമാനുസൃത RAG: 3, 5, 8, 10 മുൻഗണന നൽകുക.
ഇവ തന്നെ നിങ്ങൾക്ക് സമഗ്ര വിശ്വാസ്യതയും ആവശ്യമായെങ്കിൽ ഏറ്റവും മികച്ച LangGraph ട്യൂട്ടോറിയലുകളാണ്, വെറും പ്രോട്ടോട്ടൈപ്പുകൾ അല്ലാതെ.
പ്രായോഗികമായി തുടങ്ങാം: പുനःഉപയോഗിക്കാവുന്ന ലളിത LangGraph പാറ്റേൺ
കീഴിൽ കാണുന്ന പാറ്റേൺ ധാരാളം മികച്ച LangGraph ട്യൂട്ടോറിയലുകളെ അനുരൂപിക്കുന്നു — പ്ലാൻ → അക്റ്റ് → ചെക്ക് → റിഫൈൻ → പൂർത്തീകരിക്കുക.
from langgraph.graph import StateGraph
from typing import List, Optional
class State(dict):
query: str
plan: List[str]
step: int
artifacts: List[str]
draft: str
confidence: float
builder = StateGraph(State)
@builder.node("plan")
def plan_node(state: State):
state["plan"] = make_plan(state["query"]) # LLM-structured list
state["step"] = 0
state["artifacts"] = []
return state
@builder.node("act")
def act_node(state: State):
task = state["plan"][state["step"]]
output = execute_task(task) # tool(s)
state["artifacts"].append(output)
return state
@builder.node("synthesize")
def synth_node(state: State):
state["draft"] = synthesize(state["artifacts"]) # LLM combine
return state
@builder.node("evaluate")
def eval_node(state: State):
score, feedback = evaluate(state["draft"]) # rubric-based
state["confidence"] = score
state["feedback"] = feedback
return state
# Edges
builder.edge("plan", "act")
def more_steps(s: State) -> bool:
return s["step"] < len(s["plan"]) - 1
builder.edge("act", "act", condition=lambda s: (s.update({"step": s["step"] + 1}) or True) and more_steps(s))
builder.edge("act", "synthesize", condition=lambda s: not more_steps(s))
builder.edge("synthesize", "evaluate")
builder.edge("evaluate", "plan", condition=lambda s: s["confidence"] < 0.7) # റിഫൈൻ പ്ലാൻ
app = builder.compile
എന്തുകൊണ്ട് ഇത് ഫലപ്രദമാണ്:
- വ്യക്തമായ ഘട്ടങ്ങൾ പ്രോമ്പ്റ്റിന് ക്ലിഷ്ടത കുറയ്ക്കുന്നു.
- മൂല്യനിർണയ ഗേറ്റുകൾ കുറഞ്ഞ വിശ്വാസമുള്ള ഉത്തരങ്ങൾ വിതാര്യാതെ തടയുന്നു.
- ആവശ്യമുള്ളപ്പോൾ മാത്രമേ പുനഃക്രമീകരണം നടക്കൂ — എല്ലാ തവണയും അല്ല.
സാധാരണ പിഴവുകൾ (മറ്റും മികച്ച ട്യൂട്ടോറിയലുകൾ അവ എങ്ങനെ ഒഴിവാക്കുന്നു)
- അളവിന് മുകളിൽ സ്റ്റേറ്റ് സൂക്ഷിക്കൽ: അന്വയം രേഖകൾ അല്ലെങ്കിൽ വലിയ സന്ദേശ ചരിത്രങ്ങൾ ഇവ സ്മരണ മോഷ്ടിക്കുന്നു. കഠോറമായി സംക്ഷിപ്തീകരിക്കുക.
- അപ്രത്യക്ഷ പിശക് കൈകാര്യം: ഒന്നും മറയ്ക്കരുത്. എക്സെപ്ഷനുകൾ നോഡിയാക്കി പുനരുദ്ധാരണം മോഡൽ ചെയ്യുക.
- പരിധി ഇല്ലാത്ത ലൂപ്പുകൾ: എല്ലായ്പ്പോഴും ആവൃത്തി പരിധിവെച്ച് സംയോജനം പരിശോധിക്കുക.
- ടൂൾ പടരലുകൾ: ആദ്യം 2–3 ടൂളുകൾ കൊണ്ടു തുടങ്ങിയ ശേഷം, റൂട്ടിംഗ് ഉറപ്പുള്ളപ്പോൾ കൂടുതൽ ചേർക്കുക.
- ഓൺലൈൻ മൂല്യനിർണയം ഇല്ലാത থাকা: മോഡലുകൾ, പ്രോമ്പ്റ്റുകൾ, ടൂളുകൾ മാറുമ്പോൾ പുനരവലംബ പരാജയങ്ങൾ കണ്ടെത്താൻ ഗോൾഡൻ ടാസ്കുകൾ സേivu ചെയ്യുക.
പഠന വഴികാട്ടി: ആദ്യ ഗ്രാഫിൽ നിന്നു ഉത്പാദന എജന്റിൽ
- അടിസ്ഥാന രണ്ട്-ടൂൾ ഗ്രാഫ് നിർമ്മിക്കുക (ട്യൂട്ടോറിയൽ 1).
- മടുപ്പും റീട്രൈയും ചേർക്കുക (ട്യൂട്ടോറിയൽ 2).
- മെമ്മറി ലെയ്ർ ചെയ്തിണക്കുക (ട്യൂട്ടോറിയൽ 3).
- പ്ലാനർ-എക്സിക്യൂട്ടർ പരിചയപ്പെടുത്തി (ട്യൂട്ടോറിയൽ 4).
- മൂല്യനിർണയ ലൂപ്പുകൾ ചേർക്കുക (ട്യൂട്ടോറിയൽ 5 അല്ലെങ്കിൽ 6).
- മൾട്ടി-ആക്ടർ സ്കെയിൽ ചെയ്യുക (ട്യൂട്ടോറിയൽ 7).
- ചെക്ക്പോയിന്റുകളും ടെസ്റ്റുകളും നൽകി ഹാർഡൻ ചെയ്യുക (ട്യൂട്ടോറിയൽ 8–9).
- HITL ലൂടെ സენსിറ്റീവ് ഫലങ്ങൾ നിയന്ത്രിക്കുക (ട്യൂട്ടോറിയൽ 10).
ഇങ്ങനെ ചെയ്താൽ, ഉത്പാദന യാഥാർത്ഥ്യങ്ങളെ മാനിച്ച് മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ ഒരു ക്രമത്തിൽ നന്നായി പഠിക്കും.
LangGraph നു അനുയോജ്യമായ ടൂളിംഗ് സ്റ്റാക്ക്
- വെക്റ്റർ സ്റ്റോറുകൾ: RAG വർക്ക്ഫ്ലോയ്ക്ക് FAISS, Chroma, PGVector.
- ട്രേസിംഗ്: നോഡ് സ്പാനുകൾക്കായി OpenTelemetry അല്ലെങ്കിൽ മോഡൽ-അവെയർ ട്രേസറുകൾ.
- ക്യു: ബാക്ക്ഗ്രൗണ്ട് നോഡുകൾക്ക് Redis, Celery, അല്ലെങ്കിൽ Cloud Tasks.
- സ്റ്റോറുകൾ: സ്ഥിരം സ്റ്റേറ്റ് വക്കും, ചെക്ക്പോയിന്റുകൾക്കായി Postgres അല്ലെങ്കിൽ DynamoDB.
- മൂല്യനിർണയം: റൂബ്രിക് ക്യാലിബ്രേഷനായി സിന്തറ്റിക് ടെസ്റ്റ് സെറ്റുകളും മനുഷ്യ സ്പോട്ട് ചെക്കുകളും.
ഗൗരവമായി ശ്രദ്ധിക്കേണ്ടത്: നിങ്ങളുടെ വർക്ഫ്ലോയിൽ കോഡിംഗ്, ബ്രൗസിംഗ്, വെബ് കണ്ടന്റ് സംക്ഷേപിക്കൽ ഉൾപ്പെട്ടെങ്കിൽ, Sider.ai സൈഡ്ബാർ ബ്രൗസറിൽ ഗവേഷണവും ഡ്രാഫ്റ്റിംഗും വേഗത്തിലാക്കും. പ്രോമ്പ്റ്റുകൾ പരീക്ഷിക്കുക, ഘടിത റൂബ്രിക്കുകൾ സൃഷ്ടിക്കുക, നിങ്ങൾക്ക് തേങ്ങമാറ്റം വേണ്ടാതെ നോളജ് ബേസിലേക്ക് നിരൂപണങ്ങൾ സംഗ്രഹിക്കാൻ അതുല്യമാണ്. നിങ്ങൾക്ക് ഏറ്റവും നല്ല LangGraph ട്യൂട്ടോറിയലുകൾ തിരഞ്ഞെടുക്കാൻ എങ്ങനെ
സ്വയം ചോദിക്കുക:
- നീங்கள் ഉടൻ പ്രൊഡക്ട് ഷിപ് ചെയ്യണേ? മടുപ്പുമായി (2) ആരംഭിക്കുക, ശേഷം RAG + മൂല്യനിർണയം (5), മേനിറ്ററിംഗ് (9).
- നാലായി ഗവേഷണ എജന്റുകൾ പ്രോട്ടോട്ടൈപ്പ് ചെയ്യണേ? പ്ലാനർ-എക്സിക്യൂട്ടർ (4), സ്വയം-ക്രിട്ടിക് (6), മൾട്ടി-ആക്ടർ (7) ശ്രദ്ധിക്കുക.
- നിങ്ങൾക്കു കർശന നിയന്ത്രണാവശ്യമുണ്ടോ? മെമ്മറി നിയന്ത്രണം (3), ഫോള്ട് ടോളറൻസ് (8), HITL (10).
മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ നിങ്ങളുടെ നിയന്ത്രണങ്ങൾക്ക് അനുസൃതമാണ്: ലേറ്റൻസി, ശരിയായതാണെന്ന്, ചെലവ്, പരിപാലനക്ഷമത.
വേഗം റഫറൻസ്: മികച്ച ഗ്രാഫുകൾക്ക് പ്രേരകമാകുന്ന ചോദ്യങ്ങൾ
- ഓരോ നോഡിനും ഏറ്റവും കുറഞ്ഞത് വേണ്ട സ്റ്റേറ്റ് എന്താണ്?
- എവിടെ സാധാരണ പിഴവുകൾ ഉണ്ടാകാം — ഞങ്ങൾ നിർബന്ധിതമായി എങ്ങനെ പുനരുദ്ധാരണം നടത്തണം?
- ടോക്കണുകൾ ലാഭിക്കാൻ എപ്പോൾ വേഗത്തിൽ നിർത്തണം?
- ഏത് എഡ്ജുകൾ നിബന്ധനയുള്ളവ ആണും, ഏത് അവിശ്രുതമായവ?
- എന്ത് മനുഷ്യ അംഗീകാരങ്ങൾ ആവശ്യമാണ്, എങ്കിൽ?
ഇവയെ നിങ്ങൾ നിർമ്മിക്കുന്നപോൾ വൈറ്റ്ബോർഡിൽ സൂക്ഷിക്കുക.
ഉപസംഹാരം: നിങ്ങൾ വിശ്വസിക്കാവുന്ന എജന്റുകൾ നിർമ്മിക്കുക
LangGraph എജന്റുകളുടെ സംഘർഷത്തിന് ഓർഡർ കൊണ്ടുവരുന്നു. ലളിതമായി തുടങ്ങിയും, മടുപ്പും ചേർത്തും, മൂല്യനിർണയ ലെയർ കൂട്ടിച്ചേർത്തും, നിങ്ങള്ക്ക് സ്വയം വിശദീകരിക്കുന്ന, പിശകുകളിൽ നിന്നും പുനരുദ്ധരിക്കുന്ന, പ്രതീക്ഷിക്കാവുന്ന ഫലങ്ങൾ നൽകുന്ന എജന്റുകൾ ഡിസൈന് ചെയ്യാം.
അടുത്ത പടി:
- ഓരോ ടിയർലും ഒരെണ്ണം തിരഞ്ഞെടുക്കി ഈ ആഴ്ച നടപ്പിലാക്കൂ.
- നിലവിലുള്ള പ്രവൃത്തിയിലൊരു മൂല്യനിർണയ ഗേറ്റ് ചേർക്കൂ.
- ഗതാഗതം വർദ്ധിപ്പിക്കുന്നതിന് മുൻപ് ട്രേസിംഗ് ഇൻസ്ട്രുമെന്റ് ചെയ്യൂ.
പ്രധാന ചിലത്:
- ഗ്രാഫുകൾ എജന്റ് പെരുമാറ്റം വ്യക്തവും പരീക്ഷിക്കാവുന്നതുമായതുവരെ മാറ്റുന്നു.
- സ്റ്റേറ്റ് ഒരു കരാറാണ് — ദൃഢവും ടൈപ്പ്ചെയ്തതുമായ നിലയിൽ സൂക്ഷിക്കുക.
- മൂല്യനിർണയങ്ങളും HITL കളും ഉയർന്ന-ദണ്ഡം സാഹചര്യങ്ങളിൽ നിർബന്ധമാണ്.
- മികച്ച LangGraph ട്യൂട്ടോറിയലുകൾ വീണ്ടും ഓടിക്കാം, അളക്കാം, വികസിപ്പിക്കാം.
FAQ
Q1: LangGraph ട്യൂട്ടോറിയലുകളിൽ തുടക്കക്കാർക്ക് ഏറ്റവും ഉത്തമം എത്?
ഒരു ലളിതമായ രണ്ട്-ടൂൾ ഗ്രാഫ് (search → summarize) തന്നെ തുടങ്ങുക, തുടർന്ന് ടൈമൗട്ടുകൾ/റീട്രൈകളും അടിസ്ഥാന മെമ്മറിയും ചേർക്കുക. ഈ മികവാർന്ന ട്യൂട്ടോറിയലുകൾ നോഡുകൾ, എഡ്ജുകൾ, സ്റ്റേറ്റ് പഠിപ്പിക്കും അതിനുശേഷം സ്കെയിൽ ചെയ്യാം.
Q2: LangGraph ൽ പ്ലാനർ-എക്സിക്യൂട്ടർ എജന്റ് എങ്ങനെ ഘടിപ്പിക്കാം?
പ്ലാനിംഗിനും എക്സിക്യൂട്ടിംഗിനും പ്രത്യേകം നോഡുകളും സബ്ഗ്രാഫുകളും ഉപയോഗിക്കുക, പങ്കിട്ട സ്റ്റേറ്റിലൂടെ ഒരു ഘടിതമായ പദ്ധതി കടത്തുക. മികച്ച ട്യൂട്ടോറിയലുകൾ ചെലവ് കുറയ്ക്കാൻ സമാപന മാനദണ്ഡങ്ങളും പുനഃക്രമീകരണ ലൂപ്പുകളും കാണിക്കും.
Q3: RAG ൽ ഹ്യാലുസിനേഷൻ കുറക്കാൻ LangGraph സഹായിക്കുമോ?
അതെ. ഉത്തരം സ്കോർ ചെയ്യുന്ന മൂല്യനിർണയ നോഡുകൾ ചേർക്കുകയും വിശ്വാസം കുറഞ്ഞപ്പോൾ മെച്ചപ്പെടുത്തലുകൾ ഉണ്ടാക്കുകയും ചെയ്യുക. മികച്ച ട്യൂട്ടോറിയലുകൾ റിട്രീവൽ, സംയോജനം, മൂല്യനിർണയം ചേർത്ത് ഗുണമേന്മ ഉറപ്പാക്കും.
Q4: LangChain എജന്റുകൾക്കും LangGraph-ക്കും വ്യത്യാസം എന്താണ്?
LangChain എജന്റുകൾ ടൂൾഉപയോഗത്തിൽ കേന്ദ്രീകരിക്കുന്നു, എന്നാൽ LangGraph വ്യക്തമായ കൺട്രോൾ ഫ്ലോയും പങ്കിട്ട സ്റ്റേറ്റും പ്രധാനമാക്കി. മികച്ച ട്യൂട്ടോറിയലുകൾ ഗ്രാഫുകൾ എങ്ങനെ കാണാനാകലും വിശ്വാസ്യതയും മെച്ചപ്പെടുത്തുന്നു എന്നും ചൂണ്ടിക്കാണിക്കുന്നു.
Q5: LangGraph പ്രവൃത്തിയിലേക്ക് ഹ്യൂമൻ-ഇൻ-ദി-ലൂപ്പ് റിവ്യൂ എങ്ങനെ ചേർക്കാം?
വിശ്വാസം താഴെയാണ്ങ്കിൽ അല്ലെങ്കിൽ താസ്ക് സങ്കീർണ്ണമാണെങ്കിൽ അംഗീകാരം നോഡിലേയ്ക്ക് നിബന്ധനയുള്ള ഒരു എഡ്ജ് ചേർക്കുക. നിരവധി മികച്ച ട്യൂട്ടോറിയലുകൾ HITL ഗേറ്റുകൾ ഉപയോഗിച്ച് നിയമാനുസൃത ആവശ്യകതകൾ പാലിക്കുന്നു.