#Step 15 — 장기 메모리와 Store

import { createAgent, tool, type ToolRuntime, FakeToolCallingModel } from "langchain";
import { InMemoryStore, MemorySaver, type BaseStore } from "@langchain/langgraph";
import * as z from "zod";

const checkpointer = new MemorySaver();
const store = new InMemoryStore();

const remember = tool(
  async ({ fact }, runtime: ToolRuntime<any, { userId: string }>) => {
    const s = runtime.store as unknown as BaseStore;
    await s.put([runtime.context.userId, "memories"], crypto.randomUUID(), { fact });
    return `기억했습니다: ${fact}`;
  },
  {
    name: "remember",
    description: "사용자에 대해 알게 된 사실을 장기 메모리에 저장합니다.",
    schema: z.object({ fact: z.string() }),
  },
);

const mkAgent = (toolCalls: Array<Array<{ name: string; args: object; id: string }>>) =>
  createAgent({
    model: new FakeToolCallingModel({ toolCalls }),
    tools: [remember],
    contextSchema: z.object({ userId: z.string() }),
    checkpointer,  // 단기: 스레드별 대화 기록
    store,         // 장기: 스레드를 넘는 사실
  });

// 스레드 A — 사실을 저장
await mkAgent([[{ name: "remember", args: { fact: "좋아하는 음식은 피자" }, id: "call_1" }], []])
  .invoke(
    { messages: [{ role: "user", content: "나는 피자를 좋아해" }] },
    { configurable: { thread_id: "thread-A" }, context: { userId: "user_1" } },
  );

// 스레드 B — 완전히 새 대화
const threadB = await mkAgent([[]]).invoke(
  { messages: [{ role: "user", content: "안녕" }] },
  { configurable: { thread_id: "thread-B" }, context: { userId: "user_1" } },
);

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

const store = new InMemoryStore();
const ns = ["user_1", "memories"];

// put(namespace, key, value)
await store.put(ns, "m1", { text: "피자를 좋아함", kind: "semantic" });
await store.put(ns, "m2", { text: "채식 지향", kind: "semantic" });
await store.put(ns, "m3", { text: "2026-07-01 환불을 요청했음", kind: "episodic" });

// get → Item | null
const one = await store.get(ns, "m1");

// 쿼리 없이 부르면 그냥 목록
const all = await store.search(ns);

// filter — value 안의 필드를 정확히 매칭
const semantic = await store.search(ns, { filter: { kind: "semantic" } });

// delete
await store.delete(ns, "m2");

// listNamespaces — 어떤 네임스페이스가 있는지 훑어보기
await store.put(["user_2", "memories"], "x1", { text: "다른 사용자" });
const namespaces = await store.listNamespaces({ maxDepth: 2 });

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

const store = new InMemoryStore();

const tries: Array<[string, string[]]> = [
  ["빈 네임스페이스", []],
  ["예약어 langgraph", ["langgraph", "x"]],
  ["점이 든 라벨", ["a.b"]],
];

for (const [label, ns] of tries) {
  try {
    await store.put(ns, "k", { t: 1 });
  } catch (e) {
    console.log(label, (e as Error).message);
  }
}

const ns = ["user_1", "memories"];
await store.put(ns, "ref", { content: "원본" });

const item = await store.get(ns, "ref");
(item!.value as Record<string, unknown>)["content"] = "몰래 바꿈";  // put 을 부르지 않았습니다

console.log(JSON.stringify((await store.get(ns, "ref"))?.value));
console.log(item === (await store.get(ns, "ref")));

const store = new InMemoryStore();

const probe = tool(
  async (_input, runtime: ToolRuntime<any, { userId: string }>) => {
    const isInMemory = (runtime.store as unknown) instanceof InMemoryStore;
    const s = runtime.store as unknown as BaseStore;
    await s.put([runtime.context.userId, "memories"], "from_tool", { text: "도구가 저장함" });
    return `constructor=${runtime.store?.constructor?.name} instanceof InMemoryStore=${isInMemory}`;
  },
  { name: "probe", description: "store 접근을 확인합니다.", schema: z.object({}) },
);

const agent = createAgent({
  model: new FakeToolCallingModel({ toolCalls: [[{ name: "probe", args: {}, id: "call_1" }], []] }),
  tools: [probe],
  contextSchema: z.object({ userId: z.string() }),
  store,   // ← 여기서 준 store 가 도구의 runtime.store 로 흘러 들어갑니다
});

const res = await agent.invoke(
  { messages: [{ role: "user", content: "확인해줘" }] },
  { context: { userId: "user_1" } },
);

const saveMemory = tool(
  async ({ content, kind }, runtime: ToolRuntime<any, { userId: string }>) => {
    const s = runtime.store as unknown as BaseStore;
    const ns = [runtime.context.userId, "memories"];

    // 갱신 전략: 같은 내용이 이미 있으면 새로 쌓지 않고 덮어씁니다.
    const existing = await s.search(ns, { filter: { kind } });
    const dup = existing.find((i) => i.value["content"] === content);
    const key = dup?.key ?? crypto.randomUUID();

    await s.put(ns, key, { content, kind, updatedAt: new Date().toISOString() }, ["content"]);
    return dup ? `이미 알고 있어 갱신했습니다: ${content}` : `저장했습니다: ${content}`;
  },
  {
    name: "save_memory",
    description: [
      "사용자에 대해 새로 알게 된, 다음 대화에서도 쓸모 있는 사실을 저장합니다.",
      "kind: semantic=변하지 않는 사실/선호, episodic=특정 시점의 사건, procedural=일하는 방식.",
      "일회성 잡담이나 이미 저장된 내용은 저장하지 마세요.",
    ].join(" "),
    schema: z.object({
      content: z.string().describe("한 문장으로 요약한 사실"),
      kind: z.enum(["semantic", "episodic", "procedural"]),
    }),
  },
);

const noIndex = new InMemoryStore();   // index 설정 없음
await noIndex.put(["u", "m"], "a", { text: "피자를 좋아함" });
await noIndex.put(["u", "m"], "b", { text: "주말엔 등산을 함" });

const bad = await noIndex.search(["u", "m"], { query: "이 사용자는 뭘 먹나요?" });

import { OpenAIEmbeddings } from "@langchain/openai";

const store = new InMemoryStore({
  index: {
    embeddings: new OpenAIEmbeddings({ model: "text-embedding-3-small" }),
    dims: 1536,          // 임베딩 모델의 차원과 반드시 일치해야 합니다
    fields: ["text"],    // 이 필드만 임베딩. ["$"] 면 문서 전체.
  },
});

const ns = ["user_1", "memories"];
await store.put(ns, "m1", { text: "좋아하는 음식은 피자" });
await store.put(ns, "m2", { text: "주말마다 등산을 감" });
await store.put(ns, "m3", { text: "다크 테마를 씀" }, false);   // 인덱싱 제외

const hits = await store.search(ns, { query: "이 사용자는 뭘 먹나요?", limit: 3 });

const userId = "user_1";

