Claude API のチャット履歴を階層サマライズする：3 段階圧縮でトークンを 70 % 削減した設計

// src/history/tier1.ts
import type { Message } from "@anthropic-ai/sdk/resources/messages";
 
export interface Tier1Result {
  recent: Message[];
  overflow: Message[];
  tokenEstimate: number;
}
 
const TIER1_TOKEN_BUDGET = 3_000;
const TIER1_MIN_TURNS = 4;
 
// 日本語混在環境では 1 トークン ≒ 0.6 文字で見積もる
function estimateTokens(message: Message): number {
  const content = typeof message.content === "string"
    ? message.content
    : message.content.map((c) => "text" in c ? c.text : "").join("");
  return Math.ceil(content.length / 0.6);
}
 
export function partitionTier1(history: Message[]): Tier1Result {
  const recent: Message[] = [];
  let used = 0;
 
  for (let i = history.length - 1; i >= 0; i--) {
    const cost = estimateTokens(history[i]);
    if (used + cost > TIER1_TOKEN_BUDGET && recent.length >= TIER1_MIN_TURNS) {
      return {
        recent: recent.reverse(),
        overflow: history.slice(0, i + 1),
        tokenEstimate: used,
      };
    }
    recent.push(history[i]);
    used += cost;
  }
 
  return { recent: recent.reverse(), overflow: [], tokenEstimate: used };
}

// src/history/tier2.ts
import Anthropic from "@anthropic-ai/sdk";
import type { Message } from "@anthropic-ai/sdk/resources/messages";
 
const anthropic = new Anthropic();
 
const SUMMARIZE_SYSTEM = `You compress a chunk of a chat conversation.
Output a single paragraph in the user's language, ~200 tokens, written in the third person.
Preserve: explicit preferences, rejected ideas, decisions, in-progress requests.
Drop: greetings, filler, repeated acknowledgements.
Never invent facts; if uncertain, omit.`;
 
export interface EpisodeSummary {
  range: [number, number];   // 元 history のインデックス範囲
  summary: string;
  createdAt: number;
}
 
export async function summarizeEpisode(
  episode: Message[],
  baseIndex: number,
): Promise<EpisodeSummary> {
  const transcript = episode
    .map((m, i) => `[${m.role}] ${flattenContent(m)}`)
    .join("\n");
 
  const res = await anthropic.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 320,
    system: SUMMARIZE_SYSTEM,
    messages: [{ role: "user", content: transcript }],
  });
 
  const text = res.content
    .filter((c): c is { type: "text"; text: string } => c.type === "text")
    .map((c) => c.text).join("\n").trim();
 
  return {
    range: [baseIndex, baseIndex + episode.length - 1],
    summary: text,
    createdAt: Date.now(),
  };
}
 
function flattenContent(m: Message): string {
  if (typeof m.content === "string") return m.content;
  return m.content
    .map((c) => "text" in c ? c.text : "[non-text content]")
    .join(" ");
}

// src/history/tier3.ts
import Anthropic from "@anthropic-ai/sdk";
 
const anthropic = new Anthropic();
 
const memoryTool = {
  name: "record_long_term_memory",
  description: "Record the user's stable preferences, rejected ideas, and ongoing intents.",
  input_schema: {
    type: "object",
    properties: {
      preferences: {
        type: "array",
        items: { type: "string" },
        description: "Stable preferences (color palette, mood, motif, style).",
      },
      rejected: {
        type: "array",
        items: { type: "string" },
        description: "Ideas the user has explicitly turned down.",
      },
      ongoing_intent: {
        type: "string",
        description: "The user's current goal in 1-2 sentences.",
      },
      anchors: {
        type: "array",
        items: { type: "string" },
        description: "Named entities worth remembering (artist, location, technique).",
      },
    },
    required: ["preferences", "rejected", "ongoing_intent", "anchors"],
  },
} as const;
 
export interface LongTermMemory {
  preferences: string[];
  rejected: string[];
  ongoing_intent: string;
  anchors: string[];
  updatedAt: number;
}
 
export async function distillLongTermMemory(
  episodeSummaries: string[],
  previous: LongTermMemory | null,
): Promise<LongTermMemory> {
  const prior = previous ? `Previous memory snapshot:\n${JSON.stringify(previous, null, 2)}\n\n` : "";
  const merged = episodeSummaries.map((s, i) => `Episode ${i + 1}:\n${s}`).join("\n\n");
 
  const res = await anthropic.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 800,
    tools: [memoryTool],
    tool_choice: { type: "tool", name: "record_long_term_memory" },
    messages: [{
      role: "user",
      content: `${prior}New episode summaries:\n${merged}\n\nMerge prior memory with the new evidence. Drop superseded preferences. Keep the JSON small.`,
    }],
  });
 
  const toolUse = res.content.find((c) => c.type === "tool_use");
  if (!toolUse || toolUse.type !== "tool_use") {
    throw new Error("Tier3: tool_use not returned");
  }
 
  const input = toolUse.input as Omit<LongTermMemory, "updatedAt">;
  return { ...input, updatedAt: Date.now() };
}

