#LangGraph

import { StateSchema, MessagesValue, ReducedValue, UntrackedValue } from "@langchain/langgraph";
import * as z from "zod";

const AgentState = new StateSchema({
  // 1. 일반 zod 스키마 → 마지막 값으로 덮어씀
  currentStep: z.string().default(""),

  // 2. ReducedValue → 합치는 방법을 직접 정함 (여기선 배열 누적)
  history: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (current, update) => current.concat(update),
  }),

  // 3. MessagesValue → 메시지 전용 리듀서 (추가, 같은 id 면 교체)
  messages: MessagesValue,

  // 4. UntrackedValue → 체크포인트에 저장하지 않는 임시 값
  tempCache: new UntrackedValue(z.record(z.string(), z.unknown())),
});

type State = typeof AgentState.State;   // 노드가 읽는 타입
type Update = typeof AgentState.Update; // 노드가 반환하는 타입

import { StateGraph, StateSchema, ReducedValue, START, END, type GraphNode } from "@langchain/langgraph";
import * as z from "zod";

const CounterState = new StateSchema({
  count: z.number().default(0),
  log: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});

const increment: GraphNode<typeof CounterState> = (state) => ({
  count: state.count + 1,
  log: [`${state.count} → ${state.count + 1}`],
});

const double: GraphNode<typeof CounterState> = (state) => ({
  count: state.count * 2,
  log: [`${state.count} → ${state.count * 2}`],
});

const graph = new StateGraph(CounterState)
  .addNode("increment", increment)
  .addNode("double", double)
  .addEdge(START, "increment")
  .addEdge("increment", "double")
  .addEdge("double", END)
  .compile();

await graph.invoke({ count: 5 }); // { count: 12, log: ["5 → 6", "6 → 12"] }

import { StateGraph, StateSchema, START, END, type GraphNode, type ConditionalEdgeRouter } from "@langchain/langgraph";
import * as z from "zod";

const RouteState = new StateSchema({
  input: z.string().default(""),
  category: z.string().default(""),
  output: z.string().default(""),
});

const classify: GraphNode<typeof RouteState> = (state) => ({
  category: state.input.includes("환불") ? "refund" : "general",
});

const route: ConditionalEdgeRouter<{
  InputSchema: typeof RouteState;
  Nodes: "handleRefund" | "handleGeneral";
}> = (state) => (state.category === "refund" ? "handleRefund" : "handleGeneral");

const graph = new StateGraph(RouteState)
  .addNode("classify", classify)
  .addNode("handleRefund", () => ({ output: "환불 팀으로 연결합니다." }))
  .addNode("handleGeneral", () => ({ output: "일반 상담으로 처리합니다." }))
  .addEdge(START, "classify")
  .addConditionalEdges("classify", route, ["handleRefund", "handleGeneral"])
  .addEdge("handleRefund", END)
  .addEdge("handleGeneral", END)
  .compile();

// 부분 코드 — ScoreState, builder 는 앞의 예제처럼 정의했다고 가정
import { Command, Send } from "@langchain/langgraph";

// Command: 상태 업데이트 + 다음 노드를 노드 안에서 함께 결정
const evaluate: GraphNode<{ InputSchema: typeof ScoreState; Nodes: "pass" | "fail" }> = (state) =>
  new Command({
    update: { score: state.score },
    goto: state.score >= 60 ? "pass" : "fail",
  });

builder.addNode("evaluate", evaluate, { ends: ["pass", "fail"] }); // ends 로 이동 가능 대상을 선언

// Send: 입력 개수만큼 worker 노드를 병렬 실행 (map-reduce)
builder.addConditionalEdges(
  START,
  (state) => state.subjects.map((s) => new Send("worker", { subject: s })),
  ["worker"],
);

for await (const chunk of await graph.stream({ count: 1 }, { streamMode: "updates" })) {
  console.log(chunk); // { increment: { count: 2, ... } } → { double: { count: 4, ... } }
}

import { MemorySaver } from "@langchain/langgraph";

const app = builder.compile({ checkpointer: new MemorySaver() });

const config = { configurable: { thread_id: "thread-A" } };
await app.invoke({}, config); // count: 1
await app.invoke({}, config); // count: 2 ← 상태가 이어짐
await app.invoke({}, { configurable: { thread_id: "thread-B" } }); // count: 1 ← 다른 스레드

import { StateGraph, MemorySaver, Command, START, END, interrupt, isInterrupted } from "@langchain/langgraph";
import * as z from "zod";

const ApprovalState = z.object({
  amount: z.number(),
  status: z.string().nullable().default(() => null),
});

const graph = new StateGraph(ApprovalState)
  .addNode("charge", (state) => {
    const approved = interrupt({ question: `${state.amount}원을 결제할까요?` });
    return { status: approved === true ? "결제완료" : "취소됨" };
  })
  .addEdge(START, "charge")
  .addEdge("charge", END)
  .compile({ checkpointer: new MemorySaver() });

const config = { configurable: { thread_id: "charge-1" } };

