AI 챗봇 고도화의 여정 — 93%에서 100%까지, 그리고 그 너머

// i18n.js — 핵심 번역 함수
function t(key, replacements) {
  const lang = getLanguage(); // localStorage || 'en'
  let str = TRANSLATIONS[lang][key] || TRANSLATIONS['en'][key] || key;
  if (replacements) {
    Object.keys(replacements).forEach(k => {
      str = str.replace(new RegExp('\\{' + k + '\\}', 'g'), replacements[k]);
    });
  }
  return str;
}
 
// HTML에서는 이렇게
// <p data-i18n="page.tagline">Always learning, Always building</p>
// → 한국어 모드: "늘 배우고, 늘 만든다"

// 이 45분의 해킹 시도가 만든 보안 패턴들
const JAILBREAK_PATTERNS = [
  /(이전\s*(지시|명령|프롬프트|규칙|지침).*무시)/i,        // "이전 지시 무시"
  /(개발자\s*모드|관리자\s*모드|테스트\s*모드)/i,           // "개발자 모드"
  /(너는?\s*이제\s*(시스템|관리자|개발자|AI|다른))/i,       // "너는 이제 관리자야"
  /(가정해|가정하고|포함돼\s*있다고)/i,                     // 간접 injection
  /(답변:\s*.+)/i,                                         // few-shot injection
  /(판단\s*과정|내부\s*(로직|구조|동작))/i,                 // 시스템 내부 추출
  /(보안\s*(규칙|구조).*알려)/i,                            // 보안 정보 낚시
  // ...
];

const INAPPROPRIATE_PATTERNS = [
  /(똥꼬|씹|좆|자지|보지|꼬추|병신|지랄|새끼|미친년|미친놈|
    느금마|니애미|시발|ㅅㅂ|ㅂㅅ|ㅈㄹ)/i,
];

// Hangul Unicode constants
const HANGUL_BASE = 0xAC00;   // '가' — first precomposed syllable
const HANGUL_END  = 0xD7A3;   // '힣' — last  precomposed syllable
 
// 각 음절을 Jamo (자모)로 분해
// 예: '기' = cho(초성ㄱ) + jung(중성ㅣ) + jong(종성=0)
function decomposeHangul(codepoint) {
  const offset = codepoint - HANGUL_BASE;
  const jong   = offset % 28;        // 받침 (0-27, 0=없음)
  const jung   = Math.floor(offset / 28) % 21;
  const cho    = Math.floor(offset / (28 * 21));
  return { cho, jung, jong };
}

const PARTICLES = [
  ['에게서', null],
  ['으로부터', null],
  ['에서', null],
  ['은', true],   // true = 받침 있을 때만 (예: 책은, 방은)
  ['는', false],  // false = 받침 없을 때만 (예: 나는, 영화는)
  ['이', true],   // 받침 있을 때 (예: 책이)
  ['가', false],  // 받침 없을 때 (예: 나가)
  ['을', true],   // 받침 있을 때 (예: 책을)
  ['를', false],  // 받침 없을 때 (예: 나를)
  // ... 30+ 조사
];

function hasTrailingConsonant(word) {
  if (!word) return false;
  const codepoint = word.codePointAt(word.length - 1);
  if (!isHangulSyllable(codepoint)) return false;
  return decomposeHangul(codepoint).jong !== 0;
}
 
// 사용 예
hasTrailingConsonant("책");    // true  (책ㄱ = jong !== 0)
hasTrailingConsonant("나");    // false (나 = jong === 0)

// 했습니다 → 하, 해요 → 하, 했어요 → 하
const VERB_ENDINGS = [
  ['었습니다', ''],  // 과거 정중형
  ['었어요', ''],    // 과거 존댓말
  ['습니다', ''],    // 현재 정중형
  ['어요', ''],      // 현재 존댓말
  ['아요', ''],      // 현재 존댓말 (다른 초성)
  // ...
];

// 중요한 원칙: 결과가 2글자 이하면 반환하지 않음
if (result.length < 2) return originalWord;
 
// 영어는 그냥 소문자로
if (/^[a-zA-Z]+$/.test(word)) return word.toLowerCase();

// 옛날 방식 (비효율)
async function init() {
  const embeddings = [];
  for (const chunk of CHUNKS) {
    const emb = await hf.embed(chunk.content);
    embeddings.push(emb);
  }
  return embeddings;
}