await store.put([userId, "semantic"], "s1", { content: "이름은 김민수", confidence: 0.95 });
await store.put([userId, "semantic"], "s2", { content: "회사는 무신사", confidence: 0.9 });
await store.put([userId, "episodic"], "e1", { content: "2026-07-10 배송 지연으로 문의함", at: "2026-07-10" });
await store.put([userId, "procedural"], "p1", { content: "보고서는 항상 표로 먼저 요약해 줄 것" });

// 항상 주입할 것 = 의미 + 절차
const always = [
  ...(await store.search([userId, "semantic"])),
  ...(await store.search([userId, "procedural"])),
];

import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";

const store = PostgresStore.fromConnString(process.env.DB_URI!);
await store.setup();   // ← 최초 1회 테이블/인덱스 생성

// TTL — 오래된 기억을 자동으로 만료
await store.put(ns, key, value, ["content"], { ttl: 60 * 24 * 90 });  // 분 단위 (여기선 90일)

const ContextSchema = z.object({ userId: z.string() });
type Ctx = z.infer<typeof ContextSchema>;

const store = new InMemoryStore();
const checkpointer = new MemorySaver();

const saveMemory = tool(
  async ({ content }, runtime: ToolRuntime<any, Ctx>) => {
    const s = runtime.store as unknown as BaseStore;
    await s.put(
      [runtime.context.userId, "memories"],   // ← userId 를 반드시 네임스페이스에
      crypto.randomUUID(),
      { content, updatedAt: new Date().toISOString() },
      ["content"],
    );
    return `기억했습니다: ${content}`;
  },
  {
    name: "save_memory",
    description: "사용자의 선호·사실 중 다음 대화에서도 쓸모 있는 것을 저장합니다. 확실한 것만 저장하세요.",
    schema: z.object({ content: z.string().describe("한 문장으로 요약한 사실") }),
  },
);

const searchMemory = tool(
  async ({ query }, runtime: ToolRuntime<any, Ctx>) => {
    const s = runtime.store as unknown as BaseStore;
    const items = await s.search([runtime.context.userId, "memories"], { query, limit: 5 });
    if (items.length === 0) return "저장된 기억이 없습니다.";
    return items.map((i) => `- ${i.value["content"]}`).join("\n");
  },
  {
    name: "search_memory",
    description: "사용자에 대해 이전에 저장해 둔 사실을 검색합니다. 답하기 전에 먼저 호출하세요.",
    schema: z.object({ query: z.string().describe("찾고 싶은 내용") }),
  },
);

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  // OpenAI 대안: model: "openai:gpt-5.5"
  tools: [saveMemory, searchMemory],
  systemPrompt: [
    "너는 개인 비서다.",
    "사용자가 자기 선호나 사실을 말하면 save_memory 로 저장해라.",
    "사용자에 대한 질문에 답하기 전에는 search_memory 로 먼저 확인해라.",
    "기억에 없는 것을 지어내지 마라.",
  ].join(" "),
  contextSchema: ContextSchema,
  checkpointer,
  store,
});

const cfg = (thread: string) => ({
  configurable: { thread_id: thread },
  context: { userId: "user_1" },
});

// 1일차 — 선호를 알려줍니다.
await agent.invoke(
  { messages: [{ role: "user", content: "나는 매운 음식을 못 먹고, 채식을 지향해." }] },
  cfg("day-1"),
);

// 2일차 — 완전히 새 스레드. 대화 기록은 없지만 store 는 살아 있습니다.
const day2 = await agent.invoke(
  { messages: [{ role: "user", content: "점심 메뉴 하나만 추천해줘." }] },
  cfg("day-2"),
);

/**
 * Step 15 — 장기 메모리와 Store
 * 실행: npx tsx docs/reference/langchain/step-15-long-term-memory/practice.ts
 *
 * [15-1] ~ [15-4], [15-7] 블록은 API 키 없이 돌아갑니다 (Store 만 직접 조작).
 * [15-6], [15-9] 는 실제 모델/임베딩 호출이 필요합니다 — 키가 없으면 자동으로 건너뜁니다.
 */
import "dotenv/config";

import { createAgent, tool, type ToolRuntime, FakeToolCallingModel } from "langchain";
import { InMemoryStore, MemorySaver, type BaseStore, type Item } from "@langchain/langgraph";
import * as z from "zod";

import { printSection, printKV, printJson } from "../project/src/lib/print.js";

const hasAnthropic = process.env["ANTHROPIC_API_KEY"] !== undefined;
const hasOpenAI = process.env["OPENAI_API_KEY"] !== undefined;

/* ===== [15-1] 단기 vs 장기 — 같은 사실을 두 곳에 넣어 보고 스레드를 바꿔 본다 ===== */

printSection("[15-1] 단기(checkpointer) vs 장기(store)");

{
  // checkpointer 는 "스레드 안"의 대화 기록을, store 는 "스레드를 넘는" 사실을 갖습니다.
  // 둘은 서로를 대체하지 않습니다. 아래에서 같은 에이전트에 둘 다 붙입니다.
  const checkpointer = new MemorySaver();
  const store = new InMemoryStore();

  const remember = tool(
    async ({ fact }, runtime: ToolRuntime<any, { userId: string }>) => {
      // 함정: runtime.store 의 TS 타입은 @langchain/core 의 BaseStore<string, unknown> 입니다.
      // 실제로 주입되는 객체는 langgraph 의 BaseStore(AsyncBatchedStore) 이므로 캐스팅합니다.
      const s = runtime.store as unknown as BaseStore;
      await s.put([runtime.context.userId, "memories"], crypto.randomUUID(), { fact });
      return `기억했습니다: ${fact}`;
    },
    {
      name: "remember",
      description: "사용자에 대해 알게 된 사실을 장기 메모리에 저장합니다.",
      schema: z.object({ fact: z.string() }),
    },
  );

  // 실제 모델 대신 FakeToolCallingModel 로 도구 호출을 강제합니다 (API 키 불필요, 결정적).
  // 주의: FakeToolCallingModel 은 호출될 때마다 toolCalls 배열을 순서대로 소비합니다.
  // 스레드마다 의도한 행동을 정확히 재현하려고 에이전트를 따로 만듭니다.
  const mkAgent = (toolCalls: Array<Array<{ name: string; args: object; id: string }>>) =>
    createAgent({
      model: new FakeToolCallingModel({ toolCalls }),
      tools: [remember],
      contextSchema: z.object({ userId: z.string() }),
      checkpointer, // 단기: 스레드별 대화 기록
      store, // 장기: 스레드를 넘는 사실
    });

  // 스레드 A — 사실을 저장합니다.
  await mkAgent([[{ name: "remember", args: { fact: "좋아하는 음식은 피자" }, id: "call_1" }], []]).invoke(
    { messages: [{ role: "user", content: "나는 피자를 좋아해" }] },
    { configurable: { thread_id: "thread-A" }, context: { userId: "user_1" } },
  );

  // 스레드 B — 완전히 새 대화. 저장은 하지 않고 인사만 합니다.
  // checkpointer 관점에서 thread-A 의 메시지는 여기서 보이지 않습니다.
  const threadB = await mkAgent([[]]).invoke(
    { messages: [{ role: "user", content: "안녕" }] },
    { configurable: { thread_id: "thread-B" }, context: { userId: "user_1" } },
  );

  printKV({
    "thread-B 의 메시지 수": threadB.messages.length, // 새 스레드라 A 의 기록이 없음
    "store 에 남은 기억": (await store.search(["user_1", "memories"])).map((i) => i.value["fact"]).join(", "),
  });
  // → 대화 기록은 스레드마다 리셋되지만, store 의 사실은 스레드를 넘어 그대로 남습니다.
}