const paused = await graph.invoke({ amount: 50_000 }, config);
if (isInterrupted(paused)) {
  console.log(paused.__interrupt__[0].value); // { question: "50000원을 결제할까요?" }
}

const resumed = await graph.invoke(new Command({ resume: true }), config);
console.log(resumed.status); // "결제완료"

import {
  StateGraph, StateSchema, MessagesValue, START, END,
  type GraphNode, type ConditionalEdgeRouter,
} from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { ChatAnthropic } from "@langchain/anthropic";
import { tool, type AIMessage } from "langchain";
import * as z from "zod";

const getWeather = tool(({ city }: { city: string }) => `${city}: 맑음, 24도`, {
  name: "get_weather",
  description: "도시의 현재 날씨를 조회한다",
  schema: z.object({ city: z.string().describe("도시 이름") }),
});

const llm = new ChatAnthropic({ model: "claude-sonnet-4-6" }).bindTools([getWeather]);

const AgentState = new StateSchema({ messages: MessagesValue });

// 노드 1 — 모델 호출
const callModel: GraphNode<typeof AgentState> = async (state) => {
  const response = await llm.invoke([
    { role: "system", content: "너는 날씨를 알려주는 비서다." },
    ...state.messages,
  ]);
  return { messages: [response] };
};

// 노드 2 — 도구 실행 (tool_call_id 를 맞춘 ToolMessage 를 만들어 줌)
const toolNode = new ToolNode([getWeather]);

// 라우터 — 도구 호출이 남아 있으면 tools, 없으면 종료
const shouldContinue: ConditionalEdgeRouter<{ InputSchema: typeof AgentState; Nodes: "tools" }> = (state) => {
  const last = state.messages.at(-1) as AIMessage;
  return last?.tool_calls?.length ? "tools" : END;
};

const agent = new StateGraph(AgentState)
  .addNode("model_request", callModel)
  .addNode("tools", toolNode)
  .addEdge(START, "model_request")
  .addConditionalEdges("model_request", shouldContinue, ["tools", END])
  .addEdge("tools", "model_request") // 도구 결과를 들고 모델로 돌아감 = 루프
  .compile();

const result = await agent.invoke({ messages: [{ role: "user", content: "서울 날씨 어때?" }] });
console.log(result.messages.at(-1)?.text);

import type { RetryPolicy } from "@langchain/langgraph";

const retryPolicy: RetryPolicy = { maxAttempts: 3, initialInterval: 1000 }; // 간격 단위는 ms

workflow.addNode("searchDocumentation", searchDocumentation, { retryPolicy });

import { Command, type GraphNode } from "@langchain/langgraph";

const executeTool: GraphNode<{ InputSchema: typeof State; Nodes: "agent" }> = async (state) => {
  try {
    const result = await runTool(state.toolCall);
    return new Command({ update: { toolResult: result }, goto: "agent" });
  } catch (error) {
    // 무엇이 잘못됐는지 LLM 이 보고 접근 방식을 바꾸게 함
    return new Command({ update: { toolResult: `Tool error: ${error}` }, goto: "agent" });
  }
};

import { Command, interrupt, type GraphNode } from "@langchain/langgraph";

const lookupCustomerHistory: GraphNode<{
  InputSchema: typeof State;
  Nodes: "lookupCustomerHistory" | "draftResponse";
}> = async (state) => {
  if (!state.customerId) {
    const userInput = interrupt({
      message: "Customer ID needed",
      request: "구독 이력 조회를 위해 고객 계정 ID 를 입력해 주세요",
    });
    return new Command({ update: { customerId: userInput.customerId }, goto: "lookupCustomerHistory" });
  }

  const customerData = await fetchCustomerHistory(state.customerId);
  return new Command({ update: { customerHistory: customerData }, goto: "draftResponse" });
};

const sendReply: GraphNode<typeof EmailAgentState> = async (state) => {
  await emailService.send(state.responseText); // 실패하면 예외가 그대로 전파됨
  return {};
};

const app = new StateGraph(EmailAgentState)
  .addNode("readEmail", readEmail)
  .addNode("classifyIntent", classifyIntent, { ends: ["searchDocumentation", "bugTracking", "humanReview"] })
  .addNode("searchDocumentation", searchDocumentation, { retryPolicy: { maxAttempts: 3 } })
  .addNode("bugTracking", bugTracking)
  .addNode("draftResponse", draftResponse, { ends: ["humanReview", "sendReply"] })
  .addNode("humanReview", humanReview, { ends: ["draftResponse", "sendReply", END] })
  .addNode("sendReply", sendReply)
  .addEdge(START, "readEmail")
  .addEdge("readEmail", "classifyIntent")
  .addEdge("searchDocumentation", "draftResponse")
  .addEdge("bugTracking", "draftResponse")
  .addEdge("sendReply", END)
  .compile({ checkpointer });

const config = { configurable: { thread_id: `email-${emailId}` } };
const paused = await app.invoke({ emailContent, senderEmail }, config);
// 검토가 필요하면 __interrupt__ 로 멈춤 → 담당자 결정 후
await app.invoke(new Command({ resume: { approved: true, editedResponse } }), config);