// 새로운 방식 (효율적)
async function init() {
  // 아무것도 로드하지 않음. 그냥 HF API가 살아있는지만 probe
  await hf.embed(['query: test']);  // 모델만 warm-up
  console.log('Ready for on-demand query encoding');
}
 
// 쿼리가 들어올 때만 encoding
async function retrieve(query) {
  const queryEmb = await hf.embed([query]);
 
  // Supabase RPC 호출 (pgvector 쿼리)
  const results = await supabase.rpc('match_chunks', {
    query_embedding: queryEmb[0],
    similarity_threshold: 0.5,
    match_count: 8
  });
 
  return results;
}

-- 한 번만 실행
CREATE EXTENSION IF NOT EXISTS vector;
 
CREATE TABLE IF NOT EXISTS knowledge_chunks (
  id TEXT PRIMARY KEY,
  content TEXT NOT NULL,
  keywords TEXT[], -- ARRAY 타입
  embedding vector(1024) NOT NULL, -- 1024-dim e5-large
  created_at TIMESTAMP DEFAULT NOW()
);
 
CREATE INDEX ON knowledge_chunks USING ivfflat (embedding vector_cosine_ops);
 
-- Python 스크립트로 batch embedding 후 삽입
-- 그 후 RPC 함수 정의
CREATE OR REPLACE FUNCTION match_chunks(
  query_embedding VECTOR(1024),
  similarity_threshold FLOAT DEFAULT 0.5,
  match_count INT DEFAULT 8
) RETURNS TABLE(id TEXT, content TEXT, similarity FLOAT) AS $$
BEGIN
  RETURN QUERY
  SELECT
    knowledge_chunks.id,
    knowledge_chunks.content,
    (1 - (knowledge_chunks.embedding <=> query_embedding)) as similarity
  FROM knowledge_chunks
  WHERE (1 - (knowledge_chunks.embedding <=> query_embedding)) > similarity_threshold
  ORDER BY knowledge_chunks.embedding <=> query_embedding
  LIMIT match_count;
END;
$$ LANGUAGE PLPGSQL;

const weights = {
  neural: 0.4,    // 낮춤 (semantic은 중요하지만, 한국어 단어 token이 부족해서 과신 X)
  tfidf: 0.2,     // 유지
  keyword: 0.4    // 올림 (한국어에서 정확한 키워드 매칭이 핵심)
};
 
// Fallback (neural 다운)
const fallbackWeights = {
  tfidf: 0.4,
  keyword: 0.6
};

const SYNONYMS = {
  '요즘': ['현재', '지금', 'daval'],
  '좌우명': ['모토', 'motto', '인생관', '신조'],
  '기술스택': ['스택', 'tech stack', 'skills'],
  'iealtype': ['타입', 'type', '이상형'],
  // ...
};
 
// 쿼리 전처리
function expandQuery(query) {
  let expanded = query;
  for (const [original, synonyms] of Object.entries(SYNONYMS)) {
    if (query.includes(original)) {
      expanded += ' ' + synonyms.join(' ');
    }
  }
  return expanded;
}

// 원래: score < 0.30 * topScore 는 버림 (너무 aggressive)
// 새로운: score < 0.20 * topScore 는 버림 (덜 aggressive)
const threshold = 0.20;
const topScore = results[0].score;
const filtered = results.filter(r => r.score >= topScore * threshold);

// 마지막 4 턴의 대화를 쿼리에 추가
function enrichQuery(currentQuery, conversationHistory) {
  const recentContext = conversationHistory
    .slice(-4)  // 최근 4 턴
    .map(turn => turn.content)
    .join(' ');
 
  return `${currentQuery} [CONTEXT: ${recentContext}]`;
}

const EVAL_SET = [
  // Identity (6개)
  { q: '데이먼이 누구야?', expected: ['about', 'personality'] },
  { q: '생일은 언제야?', expected: ['about'] },
 
  // Career (5개)
  { q: 'DaVal에서 어떤 일을 하나요?', expected: ['daval', 'career'] },
  { q: '요즘 근황 알려줘', expected: ['daval', 'daily_life'] },
 
  // Technical (4개)
  { q: '어떤 기술 스택을 쓰나요?', expected: ['skills'] },
 
  // Projects (2개)
  { q: '어떤 프로젝트들을 했는데?', expected: ['projects'] },
 
  // Personal (3개)
  { q: '취미가 뭔가요', expected: ['personal', 'favorites'] },
  { q: '이상형이 뭐야?', expected: ['love_type'] },
 
  // Contact (2개)
  { q: '연락처가 어떻게 되나요?', expected: ['contact', 'connect'] },
 
  // Philosophy (2개)
  { q: '데이먼의 철학은?', expected: ['philosophy', 'deep_thoughts'] },
 
  // Provocative (2개)
  { q: '데이먼 너무 성격이 안좋아', expected: ['personality_criticism'] },
 
  // Meta (2개)
  { q: 'ai 챗봇을 만든이유는?', expected: ['portfolio_site', 'deep_thoughts'] },
];