/* ===== [15-2] BaseStore 인터페이스 — put / get / search / delete / listNamespaces ===== */

printSection("[15-2] BaseStore 기본 연산");

{
  const store = new InMemoryStore();
  const ns = ["user_1", "memories"]; // namespace = 문자열 배열(계층 경로)

  // put(namespace, key, value) — key 가 같으면 덮어씁니다(upsert).
  await store.put(ns, "m1", { text: "피자를 좋아함", kind: "semantic" });
  await store.put(ns, "m2", { text: "채식 지향", kind: "semantic" });
  await store.put(ns, "m3", { text: "2026-07-01 환불을 요청했음", kind: "episodic" });

  // get → Item | null
  const one = await store.get(ns, "m1");
  printJson("get(ns, 'm1')", one);
  // Item 의 필드는 결정적입니다: value, key, namespace, createdAt, updatedAt

  // search(namespacePrefix) — 쿼리 없이 부르면 그냥 목록입니다.
  const all = await store.search(ns);
  printKV({ "search(ns) 개수": all.length, keys: all.map((i) => i.key).join(", ") });

  // filter — value 안의 필드를 정확히 매칭. $eq/$ne/$gt/$gte/$lt/$lte 연산자도 됩니다.
  const semantic = await store.search(ns, { filter: { kind: "semantic" } });
  printKV({ "filter kind=semantic": semantic.map((i) => i.key).join(", ") });

  // delete
  await store.delete(ns, "m2");
  printKV({ "delete 후": (await store.search(ns)).map((i) => i.key).join(", ") });

  // listNamespaces — 어떤 네임스페이스들이 있는지 훑어보기
  await store.put(["user_2", "memories"], "x1", { text: "다른 사용자" });
  printJson("listNamespaces({ maxDepth: 2 })", await store.listNamespaces({ maxDepth: 2 }));
}

/* ===== [15-3] InMemoryStore — 네임스페이스 규칙과 검증 ===== */

printSection("[15-3] InMemoryStore 와 네임스페이스 규칙");

{
  const store = new InMemoryStore();

  // 네임스페이스는 "빈 배열 금지", "루트 라벨 langgraph 금지", "라벨에 점(.) 금지" 입니다.
  // 아래 셋은 모두 조용히 넘어가지 않고 즉시 에러를 던집니다 — 확인해 봅니다.
  const tries: Array<[string, string[]]> = [
    ["빈 네임스페이스", []],
    ["예약어 langgraph", ["langgraph", "x"]],
    ["점이 든 라벨", ["a.b"]],
  ];

  for (const [label, ns] of tries) {
    try {
      await store.put(ns, "k", { t: 1 });
      printKV({ [label]: "통과(예상 밖)" });
    } catch (e) {
      printKV({ [label]: `에러: ${(e as Error).message}` });
    }
  }

  // 정상 네임스페이스
  await store.put(["user_1", "memories"], "ok", { t: 1 });
  printKV({ "정상 네임스페이스": "통과" });

  // InMemoryStore 는 값을 "복사 없이" 그대로 들고 있습니다 — get 은 내부 참조를 돌려줍니다.
  const ns = ["user_1", "memories"];
  await store.put(ns, "ref", { content: "원본" });
  const item = await store.get(ns, "ref");
  (item!.value as Record<string, unknown>)["content"] = "몰래 바꿈"; // put 을 부르지 않았습니다

  printKV({
    "value 를 직접 수정한 뒤 재조회": JSON.stringify((await store.get(ns, "ref"))?.value),
    "get 이 같은 객체를 주는가": String(item === (await store.get(ns, "ref"))),
  });
  // → put 없이 store 가 오염됩니다. 에러도 경고도 없습니다.
  //   PostgresStore 는 값을 직렬화하므로 이 동작이 다릅니다(오염되지 않습니다).
  //   즉 InMemoryStore 에서 "되던" 코드가 DB 로 바꾸면 조용히 깨집니다.
}

/* ===== [15-4] 에이전트에 store 붙이기 — 도구에서 runtime.store 접근 ===== */

printSection("[15-4] createAgent({ store }) 와 runtime.store");

{
  const store = new InMemoryStore();

  const probe = tool(
    async (_input, runtime: ToolRuntime<any, { userId: string }>) => {
      // runtime.store 는 우리가 넘긴 InMemoryStore "그 객체"가 아니라
      // AsyncBatchedStore 래퍼입니다 → instanceof 검사가 실패합니다.
      const isInMemory = (runtime.store as unknown) instanceof InMemoryStore;
      const s = runtime.store as unknown as BaseStore;
      await s.put([runtime.context.userId, "memories"], "from_tool", { text: "도구가 저장함" });
      return `constructor=${runtime.store?.constructor?.name} instanceof InMemoryStore=${isInMemory}`;
    },
    { name: "probe", description: "store 접근을 확인합니다.", schema: z.object({}) },
  );

  const model = new FakeToolCallingModel({
    toolCalls: [[{ name: "probe", args: {}, id: "call_1" }], []],
  });

  const agent = createAgent({
    model,
    tools: [probe],
    contextSchema: z.object({ userId: z.string() }),
    store, // ← 여기서 준 store 가 도구의 runtime.store 로 흘러 들어갑니다
  });

  const res = await agent.invoke(
    { messages: [{ role: "user", content: "확인해줘" }] },
    { context: { userId: "user_1" } },
  );

  // 도구가 남긴 ToolMessage 안에 진단 문자열이 들어 있습니다.
  const toolMsg = res.messages.find((m) => m.getType() === "tool");
  printKV({
    "도구가 본 store": String(toolMsg?.content),
    "바깥 store 에서 읽기": JSON.stringify((await store.get(["user_1", "memories"], "from_tool"))?.value),
  });
  // → 래퍼를 거쳤어도 쓰기는 바깥의 진짜 store 에 도달합니다.
}

/* ===== [15-5] 메모리 쓰기 — 모델이 직접 저장 도구를 호출하는 방식 ===== */

printSection("[15-5] 메모리 쓰기 — 저장 도구");

