コンテキストエンジニアリング完全ガイド - LLM・AIエージェント開発の新パラダイム

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

プロンプトエンジニアリング
├── 指示文の書き方
├── 役割設定（ペルソナ）
└── 出力形式の指定

コンテキストエンジニアリング（上位概念）
├── プロンプトエンジニアリング
├── コンテキストウィンドウ管理
├── 情報の取捨選択と優先順位付け
├── 外部データ統合（RAG、MCP）
├── ツール設計とドキュメント
└── 状態管理と履歴圧縮

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

<system>
<role>
あなたはTypeScriptとReactに精通したシニアフロントエンドエンジニアです。
10年以上の実務経験を持ち、コードレビューとリファクタリングを専門としています。
</role>

<guidelines>
1. コードの可読性と保守性を最優先する
2. 型安全性を確保し、any型の使用を避ける
3. パフォーマンスへの影響を考慮する
4. セキュリティ上の問題を指摘する
</guidelines>

<output_format>
レビュー結果は以下の形式で出力してください：
- 問題の重要度（Critical / High / Medium / Low）
- 該当箇所（ファイル名と行番号）
- 問題の説明
- 修正案
</output_format>
</system>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# RAGパイプラインの概念的な実装
def build_context(user_query: str, max_tokens: int = 4000) -> str:
    # 1. クエリをベクトル化
    query_embedding = embed(user_query)
    
    # 2. 関連ドキュメントを検索
    relevant_docs = vector_db.search(
        query_embedding,
        top_k=5,
        threshold=0.7
    )
    
    # 3. トークン数を考慮してコンテキストを構築
    context_parts = []
    current_tokens = 0
    
    for doc in relevant_docs:
        doc_tokens = count_tokens(doc.content)
        if current_tokens + doc_tokens <= max_tokens:
            context_parts.append(f"<document source=\"{doc.source}\">\n{doc.content}\n</document>")
            current_tokens += doc_tokens
        else:
            break
    
    return "\n".join(context_parts)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
  "name": "search_codebase",
  "description": "プロジェクト内のソースコードを検索します。ファイル名、関数名、クラス名、変数名、コメントを対象に全文検索を実行します。検索結果は関連度順にソートされます。",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "検索キーワード。複数語の場合はスペース区切りでAND検索"
      },
      "file_pattern": {
        "type": "string",
        "description": "対象ファイルのglobパターン（例: '*.ts', 'src/**/*.tsx'）"
      },
      "max_results": {
        "type": "integer",
        "description": "取得する最大件数（デフォルト: 10）",
        "default": 10
      }
    },
    "required": ["query"]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class ConversationManager:
    def __init__(self, max_tokens: int = 128000):
        self.max_tokens = max_tokens
        self.messages = []
        self.summary = ""
    
    def add_message(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})
        self._compact_if_needed()
    
    def _compact_if_needed(self):
        total_tokens = self._count_total_tokens()
        
        if total_tokens > self.max_tokens * 0.8:
            # 古いメッセージを要約に圧縮
            old_messages = self.messages[:-10]  # 最新10件は保持
            
            summary_prompt = f"""
以下の会話履歴を簡潔に要約してください。
重要な決定事項、コンテキスト、未解決の問題を含めてください。

{self._format_messages(old_messages)}
"""
            self.summary = self._generate_summary(summary_prompt)
            self.messages = self.messages[-10:]
    
    def get_context(self) -> list:
        context = []
        if self.summary:
            context.append({
                "role": "system",
                "content": f"<conversation_summary>\n{self.summary}\n</conversation_summary>"
            })
        context.extend(self.messages)
        return context

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<project_context>
プロジェクト: ECサイトのバックエンドAPI
技術スタック:
- Node.js 20 + TypeScript 5.3
- NestJS 10
- PostgreSQL 15 + Prisma ORM
- Jest（テスト）

コーディング規約:
- 関数名はcamelCase
- 型定義は interface を優先（type は複合型のみ）
- エラーはカスタム例外クラスで処理
- すべての公開メソッドにJSDocコメント必須

ディレクトリ構造:
src/
├── modules/        # 機能モジュール
│   └── [module]/
│       ├── dto/
│       ├── entities/
│       ├── [module].controller.ts
│       ├── [module].service.ts
│       └── [module].module.ts
├── common/         # 共通ユーティリティ
└── config/         # 設定ファイル
</project_context>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<reference_implementation>
以下は既存のUserServiceの実装です。同じパターンでOrderServiceを実装してください。

