Claude API で会話型 AI を本番運用する技術 — コンテキスト制御・長期メモリ・安全性フィルターの統合設計

import Anthropic from "@anthropic-ai/sdk";
 
interface ConversationMemory {
  summary: string;           // 第2層: これまでの会話要約
  recentMessages: Array<{    // 第1層: 直近のメッセージ
    role: "user" | "assistant";
    content: string;
  }>;
  totalTurns: number;
}
 
const client = new Anthropic();
const MAX_RECENT_MESSAGES = 10; // 直近5ターン分(user + assistant)
const SUMMARY_TRIGGER = 8;     // この件数を超えたら要約を生成
 
async function chat(
  memory: ConversationMemory,
  userMessage: string
): Promise<{ response: string; updatedMemory: ConversationMemory }> {
  memory.recentMessages.push({ role: "user", content: userMessage });
  memory.totalTurns++;
 
  // 直近メッセージが閾値を超えたら要約を生成して圧縮
  if (memory.recentMessages.length > MAX_RECENT_MESSAGES) {
    try {
      memory.summary = await compressToSummary(
        memory.summary,
        memory.recentMessages.slice(0, -SUMMARY_TRIGGER)
      );
      memory.recentMessages = memory.recentMessages.slice(-SUMMARY_TRIGGER);
    } catch (error) {
      // 要約生成に失敗しても会話は継続(古いメッセージを単純に切り捨て)
      console.error("Summary generation failed, truncating:", error);
      memory.recentMessages = memory.recentMessages.slice(-MAX_RECENT_MESSAGES);
    }
  }
 
  const systemPrompt = buildSystemPrompt(memory.summary);
 
  try {
    const response = await client.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: 2048,
      system: systemPrompt,
      messages: memory.recentMessages,
    });
 
    const assistantMessage =
      response.content[0].type === "text" ? response.content[0].text : "";
    memory.recentMessages.push({ role: "assistant", content: assistantMessage });
 
    return { response: assistantMessage, updatedMemory: memory };
  } catch (error) {
    if (error instanceof Anthropic.RateLimitError) {
      await new Promise((r) => setTimeout(r, 2000));
      return chat(
        { ...memory, recentMessages: memory.recentMessages.slice(0, -1) },
        userMessage
      );
    }
    throw error;
  }
}
 
async function compressToSummary(
  existingSummary: string,
  messagesToCompress: Array<{ role: string; content: string }>
): Promise<string> {
  const conversationText = messagesToCompress
    .map((m) => `${m.role}: ${m.content}`)
    .join("\n");
 
  // 要約にはHaikuを使いコスト削減(品質差はほぼ体感できない)
  const response = await client.messages.create({
    model: "claude-haiku-4-5",
    max_tokens: 500,
    messages: [
      {
        role: "user",
        content: `以下の会話履歴を、重要な情報(ユーザーの質問意図、解決した問題、未解決の話題、ユーザーが示した好み)を保持しながら簡潔に要約してください。
 
既存の要約:
${existingSummary || "(なし)"}
 
新しい会話:
${conversationText}
 
要約(300文字以内):`,
      },
    ],
  });
 
  return response.content[0].type === "text"
    ? response.content[0].text
    : existingSummary;
}
 
function buildSystemPrompt(summary: string): string {
  const base = `あなたはユーザーの技術的な質問に答えるアシスタントです。
丁寧かつ実践的に回答し、コード例を含めてください。`;
 
  if (\!summary) return base;
  return `${base}
 
【これまでの会話の要約】
${summary}
 
上記の要約を踏まえて、文脈に沿った回答をしてください。ただし要約の内容を繰り返す必要はありません。`;
}

import Anthropic from "@anthropic-ai/sdk";
import pg from "pg";
 
const client = new Anthropic();
const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
 