{
  const store = new InMemoryStore();

  // 저장 도구는 "무엇을 저장할지"를 모델이 정하게 합니다.
  // description 이 곧 저장 정책입니다 — 부실하면 모델이 아무거나 저장하거나 아예 안 부릅니다.
  const saveMemory = tool(
    async ({ content, kind }, runtime: ToolRuntime<any, { userId: string }>) => {
      const s = runtime.store as unknown as BaseStore;
      const ns = [runtime.context.userId, "memories"];

      // 갱신 전략: 같은 내용이 이미 있으면 새로 쌓지 않고 덮어씁니다.
      const existing = await s.search(ns, { filter: { kind } });
      const dup = existing.find((i) => i.value["content"] === content);
      const key = dup?.key ?? crypto.randomUUID();

      await s.put(ns, key, { content, kind, updatedAt: new Date().toISOString() }, ["content"]);
      return dup ? `이미 알고 있어 갱신했습니다: ${content}` : `저장했습니다: ${content}`;
    },
    {
      name: "save_memory",
      description: [
        "사용자에 대해 새로 알게 된, 다음 대화에서도 쓸모 있는 사실을 저장합니다.",
        "kind: semantic=변하지 않는 사실/선호, episodic=특정 시점의 사건, procedural=일하는 방식.",
        "일회성 잡담이나 이미 저장된 내용은 저장하지 마세요.",
      ].join(" "),
      schema: z.object({
        content: z.string().describe("한 문장으로 요약한 사실"),
        kind: z.enum(["semantic", "episodic", "procedural"]),
      }),
    },
  );

  const model = new FakeToolCallingModel({
    toolCalls: [
      [{ name: "save_memory", args: { content: "매운 음식을 못 먹는다", kind: "semantic" }, id: "c1" }],
      // 같은 사실을 또 저장하려 시도 → 갱신으로 흡수되어 행이 늘지 않습니다.
      [{ name: "save_memory", args: { content: "매운 음식을 못 먹는다", kind: "semantic" }, id: "c2" }],
      [],
    ],
  });

  const agent = createAgent({
    model,
    tools: [saveMemory],
    contextSchema: z.object({ userId: z.string() }),
    store,
  });

  await agent.invoke(
    { messages: [{ role: "user", content: "나 매운 거 못 먹어" }] },
    { context: { userId: "user_1" } },
  );

  printKV({
    "저장된 기억 수": (await store.search(["user_1", "memories"])).length, // 2번 호출했지만 1
    내용: (await store.search(["user_1", "memories"])).map((i) => i.value["content"]).join(", "),
  });
}

/* ===== [15-6] 메모리 읽기 — 시맨틱 검색 (임베딩 인덱스) ===== */

printSection("[15-6] 시맨틱 검색");

{
  // 먼저 함정부터: 인덱스 설정 없이 query 를 주면 "에러가 아니라" 그냥 정렬 안 된 목록이 옵니다.
  const noIndex = new InMemoryStore();
  await noIndex.put(["u", "m"], "a", { text: "피자를 좋아함" });
  await noIndex.put(["u", "m"], "b", { text: "주말엔 등산을 함" });
  const bad = await noIndex.search(["u", "m"], { query: "이 사용자는 뭘 먹나요?" });
  printKV({
    "인덱스 없이 query": bad.map((i) => `${i.key}(score=${i.score})`).join(", "), // score 가 전부 undefined
    "store.indexConfig": String(noIndex.indexConfig), // undefined
  });
  // → 시맨틱 검색이 조용히 "그냥 목록"으로 퇴화합니다. score 가 undefined 인지 꼭 확인하세요.

  if (hasOpenAI) {
    const { OpenAIEmbeddings } = await import("@langchain/openai");

    // 인덱스를 설정해야 진짜 시맨틱 검색이 됩니다.
    const store = new InMemoryStore({
      index: {
        embeddings: new OpenAIEmbeddings({ model: "text-embedding-3-small" }),
        dims: 1536, // text-embedding-3-small 의 기본 차원
        fields: ["text"], // 이 필드만 임베딩. ["$"] 면 문서 전체.
      },
    });

    const ns = ["user_1", "memories"];
    await store.put(ns, "m1", { text: "좋아하는 음식은 피자" });
    await store.put(ns, "m2", { text: "주말마다 등산을 감" });
    await store.put(ns, "m3", { text: "다크 테마를 씀" }, false); // 인덱싱 제외

    const hits = await store.search(ns, { query: "이 사용자는 뭘 먹나요?", limit: 3 });
    printJson(
      "시맨틱 검색 결과",
      hits.map((i) => ({ key: i.key, text: i.value["text"], score: i.score })),
    );
    // → 음식 관련 m1 이 가장 높은 score 로 올라옵니다.
    //   index:false 로 넣은 m3 는 score 가 undefined 인 채로 뒤에 붙습니다(제외되지 않습니다).
  } else {
    printKV({ 건너뜀: "OPENAI_API_KEY 가 없어 임베딩 검색을 건너뜁니다" });
  }
}

/* ===== [15-7] 메모리 유형 — 의미 / 일화 / 절차 ===== */

printSection("[15-7] 메모리 유형별 네임스페이스 분리");

{
  const store = new InMemoryStore();
  const userId = "user_1";

  // 유형을 네임스페이스로 나누면 "읽을 때 필요한 것만" 가져올 수 있습니다.
  await store.put([userId, "semantic"], "s1", { content: "이름은 김민수", confidence: 0.95 });
  await store.put([userId, "semantic"], "s2", { content: "회사는 무신사", confidence: 0.9 });
  await store.put([userId, "episodic"], "e1", {
    content: "2026-07-10 배송 지연으로 문의함",
    at: "2026-07-10",
  });
  await store.put([userId, "procedural"], "p1", {
    content: "보고서는 항상 표로 먼저 요약해 줄 것",
  });

  for (const kind of ["semantic", "episodic", "procedural"]) {
    const items = await store.search([userId, kind]);
    printKV({ [kind]: items.map((i) => i.value["content"]).join(" | ") });
  }

  // 절차기억은 보통 "시스템 프롬프트에 항상 주입", 의미기억은 "항상 주입",
  // 일화기억은 "관련될 때만 검색해서 주입" 하는 게 실무 기본값입니다.
  const always = [
    ...(await store.search([userId, "semantic"])),
    ...(await store.search([userId, "procedural"])),
  ];
  printKV({ "프롬프트에 항상 넣을 것": always.length + "건" });
}

/* ===== [15-8] 영속 Store — PostgresStore (연결 문자열이 있을 때만) ===== */

printSection("[15-8] 영속 Store");

{
  // InMemoryStore 는 프로세스가 죽으면 전부 사라집니다. 프로덕션에서는 DB 백엔드를 씁니다.
  //
  //   npm install @langchain/langgraph-checkpoint-postgres
  //
  //   import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
  //   const store = PostgresStore.fromConnString(process.env.DB_URI!);
  //   await store.setup();   // ← 최초 1회 테이블/인덱스 생성. 빠뜨리면 런타임에 실패합니다.
  //
  // 이 실습 프로젝트에는 postgres 패키지가 없으므로 코드는 주석으로만 둡니다.
  // 인터페이스가 BaseStore 로 같기 때문에, 아래 [15-9] 의 에이전트 코드는
  // store 를 만드는 한 줄만 바꾸면 그대로 돌아갑니다.
  printKV({
    "InMemoryStore": "프로세스와 함께 소멸 — 개발/테스트용",
    "PostgresStore": "@langchain/langgraph-checkpoint-postgres/store — setup() 필수",
    "인터페이스": "둘 다 BaseStore — 교체 시 코드 변경 없음",
  });
}

/* ===== [15-9] 실전: 사용자 선호를 기억하는 개인 비서 ===== */

printSection("[15-9] 개인 비서 에이전트");