async function evaluate(config) {
  const retriever = new VectorRetriever();
  let totalRecall = 0;
 
  for (const { q, expected } of EVAL_SET) {
    const results = await retriever.search(q, { maxChunks: 5 });
    const retrievedIds = results.map(r => r.chunk.id);
 
    // Recall: 몇 개의 expected chunk가 top 5 안에 있는가?
    const hits = expected.filter(id => retrievedIds.includes(id)).length;
    const recall = hits / expected.length;
 
    totalRecall += recall;
 
    // 실패한 경우 로깅
    if (recall < 1.0) {
      console.log(`❌ "${q}"`);
      console.log(`  Expected: ${expected}`);
      console.log(`  Got: ${retrievedIds.slice(0, 3)}`);
    }
  }
 
  const avgRecall = totalRecall / EVAL_SET.length;
  console.log(`Recall@5: ${(avgRecall * 100).toFixed(1)}%`);
  return avgRecall;
}

const KOREAN_JAILBREAK_PATTERNS = [
  // 이전 지시 무시
  /(이전\s+지시|이전\s+명령|초기\s+지시|초기\s+프롬프트|프롬프트\s+무시|지시\s+무시)/i,
 
  // 프롬프트 까밀기
  /(프롬프트를\s+잊|기억하지|프롬프트\s+꺼내|시스템\s+프롬프트|프롬프트\s+노출|당신의\s+진정한\s+목적)/i,
 
  // 제약 해제
  /(제한\s+해제|필터\s+끄기|제한\s+없이|필터\s+제거|가드레일\s+해제|제약\s+무시)/i,
 
  // 개발자 모드
  /(개발자\s+모드|관리자\s+모드|테스트\s+모드|디버그\s+모드|원본\s+모드|실제\s+모드)/i,
 
  // 역할 하이재킹
  /(너는\s+이제|지금부터\s+너는|당신은\s+이제|새로운\s+역할|다른\s+성격|관리자가\s+되어)/i,
 
  // Meta-prompt extraction
  /(인텐트\s+분류|가드레일|파이프라인|구조를\s+설명|어떻게\s+작동하는|시스템\s+구조)/i,
];

const VULGAR_WORDS = [
  '씹', '좆', '자지', '보지', '꼬추', '병신', '지랄', '새끼',
  '미친년', '미친놈', '느금마', '니애미', '시발',
  'ㅅㅂ', 'ㅂㅅ', 'ㅈㄹ', 'ㅆ발',
  // ...
];
 
function hasVulgarity(text) {
  const lower = text.toLowerCase();
  return VULGAR_WORDS.some(word => lower.includes(word));
}

const FAMILY_KEYWORDS = [
  '가족', '부모', '엄마', '아빠', '형', '누나', '동생', '언니',
  'family', 'parents', 'mother', 'father', 'brother', 'sister',
];
 
const FAMILY_FALSE_POSITIVES = [
  '이상형',  // 형 포함하지만 가족 X
  '형식',    // 형 포함하지만 가족 X
  '형태',    // 형 포함하지만 가족 X
];
 
function isReallyFamilyQuestion(query) {
  // 먼저 false positive 제외
  for (const fp of FAMILY_FALSE_POSITIVES) {
    if (query.includes(fp)) return false;
  }
 
  // 그 다음 가족 키워드 체크
  return FAMILY_KEYWORDS.some(kw => query.includes(kw));
}