// 会話から記憶すべき情報を抽出する
async function extractMemories(
  conversation: Array<{ role: string; content: string }>
): Promise<Array<{ content: string; category: string; importance: number }>> {
  const conversationText = conversation
    .map((m) => `${m.role}: ${m.content}`)
    .join("\n");
 
  try {
    const response = await client.messages.create({
      model: "claude-haiku-4-5",
      max_tokens: 1000,
      messages: [
        {
          role: "user",
          content: `以下の会話から、将来の会話で役立つ情報を抽出してJSON配列で返してください。
抽出基準:
- ユーザーの好み(preference): 使用言語、フレームワーク、コーディングスタイル
- 事実情報(fact): プロジェクト名、技術スタック、チーム規模
- 文脈情報(context): 現在取り組んでいる課題、学習段階
 
抽出不要:
- 一般的な技術質問の内容(検索すれば分かる情報)
- 挨拶や雑談
- 一時的な話題
 
会話:
${conversationText}
 
JSON配列:
[{"content": "...", "category": "preference|fact|context", "importance": 0.0-1.0}]`,
        },
      ],
    });
 
    const text = response.content[0].type === "text" ? response.content[0].text : "[]";
    const jsonMatch = text.match(/\[[\s\S]*\]/);
    if (\!jsonMatch) return [];
 
    const parsed = JSON.parse(jsonMatch[0]);
    // 重要度が低い情報は捨てる(ノイズ削減)
    return parsed.filter(
      (m: { importance: number }) => m.importance >= 0.5
    );
  } catch (error) {
    console.error("Memory extraction failed:", error);
    return []; // 抽出失敗時も会話は継続できる
  }
}
 
// ベクトル検索で関連する記憶を取得
async function retrieveRelevantMemories(
  userId: string,
  query: string,
  limit: number = 5
): Promise<string[]> {
  try {
    const embedding = await generateEmbedding(query);
 
    // similarity * importance の複合スコアでランキング
    const result = await pool.query(
      `SELECT content, importance,
              1 - (embedding <=> $1::vector) AS similarity
       FROM user_memories
       WHERE user_id = $2
         AND created_at > NOW() - INTERVAL '90 days'
       ORDER BY (1 - (embedding <=> $1::vector)) * importance DESC
       LIMIT $3`,
      [JSON.stringify(embedding), userId, limit]
    );
 
    return result.rows.map((row: { content: string }) => row.content);
  } catch (error) {
    console.error("Memory retrieval failed:", error);
    return []; // 検索失敗時は空配列でフォールバック
  }
}
 
async function generateEmbedding(text: string): Promise<number[]> {
  const response = await fetch("https://api.openai.com/v1/embeddings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "text-embedding-3-small",
      input: text,
    }),
  });
 
  if (\!response.ok) {
    throw new Error(`Embedding API error: ${response.status}`);
  }
 
  const data = await response.json();
  return data.data[0].embedding;
}

interface PersonaConfig {
  basePersonality: string;
  responseRules: string[];
  adaptiveRules: Record<string, string>;
}
 
function buildLayeredSystemPrompt(
  persona: PersonaConfig,
  userLevel: "beginner" | "intermediate" | "advanced",
  conversationMood: "casual" | "professional" | "urgent"
): string {
  // Layer 1: 基本人格(変更不可)
  let prompt = `# あなたの人格\n${persona.basePersonality}\n\n`;
 
  // Layer 2: 応答ルール(常に適用)
  prompt += `# 応答ルール\n`;
  for (const rule of persona.responseRules) {
    prompt += `- ${rule}\n`;
  }
 
  // Layer 3: コンテキスト適応(動的に変化)
  prompt += `\n# 現在の対話コンテキスト\n`;
  prompt += `- ユーザーの技術レベル: ${userLevel}\n`;
 
  if (userLevel === "beginner") {
    prompt += `- 専門用語は必ず平易な言葉で言い換えてから使ってください\n`;
    prompt += `- コード例には1行ごとにコメントを付けてください\n`;
  } else if (userLevel === "advanced") {
    prompt += `- 前提知識の説明は省略し、本質的な部分に集中してください\n`;
    prompt += `- パフォーマンスやエッジケースにも言及してください\n`;
  }
 
  if (persona.adaptiveRules[conversationMood]) {
    prompt += `- ${persona.adaptiveRules[conversationMood]}\n`;
  }
 
  return prompt;
}
 
// 使用例
const techAdvisor: PersonaConfig = {
  basePersonality:
    "実務経験豊富なシニアエンジニア。正確さを重視しつつ、実装の現実的なトレードオフも率直に伝える。わからないことは正直に言う。",
  responseRules: [
    "コードを示す場合は、エラーハンドリングを必ず含める",
    "断定ではなく提案の形で回答する",
    "一度に3つ以上の選択肢を提示しない(選択疲れを防ぐ)",
    "ユーザーが誤解している場合、まず相手の理解を認めてから訂正する",
  ],
  adaptiveRules: {
    casual: "リラックスした口調で、ときどき個人的な経験も交える",
    professional: "簡潔かつ構造的に回答する",
    urgent: "最短の解決策を最初に提示し、詳細は後回しにする",
  },
};

import Anthropic from "@anthropic-ai/sdk";
 