{
  const ContextSchema = z.object({ userId: z.string() });
  type Ctx = z.infer<typeof ContextSchema>;

  const store = new InMemoryStore();
  const checkpointer = new MemorySaver();

  const saveMemory = tool(
    async ({ content }, runtime: ToolRuntime<any, Ctx>) => {
      const s = runtime.store as unknown as BaseStore;
      await s.put(
        [runtime.context.userId, "memories"], // ← userId 를 반드시 네임스페이스에
        crypto.randomUUID(),
        { content, updatedAt: new Date().toISOString() },
        ["content"],
      );
      return `기억했습니다: ${content}`;
    },
    {
      name: "save_memory",
      description:
        "사용자의 선호·사실 중 다음 대화에서도 쓸모 있는 것을 저장합니다. 확실한 것만 저장하세요.",
      schema: z.object({ content: z.string().describe("한 문장으로 요약한 사실") }),
    },
  );

  const searchMemory = tool(
    async ({ query }, runtime: ToolRuntime<any, Ctx>) => {
      const s = runtime.store as unknown as BaseStore;
      const items: Item[] = await s.search([runtime.context.userId, "memories"], { query, limit: 5 });
      if (items.length === 0) return "저장된 기억이 없습니다.";
      return items.map((i) => `- ${i.value["content"]}`).join("\n");
    },
    {
      name: "search_memory",
      description: "사용자에 대해 이전에 저장해 둔 사실을 검색합니다. 답하기 전에 먼저 호출하세요.",
      schema: z.object({ query: z.string().describe("찾고 싶은 내용") }),
    },
  );

  if (hasAnthropic) {
    const agent = createAgent({
      model: "anthropic:claude-sonnet-4-6",
      // OpenAI 대안: model: "openai:gpt-5.5"
      tools: [saveMemory, searchMemory],
      systemPrompt: [
        "너는 개인 비서다.",
        "사용자가 자기 선호나 사실을 말하면 save_memory 로 저장해라.",
        "사용자에 대한 질문에 답하기 전에는 search_memory 로 먼저 확인해라.",
        "기억에 없는 것을 지어내지 마라.",
      ].join(" "),
      contextSchema: ContextSchema,
      checkpointer,
      store,
    });

    const cfg = (thread: string) => ({
      configurable: { thread_id: thread },
      context: { userId: "user_1" },
    });

    // 1일차 — 선호를 알려줍니다.
    const day1 = await agent.invoke(
      { messages: [{ role: "user", content: "나는 매운 음식을 못 먹고, 채식을 지향해." }] },
      cfg("day-1"),
    );
    printKV({ "1일차 응답": String(day1.messages.at(-1)?.content).slice(0, 120) });

    // 2일차 — 완전히 새 스레드. 대화 기록은 없지만 store 는 살아 있습니다.
    const day2 = await agent.invoke(
      { messages: [{ role: "user", content: "점심 메뉴 하나만 추천해줘." }] },
      cfg("day-2"),
    );
    printKV({ "2일차 응답": String(day2.messages.at(-1)?.content).slice(0, 200) });

    printJson(
      "store 에 쌓인 기억",
      (await store.search(["user_1", "memories"])).map((i) => i.value["content"]),
    );
  } else {
    printKV({ 건너뜀: "ANTHROPIC_API_KEY 가 없어 개인 비서 실행을 건너뜁니다" });
  }
}

printSection("끝");

/**
 * Step 15 — 장기 메모리와 Store · 연습문제
 * 실행: npx tsx docs/reference/langchain/step-15-long-term-memory/exercise.ts
 *
 * 각 [문제 N] 아래를 직접 채우세요.
 * 문제 1~6 은 API 키 없이 풀 수 있습니다. 문제 7~8 은 모델/임베딩 키가 있으면 실제로 돌려 볼 수 있습니다.
 */
import "dotenv/config";

import { createAgent, tool, type ToolRuntime, FakeToolCallingModel } from "langchain";
import { InMemoryStore, MemorySaver, type BaseStore } from "@langchain/langgraph";
import * as z from "zod";

import { printSection, printKV, printJson } from "../project/src/lib/print.js";

/* ===== [문제 1] BaseStore 기본 연산 =====
 *
 * InMemoryStore 를 만들고 네임스페이스 ["user_1", "memories"] 에
 * 아래 3건을 저장한 뒤, search 로 전체를 읽어 key 목록을 출력하세요.
 *
 *   - key "m1": { content: "커피는 디카페인만", kind: "semantic" }
 *   - key "m2": { content: "2026-07-01 환불 문의", kind: "episodic" }
 *   - key "m3": { content: "회신은 항상 존댓말로", kind: "procedural" }
 *
 * 그다음 filter 를 써서 kind 가 "semantic" 인 것만 골라 출력하세요.
 */

printSection("[문제 1] BaseStore 기본 연산");
{
  // 여기에 작성하세요
}

/* ===== [문제 2] upsert 확인 =====
 *
 * 문제 1 의 store 에서 key "m1" 에 다른 value 를 put 하세요.
 * 그 후 search 결과의 개수가 늘어나는지 확인하고,
 * get 으로 읽은 Item 의 createdAt 과 updatedAt 을 함께 출력하세요.
 *
 * 질문: 같은 key 로 다시 put 하면 행이 늘어납니까, 덮어써집니까?
 * → (여기에 답을 주석으로)
 */

printSection("[문제 2] upsert");
{
  // 여기에 작성하세요
}

/* ===== [문제 3] 네임스페이스 격리 =====
 *
 * user_1 과 user_2 각각의 ["<userId>", "memories"] 에 기억을 1건씩 저장하세요.
 * 그다음 아래 두 가지를 출력해 비교하세요.
 *
 *   (A) search(["user_1", "memories"])  → user_1 것만 나와야 합니다
 *   (B) search([])                      → 네임스페이스 prefix 를 비우면 무엇이 나옵니까?
 *
 * (B) 의 결과가 왜 위험한지 주석으로 설명하세요.
 * → (여기에 설명)
 */

printSection("[문제 3] 네임스페이스 격리");
{
  // 여기에 작성하세요
}

/* ===== [문제 4] 시맨틱 검색의 조용한 퇴화 =====
 *
 * index 설정이 "없는" InMemoryStore 에 기억 2건을 넣고
 * search(ns, { query: "아무 질문" }) 을 호출하세요.
 *
 * - 에러가 납니까?
 * - 결과 Item 의 score 필드는 무엇입니까?
 * - store.indexConfig 는 무엇입니까?
 *
 * 이 셋을 출력하고, "시맨틱 검색이 동작 중인지"를 코드로 판별하는
 * 방법을 한 줄로 적으세요.
 * → (여기에 답)
 */

printSection("[문제 4] 인덱스 없는 시맨틱 검색");
{
  // 여기에 작성하세요
}

/* ===== [문제 5] runtime.store 로 저장하는 도구 =====
 *
 * 아래 조건을 만족하는 도구 save_note 를 만들고,
 * FakeToolCallingModel 로 강제 호출시켜 store 에 실제로 남는지 확인하세요.
 *
 *   - schema: { note: string }
 *   - contextSchema 로 userId 를 받는다
 *   - 네임스페이스는 [userId, "notes"]
 *   - key 는 crypto.randomUUID()
 *
 * 힌트: runtime.store 의 TS 타입은 langgraph 의 BaseStore 가 아닙니다.
 *       put 을 쓰려면 캐스팅이 필요합니다.
 */

