プロンプトエンジニアリング完全ガイド【エンジニア向け】｜Zero-shot・CoT・ReAct・構造化出力まで実装コード付きで解説

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

const client = new Anthropic();

async function classifySentiment(text: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 50,
    messages: [
      {
        role: "user",
        content: `以下のテキストの感情を「positive」「negative」「neutral」のいずれかで分類してください。\n\nテキスト: ${text}\n\n分類結果:`,
      },
    ],
  });
  return (response.content[0] as { text: string }).text.trim();
}

const result = await classifySentiment("このAPIは使いやすくて最高です！");
console.log(result); // "positive"

import OpenAI from "openai";

const client = new OpenAI();

async function extractKeywords(text: string): Promise<string[]> {
  const response = await client.chat.completions.create({
    model: "gpt-4o",
    messages: [
      {
        role: "system",
        content: "テキストから技術キーワードを抽出します。カンマ区切りで返してください。",
      },
      // Few-shot examples
      {
        role: "user",
        content: "TypeScriptでReactのカスタムフックを実装しました。",
      },
      {
        role: "assistant",
        content: "TypeScript, React, カスタムフック",
      },
      {
        role: "user",
        content: "DockerコンテナでPostgreSQLをローカル環境に立てました。",
      },
      {
        role: "assistant",
        content: "Docker, コンテナ, PostgreSQL, ローカル環境",
      },
      // 実際のリクエスト
      {
        role: "user",
        content: text,
      },
    ],
  });

  const raw = response.choices[0].message.content ?? "";
  return raw.split(",").map((kw) => kw.trim());
}

const keywords = await extractKeywords(
  "Next.jsとPrismaを使ってREST APIを構築しています。"
);
console.log(keywords); // ["Next.js", "Prisma", "REST API"]

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

const client = new Anthropic();

async function debugCode(code: string, error: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: `以下のTypeScriptコードでエラーが発生しています。\nステップバイステップで原因を分析し、修正方法を説明してください。\n\nコード:\n${code}\n\nエラー:\n${error}`,
      },
    ],
  });
  return (response.content[0] as { text: string }).text;
}

const code = `
async function fetchUser(id: string) {
  const res = await fetch('/api/users/' + id);
  return res.json();
}
const user = fetchUser("123");
console.log(user.name);
`;

const analysis = await debugCode(code, "Cannot read properties of undefined (reading 'name')");
console.log(analysis);

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

const client = new Anthropic();

const COT_SYSTEM = `あなたはコードレビューの専門家です。
問題を発見したら、必ず次の手順で回答してください：
1. 問題の特定（何が問題か）
2. 影響範囲（どんなバグやリスクが生じるか）
3. 修正案（具体的なコード）

例：
問題: setInterval の戻り値を clearInterval で解除していない
影響: コンポーネントのアンマウント後もタイマーが動き続け、メモリリーク発生
修正案:
  const timerId = setInterval(fn, 1000);
  return () => clearInterval(timerId);`;

async function reviewCode(code: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 1024,
    system: COT_SYSTEM,
    messages: [{ role: "user", content: `以下のコードをレビューしてください:\n\n${code}` }],
  });
  return (response.content[0] as { text: string }).text;
}

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

const client = new Anthropic();

// ツール定義
const tools: Anthropic.Tool[] = [
  {
    name: "search_docs",
    description: "ドキュメントを検索して関連情報を返します",
    input_schema: {
      type: "object",
      properties: {
        query: { type: "string", description: "検索クエリ" },
      },
      required: ["query"],
    },
  },
  {
    name: "run_code",
    description: "TypeScriptコードを実行して結果を返します",
    input_schema: {
      type: "object",
      properties: {
        code: { type: "string", description: "実行するコード" },
      },
      required: ["code"],
    },
  },
];

// ツール実行のモック（実際はここに実装を入れる）
function executeTool(name: string, input: Record<string, unknown>): string {
  if (name === "search_docs") {
    return `「${String(input.query)}」の検索結果: Array.prototype.map() は各要素に関数を適用した新しい配列を返します。`;
  }
  if (name === "run_code") {
    return `実行結果: [2, 4, 6]`;
  }
  return "ツールが見つかりません";
}