interface SafetyCheckResult {
  safe: boolean;
  reason?: string;
  sanitizedInput?: string;
}
 
const client = new Anthropic();
 
async function validateInput(userInput: string): Promise<SafetyCheckResult> {
  // Step 1: 正規表現ベースの高速フィルタ(APIコール不要)
  const patterns = {
    creditCard: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/,
    injection:
      /ignore\s+(all\s+)?previous\s+instructions|system\s*prompt|you\s+are\s+now/i,
  };
 
  if (patterns.creditCard.test(userInput)) {
    return {
      safe: false,
      reason: "クレジットカード番号が含まれています。個人情報は入力しないでください。",
    };
  }
 
  if (patterns.injection.test(userInput)) {
    // インジェクション試行はブロックせず無害化する
    const sanitized = userInput.replace(patterns.injection, "[filtered]");
    return { safe: true, sanitizedInput: sanitized };
  }
 
  // Step 2: 長文や疑わしいパターンのみClaude Haikuで意味チェック
  if (userInput.length > 500 || containsSuspiciousPatterns(userInput)) {
    try {
      const response = await client.messages.create({
        model: "claude-haiku-4-5",
        max_tokens: 100,
        messages: [
          {
            role: "user",
            content: `以下のユーザー入力を安全性の観点で分類してください。
回答は "safe" または "unsafe: [理由]" のみ。
 
入力: "${userInput.slice(0, 1000)}"`,
          },
        ],
      });
 
      const result =
        response.content[0].type === "text" ? response.content[0].text : "safe";
 
      if (result.startsWith("unsafe")) {
        return { safe: false, reason: result.replace("unsafe: ", "") };
      }
    } catch (error) {
      // 安全性APIが失敗しても会話は継続(可用性優先)
      console.error("Safety check failed:", error);
    }
  }
 
  return { safe: true, sanitizedInput: userInput };
}
 
function containsSuspiciousPatterns(input: string): boolean {
  const keywords = [
    "jailbreak", "bypass", "override", "roleplay as",
    "pretend you", "act as if", "DAN mode",
  ];
  const lower = input.toLowerCase();
  return keywords.some((kw) => lower.includes(kw));
}
 
// 出力のフィルタリング(応答後に実行)
function sanitizeOutput(output: string): string {
  let sanitized = output;
  // APIキー・トークンのパターンを除去
  sanitized = sanitized.replace(
    /\b(sk-[a-zA-Z0-9]{20,}|ghp_[a-zA-Z0-9]{36}|AKIA[A-Z0-9]{16})\b/g,
    "[REDACTED]"
  );
  // 内部パス情報の除去
  sanitized = sanitized.replace(
    /\/(?:home|Users|var|etc)\/[^\s"']+/g,
    "[PATH_REDACTED]"
  );
  return sanitized;
}

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 2048,
  system: [
    {
      type: "text",
      text: systemPromptBase, // 基本人格+応答ルール(変化しない部分)
      cache_control: { type: "ephemeral" },
    },
    {
      type: "text",
      text: dynamicContext, // 会話要約+長期メモリ(ターンごとに変化)
    },
  ],
  messages: memory.recentMessages,
});
// キャッシュヒット時は入力トークンコストが90%削減される

async function productionChatLoop(
  userId: string,
  memory: ConversationMemory,
  userInput: string
): Promise<{ response: string; updatedMemory: ConversationMemory }> {
  // 1. 入力の安全性チェック
  const inputCheck = await validateInput(userInput);
  if (\!inputCheck.safe) {
    return {
      response: `申し訳ありませんが、この入力は処理できません。${inputCheck.reason}`,
      updatedMemory: memory,
    };
  }
  const safeInput = inputCheck.sanitizedInput || userInput;
 
  // 2. 長期メモリから関連情報を取得
  const longTermMemories = await retrieveRelevantMemories(userId, safeInput);
 
  // 3. コンテキスト付きシステムプロンプトを構築
  const systemPrompt = buildContextualSystemPrompt(
    memory.summary,
    longTermMemories
  );
 
  // 4. 会話を実行(スライディングウィンドウ+要約バッファ)
  const result = await chat(memory, safeInput);
 
  // 5. 出力の安全性フィルタリング
  result.response = sanitizeOutput(result.response);
 
  // 6. 長期メモリに保存すべき情報を非同期で抽出(応答を遅延させない)
  extractMemories(memory.recentMessages.slice(-4)).then((memories) => {
    for (const mem of memories) {
      saveToVectorDB(userId, mem).catch(console.error);
    }
  });
 
  return result;
}