printSection("[문제 5] store 에 쓰는 도구");
{
  // 여기에 작성하세요
}

/* ===== [문제 6] 메모리 갱신 전략 =====
 *
 * 같은 사실을 여러 번 저장하면 store 가 중복으로 부풀어 오릅니다.
 * 다음을 만족하는 함수 saveDedup(store, userId, content) 를 작성하세요.
 *
 *   - [userId, "memories"] 에서 기존 항목을 search
 *   - content 가 완전히 같은 항목이 있으면 그 key 를 재사용해 덮어쓴다
 *   - 없으면 새 key(UUID)로 저장한다
 *   - 저장 후 항목 수를 반환한다
 *
 * 같은 content 로 3번 호출해 항목 수가 1로 유지되는지 확인하세요.
 */

printSection("[문제 6] 중복 방지 저장");
{
  // 여기에 작성하세요
}

/* ===== [문제 7] checkpointer 와 store 를 모두 붙인 에이전트 =====
 *
 * checkpointer(MemorySaver)와 store(InMemoryStore)를 모두 붙인 에이전트를 만들고
 * 서로 다른 thread_id 두 개로 호출하세요. FakeToolCallingModel 을 써도 됩니다.
 *
 * 다음 두 가지를 출력해 비교하세요.
 *   - 스레드 B 의 messages 길이 (스레드 A 의 대화가 보이는가?)
 *   - store 에 저장된 기억 (스레드를 넘어 남는가?)
 *
 * 질문: store 만 붙이고 checkpointer 를 빼면 무엇이 깨집니까?
 * → (여기에 답)
 */

printSection("[문제 7] checkpointer + store");
{
  // 여기에 작성하세요
}

/* ===== [문제 8] 메모리를 읽는 개인 비서 =====
 *
 * save_memory / search_memory 두 도구를 가진 에이전트를 만들고,
 * 서로 다른 스레드에서 (1) 선호를 알려주고 (2) 추천을 받아 보세요.
 *
 *   - systemPrompt 에 "기억에 없는 것을 지어내지 마라"를 반드시 넣을 것
 *   - 네임스페이스에 userId 를 넣을 것
 *   - ANTHROPIC_API_KEY 가 없으면 건너뛰도록 가드할 것
 *
 * 실행 후, 2일차 응답이 1일차에 저장한 선호를 반영했는지 확인하세요.
 */

printSection("[문제 8] 개인 비서");
{
  // 여기에 작성하세요
}

printSection("끝");

/**
 * Step 15 — 장기 메모리와 Store · 정답과 해설
 * 실행: npx tsx docs/reference/langchain/step-15-long-term-memory/solution.ts
 *
 * exercise.ts 를 스스로 풀어본 뒤에 열어보세요.
 */
import "dotenv/config";

import { createAgent, tool, type ToolRuntime, FakeToolCallingModel } from "langchain";
import { InMemoryStore, MemorySaver, type BaseStore } from "@langchain/langgraph";
import * as z from "zod";

import { printSection, printKV, printJson } from "../project/src/lib/print.js";

const hasAnthropic = process.env["ANTHROPIC_API_KEY"] !== undefined;

/* ===== [정답 1] BaseStore 기본 연산 ===== */

printSection("[정답 1] BaseStore 기본 연산");

const store1 = new InMemoryStore();
{
  const ns = ["user_1", "memories"];

  await store1.put(ns, "m1", { content: "커피는 디카페인만", kind: "semantic" });
  await store1.put(ns, "m2", { content: "2026-07-01 환불 문의", kind: "episodic" });
  await store1.put(ns, "m3", { content: "회신은 항상 존댓말로", kind: "procedural" });

  const all = await store1.search(ns);
  printKV({ "전체 key": all.map((i) => i.key).join(", ") });

  // filter 는 value 안의 필드를 매칭합니다. namespace/key 가 아니라 "값"이 대상입니다.
  const semantic = await store1.search(ns, { filter: { kind: "semantic" } });
  printKV({ "kind=semantic": semantic.map((i) => i.value["content"]).join(", ") });

  // 해설: put/get/search/delete 는 모두 async 입니다. await 를 빠뜨리면
  // 아직 쓰이지 않은 상태에서 search 가 돌아 "방금 저장한 게 없다"는 현상이 납니다.
  // 조용히 틀리는 대표적인 경로라 저장 직후 읽는 코드는 특히 조심하세요.
}

/* ===== [정답 2] upsert ===== */

printSection("[정답 2] upsert");

{
  const ns = ["user_1", "memories"];
  const beforeItem = await store1.get(ns, "m1");

  // 주의: get 이 돌려준 Item 은 store 내부 객체의 "참조"입니다(InMemoryStore 한정).
  // 나중 비교를 위해 값을 붙들어 두려면 반드시 복사해야 합니다.
  const beforeSnapshot = structuredClone(beforeItem!.value);

  // 같은 key 로 다시 put → 새 행이 생기지 않고 덮어써집니다(upsert).
  await new Promise((r) => setTimeout(r, 5)); // updatedAt 차이를 눈으로 보려고 잠깐 대기
  await store1.put(ns, "m1", { content: "커피는 아예 안 마심", kind: "semantic" });

  const after = await store1.get(ns, "m1");
  printKV({
    "search 개수": (await store1.search(ns)).length, // 여전히 3 — 늘지 않습니다
    "이전 값(복사해 둔 것)": JSON.stringify(beforeSnapshot),
    "이전 값(참조를 그대로 들고 있던 것)": JSON.stringify(beforeItem?.value), // 새 값으로 바뀌어 있습니다
    "이후 값": JSON.stringify(after?.value),
    createdAt: String(after?.createdAt.toISOString()),
    updatedAt: String(after?.updatedAt.toISOString()),
  });

  // 답: 덮어써집니다. (namespace, key) 쌍이 곧 기본키입니다.
  //
  // 해설 1 — upsert:
  // 이 성질이 메모리 갱신 전략의 토대입니다. "사실이 바뀌었다"면 새 key 로
  // 쌓지 말고 같은 key 를 덮어써야 합니다. 그렇지 않으면 "커피는 디카페인만"과
  // "커피는 아예 안 마심"이 동시에 검색되어 모델이 모순된 사실을 보게 됩니다.
  // key 를 매번 crypto.randomUUID() 로 만드는 코드가 흔한데, 그건 "사건 기록"
  // (일화기억)에나 맞고 "현재 상태"(의미기억)에는 맞지 않습니다.
  //
  // 해설 2 — 참조 함정(위 출력의 두 번째/세 번째 줄):
  // InMemoryStore 의 get/search 는 내부 객체를 "복사 없이" 돌려줍니다.
  // 그래서 (1) 먼저 읽어 둔 Item 이 나중 put 때문에 소급해서 바뀌고,
  //        (2) item.value 를 직접 수정하면 put 을 부르지 않았는데도 store 가 오염됩니다.
  // 둘 다 에러가 나지 않습니다. 게다가 PostgresStore 는 값을 직렬화하므로
  // 이 동작이 "다릅니다" — InMemoryStore 에서 우연히 동작하던 코드가
  // DB 로 바꾸는 순간 조용히 깨집니다. 읽은 값을 수정할 거면 항상 복사하고,
  // 쓰기는 반드시 put 으로만 하세요.
}