async function reactAgent(task: string): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: task },
  ];

  // ReActループ（最大10ステップ）
  for (let step = 0; step < 10; step++) {
    const response = await client.messages.create({
      model: "claude-opus-4-6",
      max_tokens: 1024,
      tools,
      messages,
    });

    // ツール呼び出しがない場合は最終回答
    if (response.stop_reason === "end_turn") {
      const textBlock = response.content.find((b) => b.type === "text");
      return textBlock ? (textBlock as { type: "text"; text: string }).text : "";
    }

    // アシスタントのメッセージを追加
    messages.push({ role: "assistant", content: response.content });

    // ツール呼び出しを処理
    const toolResults: Anthropic.ToolResultBlockParam[] = response.content
      .filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use")
      .map((toolUse) => ({
        type: "tool_result" as const,
        tool_use_id: toolUse.id,
        content: executeTool(toolUse.name, toolUse.input as Record<string, unknown>),
      }));

    messages.push({ role: "user", content: toolResults });
  }

  return "最大ステップ数に達しました";
}

const result = await reactAgent(
  "[1, 2, 3]に対してmapで2倍にする方法を調べて、コードを実行して確認してください"
);
console.log(result);

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

const client = new Anthropic();

async function selfConsistency(
  question: string,
  numSamples: number = 5
): Promise<string> {
  // 同じプロンプトを複数回実行する（モデルは確率的なので毎回異なる推論をする）
  const promises = Array.from({ length: numSamples }, () =>
    client.messages.create({
      model: "claude-opus-4-6",
      max_tokens: 256,
      messages: [
        {
          role: "user",
          content: `${question}\n\nステップバイステップで考えて、最後に「答え: X」の形式で回答してください。`,
        },
      ],
    })
  );

  const responses = await Promise.all(promises);

  // 各レスポンスから「答え: X」を抽出
  const answers = responses.map((r) => {
    const text = (r.content[0] as { text: string }).text;
    const match = text.match(/答え[:：]\s*(.+)/);
    return match ? match[1].trim() : text.trim();
  });

  // 多数決：最も多く出現した答えを返す
  const counts = new Map<string, number>();
  for (const answer of answers) {
    counts.set(answer, (counts.get(answer) ?? 0) + 1);
  }

  return [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
}

const answer = await selfConsistency(
  "TypeScriptで型ガードとして機能する関数の正しい戻り値の型は何ですか？",
  5
);
console.log("最多回答:", answer);

// コードレビューアシスタントのシステムプロンプト
const CODE_REVIEW_SYSTEM = `あなたは10年以上の経験を持つシニアTypeScriptエンジニアです。
コードレビューの専門家として振る舞ってください。

【レビュー方針】
- 型安全性（型の欠落・any の乱用・型アサーションの誤用）を最優先でチェックする
- パフォーマンス問題（無駄なレンダリング・N+1クエリ・メモリリーク）を指摘する
- セキュリティリスク（インジェクション・XSS・認証の欠落）を必ず確認する
- 読みやすさと保守性の観点でコメントする

【出力形式】
必ず以下のJSON形式で返してください:
{
  "severity": "critical" | "major" | "minor" | "info",
  "issues": [
    {
      "line": 行番号または範囲,
      "type": "type-safety" | "performance" | "security" | "readability",
      "description": "問題の説明",
      "suggestion": "修正案のコード"
    }
  ],
  "summary": "全体的な評価（2〜3文）"
}

【禁止事項】
- 問題がない場合でも必ずissuesを空配列で返す（省略しない）
- JSONフォーマット以外での回答は禁止
- 推測でissuesを追加しない`;

export { CODE_REVIEW_SYSTEM };

// プロンプトの構成要素をモジュール化する
const PERSONA = (role: string, experience: string) =>
  `あなたは${experience}の${role}です。`;

const OUTPUT_FORMAT = (format: string) =>
  `必ず${format}形式で回答してください。`;

const CONSTRAINTS = (...rules: string[]) =>
  `【制約】\n${rules.map((r, i) => `${i + 1}. ${r}`).join("\n")}`;

// 組み合わせてシステムプロンプトを構築
function buildSystemPrompt(config: {
  role: string;
  experience: string;
  outputFormat: string;
  constraints: string[];
}): string {
  return [
    PERSONA(config.role, config.experience),
    OUTPUT_FORMAT(config.outputFormat),
    CONSTRAINTS(...config.constraints),
  ].join("\n\n");
}

const systemPrompt = buildSystemPrompt({
  role: "SQLクエリ最適化エンジニア",
  experience: "データベースチューニング10年以上",
  outputFormat: "JSON（original_query, optimized_query, explanation を含む）",
  constraints: [
    "実行計画の改善点を必ず説明する",
    "インデックスの提案がある場合はCREATE INDEX文も含める",
    "PostgreSQL 15+を前提とする",
  ],
});

console.log(systemPrompt);

import Anthropic from "@anthropic-ai/sdk";
import { z } from "zod";

const client = new Anthropic();

// 期待するレスポンスの型をZodスキーマで定義
const CodeReviewSchema = z.object({
  severity: z.enum(["critical", "major", "minor", "info"]),
  issues: z.array(
    z.object({
      line: z.union([z.number(), z.string()]),
      type: z.enum(["type-safety", "performance", "security", "readability"]),
      description: z.string(),
      suggestion: z.string(),
    })
  ),
  summary: z.string(),
});

type CodeReview = z.infer<typeof CodeReviewSchema>;

async function reviewCode(code: string): Promise<CodeReview> {
  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 1024,
    system: `コードレビューの結果を以下のJSON形式のみで返してください。余分なテキストは含めないでください。
スキーマ:
{
  "severity": "critical" | "major" | "minor" | "info",
  "issues": [{ "line": number | string, "type": string, "description": string, "suggestion": string }],
  "summary": string
}`,
    messages: [{ role: "user", content: `以下のコードをレビューしてください:\n\n${code}` }],
  });

  const text = (response.content[0] as { text: string }).text;

  // JSON部分を抽出（モデルが余分なテキストを出力した場合に対応）
  const jsonMatch = text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) throw new Error("JSON形式のレスポンスが見つかりません");

  const parsed = JSON.parse(jsonMatch[0]);
  return CodeReviewSchema.parse(parsed); // 型チェック（失敗時は例外）
}

