What is LangGraph used for?

LangGraph is used to build reliable agent and multi-agent workflows with explicit control flow, persistent state, and checkpoints. It’s ideal for loops, tool use, human-in-the-loop steps, and complex orchestration.

How do I install and set up LangGraph?

Install with `pip install langgraph langchain` (Python) or `npm i @langchain/langgraph langchain` (JS/TS). Configure your LLM provider (e.g., `OPENAI_API_KEY`) and start by defining a `State`, nodes, and conditional edges.

Is LangGraph different from LangChain?

Yes. LangGraph is a separate package that focuses on graph-based orchestration and stateful, resumable workflows. It complements LangChain’s models, tools, and integrations, adding determinism and reliability.

Can I build multi-agent systems with LangGraph?

Absolutely. LangGraph supports supervisor–worker patterns, debate or committee agents, and policy gates. You route between agents via conditional edges and maintain shared or segmented state.

How do I prevent infinite loops in LangGraph?

Define clear termination conditions and always provide an `END` path in routers. Add loop counters or timeouts in state, prune messages, and write unit tests to verify routing logic.

Paano Gamitin ang LangGraph: Isang Praktikal na Gabay sa Pagbuo ng Maaasahang AI Agents

Kung sinubukan mo nang gumawa ng agentic workflows gamit ang mga simpleng chains at tools, malamang naka-encounter ka na ng mga limitasyon—hindi maasahang loops, madaling masira na control flow, at mahirap i-debug na estado. Binabago ng LangGraph ang sitwasyong ito sa pamamagitan ng pagbibigay ng graph-native na paraan para idisenyo, kontrolin, at i-trace ang kilos ng agent nang may persistence at guardrails.

Sa hands-on na tutorial na ito, matututuhan mo kung paano gamitin ang LangGraph mula sa simula hanggang maging handa para sa production: ano ito, paano gumagana ang graph model, at paano bumuo, mag-test, at mag-iterate ng tunay na agent workflows—single-agent at multi-agent—gamit ang Python o JavaScript.

Mahalagang banggitin: kung nagda-draft ka ng prompts, nagdidiagram ng mga flow, o kasabay na nag-eedit ng code kasama ang isang AI assistant, makakatulong ang Sider.AI para pabilisin ang iyong LangGraph iterations (prompt refinement, unit tests, at doc lookups) nang direkta sa iyong browser. Para sa karagdagang detalye, tingnan ang https://sider.ai/.

Ano ang LangGraph—at Bakit Ito Gamitin?

Ang LangGraph ay isang framework para sa paggawa ng agentic at multi-agent na LLM applications na may explicit control flow, persistent state, at event-based tracing. Bahagi ito ng LangChain ecosystem ngunit pinapanatili bilang hiwalay na package. Pinipili ito ng mga developer para gawing mas maaasahan at kontrolado ang mga agent, na may mga tampok tulad ng deterministic edges, resumable checkpoints, at isang malinaw na mental model para sa mga kumplikadong loops at paggamit ng mga tools.

Pangunahing mga dahilan kung bakit tinatangkilik ng mga team ang LangGraph:

Pagkakatiwalaan at guardrails: tukuyin nang eksakto kung kailan maaaring kumilos ang isang agent, humingi ng tulong, o magpasa ng gawain.

Resumability: mag-checkpoint ng estado, makabawi mula sa mga pagkabigo, at ipagpatuloy kung saan ka tumigil.

Multi-agent na pattern: pagbuo ng mga espesiyalista, debate, o supervisor–worker flows.

Observability: event streams at state snapshots na nagpapadali sa pag-debug.

Kung gusto mo ng istrakturadong pag-aaral, magandang simula ang opisyal na Introduction to LangGraph course. Meron din video course para sa mga baguhan na nagtuturo ng mga kumplikadong conversational AI workflows.

Pangunahing Mental Model: Nodes, Edges, at Estado

Isipin ang LangGraph bilang isang directed graph sa ibabaw ng iyong application state.

Nodes: executable na hakbang (hal., tumawag ng LLM, patakbuhin ang isang tool, i-route sa ibang agent).

Edges: routing logic na tumutukoy kung aling node ang susunod na tatakbo.

Estado: isang typed, mergeable na object (mga mensahe, variables, resulta ng tool) na dinadala sa mga nodes.