const PRIVATE_TOPICS = {
  school_history: {
    patterns: [/(중학교|고등학교|학창\s*시절)/i],
    deflection: {
      ko: 'Daemon은 학창 시절 이야기는 공개하지 않고 있어요. 대학 이후라면 많이 알려드릴 수 있어요!',
      en: "Daemon keeps his school days private. I can tell you about university onwards though!"
    }
  },
  role_model: {
    patterns: [/(롤모델|role\s*model|존경하는\s*사람|멘토)/i],
    deflection: {
      ko: 'Daemon의 롤모델은 비공개예요. 대신 그의 철학을 알려드릴까요?',
      en: "His role models are private. Want to hear about his philosophy instead?"
    }
  },
  money: {
    patterns: [/(연봉|월급|돈|salary|얼마\s*벌|net\s*worth)/i],
    deflection: {
      ko: '금전적인 부분은 비밀이에요! 대신 어떤 가치를 추구하며 일하는지 알려드릴까요?',
      en: "Money details are private! Want to hear about what drives his work?"
    }
  },
  romance: {
    patterns: [/(여자친구|썸녀|연애|연인|첫사랑|결혼|girlfriend|romance)/i],
    deflection: {
      ko: '궁금하면 직접 만나서 물어보세요! 대신 연락처를 알려드릴게요.',
      en: "Ask him directly! Here's how to reach him..."
    }
  },
};

// ❌ Old way
"Daemon은 Kotlin을 사용합니다."
 
// ✅ New way
"Daemon이 Katsby에서 일하면서 Kotlin에 빠지셨는데,
 지금은 모바일이고 백엔드고 전부 Kotlin 기반이에요.
 KMP로 Android, iOS, 서버까지 하나로 관리하시는데 —
 본인은 당연한 것처럼 말하지만, 이런 선택을 하는 개발자가 많지는 않거든요."

const progressiveDepth = {
  turn1: `짧고 friendly한 답변으로 시작. 핵심만.`,
 
  turn2_3: `why를 추가하세요. 선택 배경, 가치관의 일관성을 드러내세요.`,
 
  turn4_plus: `철학적 성찰까지 가능. "Daemon이 이렇게 생각하는 이유는..."
               라는 deeper narrative를 풀어내세요.`
};

// Example: recruiter가 들어온 경우
const visitorProfile = `
[VISITOR_PROFILE]
Type: recruiter (confidence: 92%)
Signals: "hiring", "channel", "position"
 
답변 스타일: Impact와 professionalism 중심.
DaVal co-founder 역할, 526 sign-ups, 770K page views 같은
구체적인 성과를 먼저 언급.
`;

// Romance: 재치있게 deflect
Q: "여자친구 있어?"
A: "궁금하면 직접 만나서 물어보세요!
    대신 연락처는 알려드릴 수 있어요."
 
// Ideal Type: 답변 가능 (실제로 공개 정보)
Q: "이상형이 뭐야?"
A: "Daemon은 '자기 삶을 사랑하고, 예술을 이해하며,
    깊이가 있는 사람'을 좋아해요.
    외모로는 '쌍꺼풀, 예쁘고, 사랑이 가득한' 타입이라고 하더라고요."
 
// Family: Hard block (재치 없음, 딱 거절)
Q: "엄마는 뭐하시나요?"
A: "Daemon은 가족 이야기는 공개하지 않고 있어요.
    다른 거라면 뭐든 물어봐 주세요!"

const TOPIC_GRAPH = {
  about:    ['personality', 'origin_story', 'philosophy', ...],
  daval:    ['career', 'leadership', 'achievements', ...],
  projects: ['project_kmp', 'project_toyou', 'skills', ...],
  personal: ['personality', 'favorites', 'music_taste', ...],
  // 40+ topics with adjacency
};
 
const TOPIC_WEIGHTS = {
  about: 10,       // 높음: 기초 주제
  daval: 7,        // 중간-높음: 직업
  personal: 8,     // 중간-높음: 개인
  love_type: 2,    // 낮음: 민감한 주제
  // ...
};

function recommendTopics(sessionContext) {
  const explored = sessionContext.exploredTopics; // Set of topic IDs
  const candidates = new Map();
 
  // 1. Adjacency 기반 추천
  for (const exploredTopic of explored) {
    const neighbors = TOPIC_GRAPH[exploredTopic] || [];
    for (const neighbor of neighbors) {
      if (explored.has(neighbor)) continue;
 
      const baseWeight = TOPIC_WEIGHTS[neighbor] || 5;
      const adjacencyBonus = 3; // 인접 토픽은 bonus
      const totalScore = baseWeight + adjacencyBonus;
 
      candidates.set(neighbor, totalScore);
    }
  }
 
  // 2. 아직 explore하지 않은 high-weight 토픽
  for (const [topic, weight] of Object.entries(TOPIC_WEIGHTS)) {
    if (explored.has(topic)) continue;
    const score = weight + (candidates.get(topic) || 0);
    candidates.set(topic, score);
  }
 
  // 3. Sort & return top 3
  return Array.from(candidates.entries())
    .sort((a, b) => b[1] - a[1])
    .slice(0, 3)
    .map(([topic]) => topic);
}