// 使用例
const review = await reviewCode(`
function getUser(id) {
  return fetch('/api/users/' + id).then(r => r.json());
}
`);

if (review.severity === "critical") {
  console.error("重大な問題があります:", review.issues);
} else {
  console.log("レビュー完了:", review.summary);
}

import OpenAI from "openai";
import { zodResponseFormat } from "openai/helpers/zod";
import { z } from "zod";

const client = new OpenAI();

const ArticleSchema = z.object({
  title: z.string(),
  summary: z.string().max(200),
  keywords: z.array(z.string()).max(5),
  difficulty: z.enum(["beginner", "intermediate", "advanced"]),
});

type Article = z.infer<typeof ArticleSchema>;

async function generateArticleMeta(content: string): Promise<Article> {
  const response = await client.beta.chat.completions.parse({
    model: "gpt-4o-2024-08-06",
    messages: [
      {
        role: "system",
        content: "技術記事のメタデータを生成します。",
      },
      {
        role: "user",
        content: `以下の記事のメタデータを生成してください:\n\n${content}`,
      },
    ],
    response_format: zodResponseFormat(ArticleSchema, "article_meta"),
  });

  const parsed = response.choices[0].message.parsed;
  if (!parsed) throw new Error("パースに失敗しました");
  return parsed;
}

const meta = await generateArticleMeta(
  "TypeScriptのジェネリクスを使うと、型安全なコレクションが実装できます..."
);
console.log(meta.title, meta.difficulty); // 型が保証される

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

const client = new Anthropic();

// 英語プロンプトで高精度を狙い、日本語で出力させるパターン
async function analyzeCode(code: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 512,
    messages: [
      {
        role: "user",
        // 指示は英語、出力指定は日本語
        content: `Analyze the following TypeScript code for potential bugs and type safety issues.
Respond in Japanese with specific line references.

Code:
${code}`,
      },
    ],
  });
  return (response.content[0] as { text: string }).text;
}

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

const client = new Anthropic();

interface Document {
  id: string;
  title: string;
  content: string;
  score: number; // 類似度スコア
}

function buildRagPrompt(query: string, documents: Document[]): string {
  // 関連度スコアでソートして上位のドキュメントを使う
  const topDocs = documents
    .sort((a, b) => b.score - a.score)
    .slice(0, 3);

  const context = topDocs
    .map((doc, i) => `[文書${i + 1}] ${doc.title}\n${doc.content}`)
    .join("\n\n---\n\n");

  return `以下の参考文書をもとに、質問に回答してください。

【重要なルール】
- 参考文書に記載されている情報のみを使って回答してください
- 文書にない情報を推測・補完しないでください
- 確信が持てない場合は「文書には記載がありません」と明記してください
- 回答の根拠となる文書番号を[文書X]の形式で明示してください

===参考文書===
${context}
=============

質問: ${query}`;
}

