Anthropic Claude API

const response = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [
    { role: "system", content: "시스템 프롬프트" },
    { role: "user", content: "사용자 입력" }
  ],
  max_tokens: 1024
});

const text = response.choices[0].message.content;

const response = await anthropic.messages.create({
  model: "claude-3-5-haiku-latest",
  system: "시스템 프롬프트",
  messages: [
    { role: "user", content: "사용자 입력" }
  ],
  max_tokens: 1024
});

const text = response.content[0].text;

npm install @anthropic-ai/sdk

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.AI_API_KEY,
});

const params: Anthropic.MessageCreateParams = {
  model: "claude-3-5-haiku-latest",
  max_tokens: 8192,
  system: "당신은 기술 블로그 글을 요약하는 전문가입니다. JSON 형식으로 응답하세요.",
  messages: [
    { role: "user", content: articleContent }
  ],
};

const message = await client.messages.create(params);

interface Message {
  id: string;           // 고유 메시지 ID
  type: "message";
  role: "assistant";
  content: ContentBlock[];  // 응답 콘텐츠 블록 배열
  model: string;        // 실제 사용된 모델
  stop_reason: "end_turn" | "max_tokens" | "stop_sequence";
  usage: {
    input_tokens: number;
    output_tokens: number;
  };
}

type ContentBlock = TextBlock | ImageBlock;

interface TextBlock {
  type: "text";
  text: string;
}

const message = await client.messages.create(params);

if (message.stop_reason === "max_tokens") {
  console.warn("응답이 잘렸습니다. max_tokens를 늘려주세요.");
}

const responseText = message.content[0].text;

const { input_tokens, output_tokens } = message.usage;
console.log(`입력: ${input_tokens} 토큰, 출력: ${output_tokens} 토큰`);

const system = `당신은 기술 블로그 글을 분석하는 전문가입니다.

반드시 아래 JSON 형식으로만 응답하세요. 다른 텍스트는 포함하지 마세요.

{
  "summary": "2-3문장 요약",
  "tags": {
    "태그1": true,
    "태그2": true
  }
}`;

const message = await client.messages.create({
  model: "claude-3-5-haiku-latest",
  max_tokens: 8192,
  system,
  messages: [{ role: "user", content: articleContent }],
});

const responseText = message.content[0].text
  .replace(/[\n\r\t\s]+/g, " ");  // 줄바꿈/공백 정리

const result = JSON.parse(responseText);
console.log(result.summary);
console.log(Object.keys(result.tags));

  
  // JSON 부분만 추출 (첫 번째 { 부터 마지막 } 까지)
  const match = cleaned.match(/\{[\s\S]*\}/);
  if (!match) throw new Error("JSON not found in response");
  
  return JSON.parse(match[0]);
}

const stream = await client.messages.stream({
  model: "claude-3-5-haiku-latest",
  max_tokens: 4096,
  messages: [{ role: "user", content: "긴 글을 작성해주세요." }],
});

for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    process.stdout.write(event.delta.text);
  }
}

// 스트림 완료 후 최종 메시지 객체 얻기
const finalMessage = await stream.finalMessage();
console.log(finalMessage.usage);

function isRetryableError(error: Error): boolean {
  const message = error.message.toLowerCase();
  
  // 영구적 에러
  if (message.includes("invalid") || message.includes("401")) return false;
  if (message.includes("json") || message.includes("parse")) return false;
  
  // 일시적 에러
  if (message.includes("rate limit") || message.includes("429")) return true;
  if (message.includes("timeout") || message.includes("503")) return true;
  
  // 판단 불가능한 에러는 일단 재시도
  return true;
}

async function callWithRetry<T>(
  fn: () => Promise<T>,
  maxRetries: number = 3
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (!isRetryableError(error) || attempt === maxRetries) {
        throw error;
      }
      
      const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
      console.warn(`재시도 ${attempt + 1}/${maxRetries} (${delay}ms 후)`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
  throw new Error("Unreachable");
}

// 사용
const message = await callWithRetry(() =>
  client.messages.create(params)
);

interface QueueItem {
  id: number;
  content: string;
  deathCount: number;
}

async function processWithRetry(
  item: QueueItem,
  queue: string
): Promise<void> {
  try {
    const result = await callAI(item.content);
    await saveResult(item.id, result);
  } catch (error) {
    if (isRetryableError(error) && item.deathCount < 3) {
      item.deathCount++;
      await redis.rpush(queue, JSON.stringify(item));
      console.warn(`${item.id} 재시도 예약 (${item.deathCount}/3)`);
    } else {
      console.error(`${item.id} 영구 실패`);
      await markAsFailed(item.id);
    }
  }
}

async function processBatch(
  items: QueueItem[],
  concurrency: number = 5
): Promise<void> {
  // Rate limit에 맞춰 동시 처리 수 제한
  const chunks = [];
  for (let i = 0; i < items.length; i += concurrency) {
    chunks.push(items.slice(i, i + concurrency));
  }
  
  for (const chunk of chunks) {
    await Promise.all(chunk.map(item => processItem(item)));
    // 청크 간 딜레이로 rate limit 회피
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
}

const batchSize = parseInt(process.env.AI_RATE_LIMIT_COUNT || "5");
const items = await loadFromQueue(batchSize);
await Promise.all(items.map(item => processItem(item)));

const system = `기술 블로그 글을 분석하세요.

예시 입력: "React 18에서 Suspense를 활용한 데이터 페칭 패턴을 알아봅니다."
예시 출력: {"summary": "React 18의 Suspense를 이용한 선언적 데이터 페칭 방법을 설명하는 글", "tags": {"React": true, "Suspense": true}}

반드시 위 JSON 형식으로만 응답하세요.`;

const system = `당신은 10년 경력의 시니어 개발자입니다.
기술 블로그 글을 읽고 핵심 내용을 2-3문장으로 요약합니다.
초보 개발자도 이해할 수 있는 쉬운 언어를 사용합니다.`;

const system = `규칙:
1. 반드시 JSON으로만 응답
2. summary는 100자 이내
3. tags는 최대 5개
4. 한국어로 작성`;