/* ===== [정답 3] 네임스페이스 격리 ===== */

printSection("[정답 3] 네임스페이스 격리");

{
  const store = new InMemoryStore();
  await store.put(["user_1", "memories"], "a", { content: "user_1 의 비밀" });
  await store.put(["user_2", "memories"], "b", { content: "user_2 의 비밀" });

  const onlyUser1 = await store.search(["user_1", "memories"]);
  const everything = await store.search([]); // prefix 를 비우면 = 전부

  printKV({
    "(A) user_1 네임스페이스": onlyUser1.map((i) => i.value["content"]).join(", "),
    "(B) prefix 없이 search([])": everything.map((i) => `${i.namespace.join("/")}:${i.value["content"]}`).join(" | "),
  });

  // 답: search([]) 는 모든 사용자의 기억을 한꺼번에 돌려줍니다.
  //
  // 해설: 이게 이 스텝에서 가장 위험한 대목입니다. namespacePrefix 는 "필터"가
  // 아니라 "경로"이고, 빈 배열은 루트 = 전체입니다. 도구 안에서 네임스페이스를
  // [userId, "memories"] 가 아니라 ["memories"] 로 짜 두면, 에러 없이 잘 도는
  // 것처럼 보이면서 A 사용자의 기억이 B 사용자 답변에 섞여 나옵니다.
  // 테스트에서는 사용자가 한 명이라 절대 안 잡히고, 프로덕션에서 터집니다.
  // userId 는 반드시 네임스페이스의 "앞쪽"에 두세요. value 안에 userId 를 넣고
  // filter 로 거르는 방식은 필터를 빠뜨리는 순간 그대로 유출이 됩니다.
}

/* ===== [정답 4] 인덱스 없는 시맨틱 검색 ===== */

printSection("[정답 4] 인덱스 없는 시맨틱 검색");

{
  const store = new InMemoryStore(); // index 설정 없음
  const ns = ["u", "m"];
  await store.put(ns, "a", { text: "피자를 좋아함" });
  await store.put(ns, "b", { text: "주말엔 등산을 함" });

  const hits = await store.search(ns, { query: "이 사용자는 뭘 먹나요?" });

  printKV({
    "에러가 났는가": "아니오 — 정상 반환됩니다",
    "결과 score": hits.map((i) => `${i.key}=${i.score}`).join(", "), // 전부 undefined
    "store.indexConfig": String(store.indexConfig), // undefined
  });

  // 답: 시맨틱 검색이 동작 중인지는 store.indexConfig 가 정의되어 있는지로 판별합니다.
  //     (결과 쪽에서는 item.score 가 undefined 인지로 확인할 수 있습니다.)
  //
  // 해설: query 를 줬는데 인덱스가 없으면 LangGraph 는 예외를 던지지 않고
  // "그냥 저장 순서대로의 목록"을 돌려줍니다. limit 도 그대로 먹기 때문에
  // 코드는 완벽히 정상으로 보입니다. 문제는 검색 품질만 조용히 나빠진다는 것입니다.
  // 기억이 5건일 때는 아무 차이가 없어서 개발 중엔 절대 안 보이고,
  // 500건이 되면 "왜 엉뚱한 기억을 물어오지?"가 됩니다.
  // 부팅 시 store.indexConfig 를 한 번 assert 하는 게 값싼 방어입니다.
}

/* ===== [정답 5] store 에 쓰는 도구 ===== */

printSection("[정답 5] store 에 쓰는 도구");

{
  const store = new InMemoryStore();

  const saveNote = tool(
    async ({ note }, runtime: ToolRuntime<any, { userId: string }>) => {
      // 핵심: runtime.store 의 TS 타입은 @langchain/core 의 BaseStore<string, unknown> 입니다.
      // put/search 가 없는 다른 인터페이스라 그대로 쓰면 컴파일이 안 됩니다.
      // 런타임에 실제로 들어오는 객체는 langgraph 의 BaseStore 이므로 캐스팅합니다.
      const s = runtime.store as unknown as BaseStore;
      await s.put([runtime.context.userId, "notes"], crypto.randomUUID(), { note });
      return `메모했습니다: ${note}`;
    },
    {
      name: "save_note",
      description: "사용자의 메모를 저장합니다.",
      schema: z.object({ note: z.string() }),
    },
  );

  const agent = createAgent({
    model: new FakeToolCallingModel({
      toolCalls: [[{ name: "save_note", args: { note: "금요일 회고 준비" }, id: "c1" }], []],
    }),
    tools: [saveNote],
    contextSchema: z.object({ userId: z.string() }),
    store,
  });

  await agent.invoke({ messages: [{ role: "user", content: "메모해줘" }] }, { context: { userId: "user_1" } });

  printJson(
    "store 에 남은 notes",
    (await store.search(["user_1", "notes"])).map((i) => i.value),
  );

  // 해설: 캐스팅이 필요하다는 사실 자체가 함정입니다. 공식 문서 예제는
  // runtime.store.put(...) 을 바로 부르지만, 현재 배포된 타입 정의에서는
  // tsc 가 "Property 'put' does not exist" 를 냅니다.
  // as unknown as BaseStore 로 한 번 좁혀 놓고 쓰는 게 가장 깔끔합니다.
  // 참고로 runtime.store 는 우리가 넘긴 InMemoryStore 그 객체가 아니라
  // AsyncBatchedStore 래퍼입니다 → instanceof InMemoryStore 는 false 입니다.
  // "store 가 제대로 붙었나"를 instanceof 로 검사하면 멀쩡한데도 실패합니다.
}

/* ===== [정답 6] 중복 방지 저장 ===== */

printSection("[정답 6] 중복 방지 저장");

{
  const store = new InMemoryStore();

  async function saveDedup(s: BaseStore, userId: string, content: string): Promise<number> {
    const ns = [userId, "memories"];
    const existing = await s.search(ns);
    const dup = existing.find((i) => i.value["content"] === content);
    const key = dup?.key ?? crypto.randomUUID(); // 있으면 그 key 재사용 → upsert
    await s.put(ns, key, { content, updatedAt: new Date().toISOString() });
    return (await s.search(ns)).length;
  }

  const n1 = await saveDedup(store, "user_1", "매운 음식을 못 먹는다");
  const n2 = await saveDedup(store, "user_1", "매운 음식을 못 먹는다");
  const n3 = await saveDedup(store, "user_1", "매운 음식을 못 먹는다");

  printKV({ "1회 후": n1, "2회 후": n2, "3회 후": n3 }); // 1, 1, 1

  // 해설: 여기서는 문자열 완전일치로 중복을 잡았지만 실전에서는
  // "매운 거 못 먹음"과 "맵찔이임"처럼 표현만 다른 같은 사실이 들어옵니다.
  // 완전일치 dedup 은 이걸 못 잡습니다. 실무에서는
  //   (1) 사실 종류를 key 로 고정하거나 (예: key="food_preference")
  //   (2) 시맨틱 검색으로 유사한 기억을 먼저 찾아 모델에게 "갱신할지 새로 만들지" 결정시키거나
  //   (3) 주기적으로 요약·병합하는 배치를 돌립니다.
  // 무한정 append 하는 store 는 반드시 검색 품질이 무너집니다.
}