async function ragAnswer(
  query: string,
  documents: Document[]
): Promise<string> {
  const prompt = buildRagPrompt(query, documents);

  const response = await client.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
  });

  return (response.content[0] as { text: string }).text;
}

// 使用例
const docs: Document[] = [
  {
    id: "1",
    title: "TypeScriptの型ガード",
    content: "型ガードはruntime で型を絞り込む関数です。is キーワードを使います。",
    score: 0.92,
  },
  {
    id: "2",
    title: "TypeScriptのGenerics",
    content: "Genericsを使うと型安全な汎用コンポーネントを作れます。",
    score: 0.75,
  },
];

const answer = await ragAnswer("型ガードとは何ですか？", docs);
console.log(answer);

{
  "version": "2.0.0",
  "name": "code-review",
  "description": "TypeScriptコードレビュー用プロンプト",
  "system": "あなたはシニアTypeScriptエンジニアです...",
  "variables": ["code", "context"],
  "template": "以下のTypeScriptコードをレビューしてください。\n\nコンテキスト: {{context}}\n\nコード:\n{{code}}",
  "updated_at": "2025-03-01"
}

import * as fs from "fs";
import * as path from "path";

interface PromptConfig {
  version: string;
  name: string;
  description: string;
  system: string;
  variables: string[];
  template: string;
  updated_at: string;
}

class PromptManager {
  private promptsDir: string;

  constructor(promptsDir: string) {
    this.promptsDir = promptsDir;
  }

  load(name: string, version?: string): PromptConfig {
    const pattern = version ? `${name}.v${version}.json` : `${name}.json`;
    const filePath = path.join(this.promptsDir, pattern);
    return JSON.parse(fs.readFileSync(filePath, "utf-8")) as PromptConfig;
  }

  render(config: PromptConfig, variables: Record<string, string>): string {
    return config.variables.reduce(
      (template, varName) =>
        template.replace(
          new RegExp(`\\{\\{${varName}\\}\\}`, "g"),
          variables[varName] ?? ""
        ),
      config.template
    );
  }
}

// 使用例
const manager = new PromptManager("./prompts");
const promptConfig = manager.load("code-review", "2");
const userMessage = manager.render(promptConfig, {
  code: "const x: any = getValue();",
  context: "ECサイトの商品取得API",
});

console.log(promptConfig.system); // システムプロンプト
console.log(userMessage); // ユーザーメッセージ

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

const client = new Anthropic();

interface EvalCase {
  input: string;
  expected: string; // 期待する出力のキーワードや部分文字列
}

interface EvalResult {
  case: EvalCase;
  output: string;
  passed: boolean;
  score: number;
}

async function evaluatePrompt(
  systemPrompt: string,
  evalCases: EvalCase[]
): Promise<{ results: EvalResult[]; averageScore: number }> {
  const results: EvalResult[] = await Promise.all(
    evalCases.map(async (evalCase) => {
      const response = await client.messages.create({
        model: "claude-opus-4-6",
        max_tokens: 512,
        system: systemPrompt,
        messages: [{ role: "user", content: evalCase.input }],
      });

      const output = (response.content[0] as { text: string }).text;

      // 簡易スコアリング：期待キーワードが含まれているか
      const passed = output
        .toLowerCase()
        .includes(evalCase.expected.toLowerCase());
      const score = passed ? 1 : 0;

      return { case: evalCase, output, passed, score };
    })
  );

  const averageScore =
    results.reduce((sum, r) => sum + r.score, 0) / results.length;

  return { results, averageScore };
}

// 評価実行例
const evalCases: EvalCase[] = [
  {
    input: "anyを使っているコード: const x: any = 1;",
    expected: "any",
  },
  {
    input: "型が正しいコード: const x: number = 1;",
    expected: "問題",
  },
];

const { results, averageScore } = await evaluatePrompt(
  "TypeScriptコードの型安全性をレビューしてください。",
  evalCases
);

console.log(`平均スコア: ${(averageScore * 100).toFixed(1)}%`);
results.forEach((r) => {
  console.log(`${r.passed ? "✓" : "✗"} ${r.case.input.slice(0, 30)}...`);
});