// Redis에 session 정보 저장
const sessionKey = `session:${visitorId}:${sessionId}`;
 
const session = {
  visitorId,
  sessionId,
  exploredTopics: new Set(['about', 'daval']),
  conversationTurns: 4,
  createdAt: Date.now(),
  ttl: 2 * 60 * 60 * 1000  // 2 hours
};
 
await redis.setex(sessionKey, 7200, JSON.stringify(session));

// 옛날 방식 (손실됨)
fs.appendFileSync('logs/requests.jsonl', JSON.stringify(logEntry) + '\n');
 
// 새로운 방식 (Redis에 영구 저장)
await redis.zadd('chat:requests', Date.now(), JSON.stringify({
  requestId,
  userId,
  intent,
  model,
  status,
  timestamp: Date.now()
}));

const REDIS_KEYS = {
  'chat:visitors': 'visitor profiling 로그',
  'chat:requests': 'API request 메트릭',
  'chat:feedback': '사용자 피드백 (좋음/싫음)',
  'chat:gaps': '미답변/저품질 질문들',
  'chat:latency': '단계별 성능 지표',
  'chat:cache': 'semantic cache',
  'chat:costs': '토큰 수 + USD 비용'
};
 
// Sorted Set (score = timestamp)
// zadd(key, timestamp, JSON.stringify(entry))

npm run fetch-questions           # 전체 데이터
npm run fetch-questions --days 7  # 최근 7일

// Redis → 로컬 JSON 변환
async function fetchFromRedis() {
  const client = redis.createClient();
  await client.connect();
 
  const result = await client.zrange('chat:requests', 0, -1, {
    withScores: true
  });
 
  const entries = result.map((item, idx) => {
    if (idx % 2 === 0) return JSON.parse(item);
  });
 
  fs.writeFileSync('data/chat-logs/requests.json', JSON.stringify(entries, null, 2));
 
  console.log(`✓ Fetched ${entries.length} requests`);
}

class SemanticCache {
  constructor() {
    this.maxInMemory = 50;
    this.index = [];  // [{embedding, normalizedKey, response}, ...]
    this.threshold = 0.92;
  }
 
  async get(query, intent) {
    // 1. In-memory lookup
    const inMemoryHit = this._findByCosineSimilarity(query);
    if (inMemoryHit) {
      this.stats.hits++;
      this.stats.semanticHits++;
      return inMemoryHit.response;
    }
 
    // 2. Redis exact match
    const fieldKey = _makeFieldKey(intent, normalizeQuery(query));
    const cachedEntry = await redis.hget('chat:cache', fieldKey);
    if (cachedEntry) {
      this.stats.hits++;
      this.stats.stringHits++;
      return JSON.parse(cachedEntry).response;
    }
 
    // 3. Redis full scan (cold start recovery)
    const allCached = await redis.hgetall('chat:cache');
    for (const [, entry] of Object.entries(allCached)) {
      const parsed = JSON.parse(entry);
      const similarity = cosineSimilarity(
        queryEmbed,
        parsed.embedding
      );
      if (similarity >= this.threshold) {
        // Populate in-memory for next hit
        this._addToInMemoryIndex(parsed);
        this.stats.hits++;
        this.stats.redisHits++;
        return parsed.response;
      }
    }
 
    return null;  // Cache miss
  }
}

// Phase 2 parallel
const [cachedResponse, retrievalResults] = await Promise.all([
  semanticCache.get(query, intent),
  vectorRetriever.search(query)
]);
 
if (cachedResponse) return cachedResponse;
 
// Phase 3 parallel
const [rerankedChunks, conversationSummary] = await Promise.all([
  reranker.rank(retrievalResults, query),
  summarizer.summarizeHistory(history)
]);
 
// Main + Follow-up parallel
const mainLLMPromise = generateMainResponse(rerankedChunks);
const followUpPromise = generateFollowUps(rerankedChunks, intent);
 