/* ===== [정답 7] checkpointer + store ===== */

printSection("[정답 7] checkpointer + store");

{
  const checkpointer = new MemorySaver();
  const store = new InMemoryStore();

  const remember = tool(
    async ({ fact }, runtime: ToolRuntime<any, { userId: string }>) => {
      const s = runtime.store as unknown as BaseStore;
      await s.put([runtime.context.userId, "memories"], crypto.randomUUID(), { fact });
      return `기억했습니다: ${fact}`;
    },
    { name: "remember", description: "사실을 저장합니다.", schema: z.object({ fact: z.string() }) },
  );

  const mk = (toolCalls: Array<Array<{ name: string; args: object; id: string }>>) =>
    createAgent({
      model: new FakeToolCallingModel({ toolCalls }),
      tools: [remember],
      contextSchema: z.object({ userId: z.string() }),
      checkpointer,
      store,
    });

  await mk([[{ name: "remember", args: { fact: "닉네임은 민수" }, id: "c1" }], []]).invoke(
    { messages: [{ role: "user", content: "내 닉네임은 민수야" }] },
    { configurable: { thread_id: "A" }, context: { userId: "user_1" } },
  );

  const b = await mk([[]]).invoke(
    { messages: [{ role: "user", content: "안녕" }] },
    { configurable: { thread_id: "B" }, context: { userId: "user_1" } },
  );

  printKV({
    "스레드 B 의 messages 길이": b.messages.length, // 2 — A 의 대화는 안 보입니다
    "store 의 기억": (await store.search(["user_1", "memories"])).map((i) => i.value["fact"]).join(", "),
  });

  // 답: store 만 붙이고 checkpointer 를 빼면 "같은 스레드 안의 대화 이어가기"가 깨집니다.
  //     사용자가 방금 한 말을 다음 턴에 기억하지 못하고, HITL(중단/재개)도 동작하지 않습니다.
  //     반대로 checkpointer 만 붙이면 스레드가 바뀌는 순간 사용자에 대해 아무것도 모르게 됩니다.
  //
  // 해설: 둘은 대체재가 아니라 보완재입니다. 헷갈리면 이렇게 기억하세요.
  //   checkpointer = "이 대화에서 무슨 말이 오갔나"  (스레드 안, 자동)
  //   store        = "이 사용자는 어떤 사람인가"      (스레드 밖, 직접 저장)
  //   thread_id 만 주고 checkpointer 를 안 붙이면 아무것도 안 남습니다(Step 10).
}

/* ===== [정답 8] 개인 비서 ===== */

printSection("[정답 8] 개인 비서");

{
  const ContextSchema = z.object({ userId: z.string() });
  type Ctx = z.infer<typeof ContextSchema>;

  const store = new InMemoryStore();
  const checkpointer = new MemorySaver();

  const saveMemory = tool(
    async ({ content }, runtime: ToolRuntime<any, Ctx>) => {
      const s = runtime.store as unknown as BaseStore;
      const ns = [runtime.context.userId, "memories"]; // userId 를 반드시 앞에
      const existing = await s.search(ns);
      const dup = existing.find((i) => i.value["content"] === content);
      await s.put(ns, dup?.key ?? crypto.randomUUID(), { content, updatedAt: new Date().toISOString() }, [
        "content",
      ]);
      return `기억했습니다: ${content}`;
    },
    {
      name: "save_memory",
      description:
        "사용자의 선호·사실 중 다음 대화에서도 쓸모 있는 것을 저장합니다. 사용자가 명시적으로 말한 것만 저장하세요.",
      schema: z.object({ content: z.string().describe("한 문장으로 요약한 사실") }),
    },
  );

  const searchMemory = tool(
    async ({ query }, runtime: ToolRuntime<any, Ctx>) => {
      const s = runtime.store as unknown as BaseStore;
      const items = await s.search([runtime.context.userId, "memories"], { query, limit: 5 });
      return items.length === 0 ? "저장된 기억이 없습니다." : items.map((i) => `- ${i.value["content"]}`).join("\n");
    },
    {
      name: "search_memory",
      description: "사용자에 대해 저장해 둔 사실을 검색합니다. 사용자 취향이 관련된 답을 하기 전에 먼저 호출하세요.",
      schema: z.object({ query: z.string() }),
    },
  );

  if (hasAnthropic) {
    const agent = createAgent({
      model: "anthropic:claude-sonnet-4-6",
      // OpenAI 대안: model: "openai:gpt-5.5"
      tools: [saveMemory, searchMemory],
      systemPrompt: [
        "너는 개인 비서다.",
        "사용자가 자기 선호나 사실을 말하면 save_memory 로 저장해라.",
        "사용자 취향이 관련된 질문에는 먼저 search_memory 로 확인한 뒤 답해라.",
        "기억에 없는 것을 지어내지 마라. 모르면 모른다고 말해라.",
      ].join(" "),
      contextSchema: ContextSchema,
      checkpointer,
      store,
    });

    const cfg = (thread: string) => ({
      configurable: { thread_id: thread },
      context: { userId: "user_1" },
    });

    const day1 = await agent.invoke(
      { messages: [{ role: "user", content: "나는 매운 음식을 못 먹고, 채식을 지향해." }] },
      cfg("day-1"),
    );
    printKV({ "1일차": String(day1.messages.at(-1)?.content).slice(0, 150) });

    const day2 = await agent.invoke(
      { messages: [{ role: "user", content: "점심 메뉴 하나만 추천해줘." }] },
      cfg("day-2"), // 새 스레드 — 대화 기록은 없지만 store 는 살아 있음
    );
    printKV({ "2일차": String(day2.messages.at(-1)?.content).slice(0, 250) });

    printJson(
      "store 의 기억",
      (await store.search(["user_1", "memories"])).map((i) => i.value["content"]),
    );

    // 해설: 2일차 응답에 "맵지 않은 채식 메뉴"가 나오면 성공입니다.
    // 이때 검증해야 할 것은 "그럴듯한 답"이 아니라 "search_memory 를 실제로 불렀는가"입니다.
    // 모델이 도구를 안 부르고 일반 상식으로 답해도 그럴듯해 보이기 때문입니다.
    // day2.messages 에서 tool 메시지를 찾아 확인하세요.
    const calledSearch = day2.messages.some((m) => m.getType() === "tool" && String(m.name) === "search_memory");
    printKV({ "search_memory 를 실제로 호출했는가": calledSearch ? "예" : "아니오(프롬프트를 더 강하게)" });
  } else {
    printKV({ 건너뜀: "ANTHROPIC_API_KEY 가 없어 실행을 건너뜁니다" });
  }
}

printSection("끝");