```typescript
// src/modules/user/user.service.ts
@Injectable()
export class UserService {
  constructor(private readonly prisma: PrismaService) {}

  /**
   * ユーザーを作成します
   * @param dto ユーザー作成DTO
   * @returns 作成されたユーザー
   * @throws ConflictException メールアドレスが既に存在する場合
   */
  async create(dto: CreateUserDto): Promise<User> {
    const existing = await this.prisma.user.findUnique({
      where: { email: dto.email },
    });
    
    if (existing) {
      throw new ConflictException('Email already exists');
    }
    
    return this.prisma.user.create({
      data: {
        ...dto,
        password: await hash(dto.password, 10),
      },
    });
  }
}
\`\`\`
</reference_implementation>

<task>
注文管理機能（OrderService）を実装してください。
- 注文の作成（create）
- 注文の取得（findById）
- ユーザー別注文一覧（findByUserId）
- 注文ステータスの更新（updateStatus）
</task>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<debug_context>
<error_message>
TypeError: Cannot read properties of undefined (reading 'map')
    at OrderService.findByUserId (order.service.ts:45:32)
    at OrderController.getUserOrders (order.controller.ts:28:35)
</error_message>

<related_code file="order.service.ts" lines="40-50">
async findByUserId(userId: string): Promise<Order[]> {
  const user = await this.prisma.user.findUnique({
    where: { id: userId },
    include: { orders: true },
  });
  
  return user.orders.map(order => ({  // Line 45: エラー発生箇所
    ...order,
    formattedTotal: this.formatCurrency(order.total),
  }));
}
</related_code>

<test_input>
userId: "non-existent-user-id"
</test_input>
</debug_context>

<task>
上記のエラーの原因を特定し、修正案を提示してください。
</task>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def prioritize_context(items: list, max_tokens: int) -> list:
    """重要度スコアに基づいてコンテキストアイテムを選択"""
    # 重要度でソート（降順）
    sorted_items = sorted(items, key=lambda x: x.importance, reverse=True)
    
    selected = []
    current_tokens = 0
    
    for item in sorted_items:
        if current_tokens + item.tokens <= max_tokens:
            selected.append(item)
            current_tokens += item.tokens
    
    return selected

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def filter_by_relevance(documents: list, query: str, threshold: float = 0.5) -> list:
    """意味的類似度に基づいて関連ドキュメントをフィルタリング"""
    query_embedding = embed(query)
    
    relevant = []
    for doc in documents:
        similarity = cosine_similarity(query_embedding, doc.embedding)
        if similarity >= threshold:
            relevant.append((doc, similarity))
    
    return [doc for doc, _ in sorted(relevant, key=lambda x: x[1], reverse=True)]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# キャッシュ効率を高める構成
def build_request(user_input: str) -> dict:
    return {
        # キャッシュされやすい部分（前方に配置）
        "system": STATIC_SYSTEM_PROMPT,  # 変更頻度が低い
        "context": [
            PROJECT_CONTEXT,              # プロジェクト情報
            CODING_STANDARDS,             # コーディング規約
        ],
        # 動的な部分（後方に配置）
        "messages": [
            {"role": "user", "content": user_input}
        ]
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 悪い例
<context>
プロジェクトの全ファイル一覧（1000件）
全データベーステーブルのスキーマ
過去1年分のコミット履歴
...（省略）...
</context>

# 良い例
<context>
<relevant_files>
- src/services/order.service.ts（編集対象）
- src/types/order.types.ts（参照する型定義）
</relevant_files>
<relevant_schema>
orders, order_items テーブルのみ
</relevant_schema>
</context>

1
2
3
4
5
6
7

# 悪い例
System: 必ずJSON形式で回答してください
User: Markdown形式で結果を整形してください

# 良い例
System: 出力形式はユーザーの指示に従ってください
User: 結果をJSON形式で出力してください

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 悪い例
<types>型定義A</types>
<other_info>無関係な情報</other_info>
<implementation>型Aを使う実装</implementation>

# 良い例
<feature_a>
  <types>型定義A</types>
  <implementation>型Aを使う実装</implementation>
</feature_a>