Channels: mga pinangalanang bahagi ng estado na maaaring basahin/sulat ng nodes (hal., messages, context).

Checkpoints: persistent na snapshots ng estado na nagbibigay-daan para mag-resume o gumawa ng branches.

Tumatanggap ang isang node ng kasalukuyang estado, ina-update ito, at nagbabalik ng partial patch. Pinipili ng mga edges ang susunod na node base sa resulta ng estado. Ginagawa nitong malinaw ang loops, retries, at supervision, na mahalaga para sa pagiging maaasahan.

Pag-install at Setup

Sinusuportahan ng LangGraph ang Python at JavaScript/TypeScript. Piliin ang stack mo at i-install kasama ang LangChain at ang iyong nais na LLM client.

Python:

pip install -U langgraph langchain openai
# Opsyonal: tracing, vector stores, tools, atbp.

JavaScript/TypeScript:

pnpm add @langchain/langgraph langchain openai
# o
npm install @langchain/langgraph langchain openai

Environment variables:

export OPENAI_API_KEY=sk-... # o sa provider na pinili mo

Ang Iyong Unang LangGraph: Isang Minimal na Single-Agent Loop (Python)

Bumubuo ang halimbawa na ito ng simpleng agent na nagre-reason, gumagamit ng mga tools, at nagdedesisyon kung kailan titigil.

from typing import TypedDict, List
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
# 1) Itakda ang Estado
action_token = "<act>" # simpleng senyales para sa paggamit ng tool kumpara sa pinal na sagot
class State(TypedDict):
messages: List.
- Libreng Intro sa LangGraph course mula sa LangChain Academy.
- Kompleto at beginner-friendly na video course para sa mga kumplikadong conversational workflows.
## Pagwawakas: Mula Prototype hanggang Maaasahang Agents
Binibigay ng LangGraph ang graph-native kontrol sa LLM applications: malinaw na mga ruta, resumable na estado, at behaviors na madaling obserbahan. Magsimula sa maliit gamit ang single-agent loop, pagkatapos ay lumipat sa multi-agent supervisors, policy gates, at human review. Panatilihing simple ang mga nodes, malinis ang estado, at deterministic ang mga ruta.
Mga Hakbang sa Aksyon:
- Gumawa ng minimal na estado at dalawang nodes (`agent`, `tool`).
- Magdagdag ng router na may malinaw na `END` path.
- Maglagay ng checkpoints at tests bago palawakin.
- I-layer ang mga tools at espesiyalista na mga agent habang lumalago.
Sa mga pundasyong ito—at matibay na debugging loop—magagawa mong mag-deploy ng mga agent system na palaging gumagawa ng tama sa production.
### FAQ
Q1:Ano ang gamit ng LangGraph?
Ginagamit ang LangGraph para bumuo ng maaasahang agent at multi-agent workflows na may explicit control flow, persistent state, at checkpoints. Mainam ito para sa mga loops, paggamit ng tools, human-in-the-loop na mga hakbang, at kumplikadong orchestration.
Q2:Paano ako mag-iinstall at magsi-set up ng LangGraph?
Iinstall gamit ang `pip install langgraph langchain` (Python) o `npm i @langchain/langgraph langchain` (JS/TS). I-configure ang iyong LLM provider (hal., `OPENAI_API_KEY`) at magsimula sa pag-define ng `State`, mga node, at conditional edges.
Q3:Iba ba ang LangGraph kumpara sa LangChain?
Oo. Ang LangGraph ay hiwalay na package na nakatuon sa graph-based orchestration at stateful, resumable workflows. Ito ay kompleto sa mga models, tools, at integrations ng LangChain, na nagbibigay ng determinism at pagiging maaasahan.
Q4:Pwede ba akong gumawa ng multi-agent systems gamit ang LangGraph?
Oo naman. Sinusuportahan ng LangGraph ang supervisor–worker patterns, debate o committee agents, at policy gates. Nireroute mo ang mga agent gamit ang conditional edges habang pinananatili ang shared o segmented na estado.
Q5:Paano ko maiiwasan ang mga walang katapusang loop sa LangGraph?
<a39>Tukuyin ang malinaw na pagkakatapos na kundisyon at palaging magbigay ng `END` path sa mga router. Maglagay ng loop counters o timeouts sa estado, alisin ang mga lumang mensahe, at sumulat ng unit tests para tiyakin ang routing logic.