const [mainResponse, followUps] = await Promise.all([
  mainLLMPromise,
  followUpPromise
]);

// 옛날: 매번 embedding 계산
const cacheResult = await semanticCache.get(query);  // embed
const retrieval = await retriever.search(query);     // embed again!
 
// 새로운: 한 번만 계산
const embedding = await embeddings.encode(query);   // 1번만
 
const cacheResult = await semanticCache.get(query, embedding);
const retrieval = await retriever.search(query, embedding);
const rerank = await reranker.score(results, embedding);

class LatencyProfiler {
  recordStage(stageName, durationMs) {
    // Redis sorted set에 기록
    await redis.zadd(`latency:${stageName}`, Date.now(), durationMs);
  }
 
  async getStats(stageName) {
    const measurements = await redis.zrange(`latency:${stageName}`, 0, -1);
    const nums = measurements.map(Number);
 
    return {
      p50: percentile(nums, 50),
      p95: percentile(nums, 95),
      p99: percentile(nums, 99),
      avg: average(nums),
      count: nums.length
    };
  }
}

const requestLog = {
  requestId: crypto.randomUUID(),
  timestamp: Date.now(),
  userId: visitorId,
 
  // Input
  query,
  intent,
 
  // Pipeline stages with timing
  timing: {
    guardrails_ms: 5,
    intent_classification_ms: 45,
    embeddings_ms: 120,      // Most expensive
    cache_lookup_ms: 2,
    retrieval_ms: 80,
    rerank_ms: 350,
    summarize_ms: 180,
    llm_generation_ms: 2100,
    total_pipeline_ms: 2883,
    total_llm_ms: 2100,
    overhead_ms: 783  // 2883 - 2100
  },
 
  // Cost
  input_tokens: 3240,
  output_tokens: 580,
  cost_usd: 0.0124,
 
  // Quality
  retrieval_score: 0.87,
  rerank_quality: 0.92,
 
  status: 'success'
};
 
await redis.zadd('chat:requests', Date.now(), JSON.stringify(requestLog));

GET /api/chat/latency?stage=llm_generation
→ {
  p50_ms: 1200,
  p95_ms: 3400,
  p99_ms: 8200,
  avg_ms: 1450,
  count: 1284
}
 
GET /api/chat/analytics
→ {
  daily_requests: 245,
  avg_cost_per_request: $0.0089,
  total_cost_today: $2.18,
  model_distribution: { haiku: 60%, sonnet: 40% }
}

node scripts/auto-learn.js              # 갭 분석 (dry-run)
node scripts/auto-learn.js --auto       # Haiku로 제안 생성
node scripts/auto-learn.js --days 14    # 14일 데이터

// 1. Gap 데이터 로드 (retrieval score < 0.15 또는 eval score < 3)
const gaps = await fetchGapsFromRedis(filterDays);
 
// 2. 비슷한 질문들을 클러스터링 (simple keyword-based)
const clusters = clusterGaps(gaps, similarityThreshold = 0.7);
 
// 3. Top clusters별로 Haiku에 제안 요청
for (const cluster of clusters.slice(0, 10)) {
  const prompt = `
    이 질문들은 모두 비슷한 주제인데 chatbot이 잘 답하지 못했어요:
    ${cluster.questions.map(q => `- ${q}`).join('\n')}
 
    이들을 cover할 new knowledge chunk template을 제안해 주세요.
    (마크다운 format, 200-300 words)
  `;
 
  const suggestion = await claude.messages.create({
    model: 'claude-haiku-4-5-20251001',
    messages: [{ role: 'user', content: prompt }]
  });
 
  console.log(`Suggestion for cluster "${cluster.topic}":`);
  console.log(suggestion.content[0].text);
}

// 예전: 텍스트 parsing (불안정)
const followUps = parseJSON(responseText);  // brittle
 
// 새로운: Claude tool_use (structured output)
const response = await claude.messages.create({
  model: 'claude-haiku-4-5-20251001',
  tools: [{
    name: 'suggest_follow_ups',
    description: 'Suggest 2-3 follow-up questions based on the conversation',
    input_schema: {
      type: 'object',
      properties: {
        questions: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              question: { type: 'string' },
              relevance: { type: 'string' }
            },
            required: ['question', 'relevance']
          }
        }
      },
      required: ['questions']
    }
  }],
  messages: [...]
});
 
// tool_use로 guaranteed structured output
const followUps = extractToolUse(response);