// src/history/orchestrator.ts
import { partitionTier1 } from "./tier1";
import type { LongTermMemory, EpisodeSummary } from "./types";
 
export interface ChatState {
  history: Message[];
  episodes: EpisodeSummary[];
  longTermMemory: LongTermMemory | null;
}
 
const EPISODE_SIZE = 6;
const DISTILL_TRIGGER = 3;
 
export async function buildPromptMessages(state: ChatState): Promise<Message[]> {
  const { recent } = partitionTier1(state.history);
 
  const memorySystem = state.longTermMemory
    ? formatMemorySystemBlock(state.longTermMemory)
    : "";
  const episodicContext = state.episodes
    .map((e, i) => `<episode index="${i}">${e.summary}</episode>`)
    .join("\n");
 
  return [
    { role: "user", content: `${memorySystem}\n${episodicContext}` },
    ...recent,
  ];
}
 
export function shouldCompressTier2(state: ChatState): boolean {
  const { overflow } = partitionTier1(state.history);
  const summarized = state.episodes.length * EPISODE_SIZE;
  return overflow.length - summarized >= EPISODE_SIZE;
}
 
export function shouldCompressTier3(state: ChatState): boolean {
  const unsummarizedEpisodes = state.episodes.length
    - (state.longTermMemory ? Math.floor(state.episodes.length / DISTILL_TRIGGER) * DISTILL_TRIGGER : 0);
  return unsummarizedEpisodes >= DISTILL_TRIGGER;
}

// src/history/recall-probe.ts
import Anthropic from "@anthropic-ai/sdk";
import { buildPromptMessages } from "./orchestrator";
import type { ChatState } from "./orchestrator";
 
export interface Probe {
  /** その事実が述べられたターン（生履歴の添字） */
  statedAtTurn: number;
  question: string;
  /** 正解ならこのいずれかを必ず含む */
  mustInclude: string[];
}
 
export interface ProbeResult extends Probe {
  answer: string;
  passed: boolean;
  judgedBy: "literal" | "model";
}
 
const anthropic = new Anthropic();
const UNKNOWN = "UNKNOWN";
 
export async function runProbe(state: ChatState, probe: Probe): Promise<ProbeResult> {
  // 本番と同じ経路で圧縮後の messages を組み立てる（ここを別実装にすると測定が無意味になる）
  const compressed = await buildPromptMessages(state);
 
  const res = await anthropic.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 200,
    system: `Answer only from the conversation context provided. If it is not there, reply exactly: ${UNKNOWN}`,
    messages: [...compressed, { role: "user", content: probe.question }],
  });
 
  const answer = res.content.map((b) => ("text" in b ? b.text : "")).join("").trim();
 
  const literal = probe.mustInclude.some(
    (w) => answer.toLowerCase().includes(w.toLowerCase()),
  );
  if (literal || answer === UNKNOWN) {
    return { ...probe, answer, passed: literal, judgedBy: "literal" };
  }
  return { ...probe, answer, passed: await judgeByModel(probe, answer), judgedBy: "model" };
}
 
async function judgeByModel(probe: Probe, answer: string): Promise<boolean> {
  const res = await anthropic.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 8,
    system: "Reply with exactly YES or NO.",
    messages: [{
      role: "user",
      content: `Does the answer below convey any of ${JSON.stringify(probe.mustInclude)}?\n\nAnswer: ${answer}`,
    }],
  });
  return res.content.some(
    (b) => "text" in b && b.text.trim().toUpperCase().startsWith("YES"),
  );
}

const EPISODE_SIZE = 6;
const EPISODE_OVERLAP = 1;
 
export function sliceEpisodes(overflow: Message[], alreadySummarized: number): Message[][] {
  const episodes: Message[][] = [];
  let start = alreadySummarized;
 
  while (overflow.length - start >= EPISODE_SIZE) {
    // 直前エピソードの末尾 1 ターンを持ち越して、発言と応答が割れないようにする
    const from = Math.max(0, start - EPISODE_OVERLAP);
    episodes.push(overflow.slice(from, start + EPISODE_SIZE));
    start += EPISODE_SIZE;
  }
  return episodes;
}

const cachedSystem = [
  {
    type: "text",
    text: formatMemorySystemBlock(state.longTermMemory),
    cache_control: { type: "ephemeral" },
  },
];
 
await anthropic.messages.create({
  model: "claude-sonnet-4-6",
  system: cachedSystem,
  messages: [...episodicAsUser, ...recent],
  max_tokens: 1_024,
});