長文ドキュメント要約Prompt戦略完全ガイド：Map-Reduce vs Stuff vs Refine

こんにちは、HolySheep AI公式技術ブログへようこそ。私は普段、每月数百件のドキュメント要約を自動処理するシステム構築を担当しています。本日は、AI-API初心者のために、長文ドキュメントを効率的に要約する3つの代表的なPrompt戦略を、実際のコード例とともに丁寧に解説いたします。

本記事读完後、あなたは以下ことが雰囲できるようになります：

3つの要約戦略の違いと使い分けを理解できる
HolySheep AIを使って最安値で高品质な要約を実現できる
よくあるエラーを回避し、実務にすぐ適用できる

なぜ長文要約は特別な戦略が必要なのか

AIモデルのコンテキストウィンドウには限りがあります。たとえばGPT-4oでも128Kトークン、Claude 3.5 Sonnetは200Kトークンが上限です。数百ページのPDFや長い報告書、複数のメールスレッドを一度に処理しようとすると、「コンテキスト長超過」という壁にぶつかりがちです。

ここで活躍するのが、本日ご紹介する3つのPrompt戦略です。これらは、大量のテキストを「分割→処理→統合」という流程で効果的に扱うための設計パターンになります。

3つのPrompt戦略の概要

戦略	処理方式	的优点	缺点	向いている場面
Stuff	全文を1度に投入	简单、実装かんとい	コンテキスト長限制あり	短〜中程度の文書
Map-Reduce	分割→並列要約→統合	長い文書に対応	処理時間が長い	長いレポート、多的ファイル
Refine	段階的细化	一貫性のある高品质出力	コストがやや高い	高品质が求められる場面

前提準備：HolySheep AIの始め方

まず、今すぐ登録してAPIキーを取得してください。HolySheep AIは2026年現在の価格表で最も經濟的な选择で、Gemini 2.5 Flashは$2.50/MTok、DeepSeek V3.2更是$0.42/MTokという破格の安さを提供しています。新規登録者には無料クレジットがプレゼントされるため、気軽に实验を始めることができます。

また、レートは¥1=$1（公式¥7.3=$1の85%節約）であり、WeChat PayやAlipayにも対応しています。APIレイテンシは<50msと高速なため、实时処理にも耐えられます。

戦略1：Stuff（スタッフ）— 最も简单な方法

基本的な考え方

Stuff戦略は、最もシンプルなアプローチです。ドキュメント全体を一度のAPIリクエストで送信し、要約を生成させます。代码量が少なく、実装がかんたんなため、初心者にぴったりの方法です。

コード例：Pythonでの実装

import requests
import json

def summarize_with_stuff(document_text, api_key):
    """
    Stuff戦略：ドキュメント全体を1度に要約
    """
    url = "https://api.holysheep.ai/v1/chat/completions"
    
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    # プロンプト設計：简洁な要約指示
    system_prompt = """あなたは专业的なドキュメント要約エキスパートです。
    入力された文章を简潔に、要点を漏らさず要約してください。
    構成：1) 主要な论点、2) 重要なデータ・事实、3) 結論"""
    
    data = {
        "model": "gpt-4o",  # または "claude-sonnet-4", "gemini-2.5-flash"
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"以下のドキュメントを要約してください：\n\n{document_text}"}
        ],
        "temperature": 0.3,
        "max_tokens": 1000
    }
    
    response = requests.post(url, headers=headers, json=data)
    
    if response.status_code == 200:
        return response.json()["choices"][0]["message"]["content"]
    else:
        raise Exception(f"APIエラー: {response.status_code} - {response.text}")

使用例
api_key = "YOUR_HOLYSHEEP_API_KEY"
with open("document.txt", "r", encoding="utf-8") as f:
    doc = f.read()

10,000トークン以下の文書に適しています
summary = summarize_with_stuff(doc, api_key)
print(summary)

向いている人・向いていない人

向いている人

API编程が初めての人
10,000トークン以下の短い〜中程度の文書処理
简易なプロトタイプを快速に作りたい人
コストを最低限に抑えたい人

向いていない人

100ページ以上の長い報告書
リアルタイム性が求められる処理
コンテキスト長を超える文書

戦略2：Map-Reduce（マップリダース）— 並列処理の名人

基本的な考え方

Map-Reduceは、その名前が示すように2つのフェーズで構成されます。Map（映射）フェーズでは、ドキュメントを小さなチャンクに分割し、それぞれを並列で要約します。Reduce（缩小）フェーズでは、これらの部分要約を統合して最终的な要約を生成します。

コード例：Pythonでの実装

import requests
import json
import os
from concurrent.futures import ThreadPoolExecutor, as_completed

class MapReduceSummarizer:
    """
    Map-Reduce戦略の実装
    長いドキュメントを分割→並列要約→統合
    """
    
    def __init__(self, api_key, model="gpt-4o"):
        self.api_key = api_key
        self.model = model
        self.url = "https://api.holysheep.ai/v1/chat/completions"
    
    def _call_api(self, messages, temperature=0.3, max_tokens=500):
        """単一のAPIコールを実行"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        data = {
            "model": self.model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        response = requests.post(self.url, headers=headers, json=data)
        
        if response.status_code != 200:
            raise Exception(f"API Error {response.status_code}: {response.text}")
        
        return response.json()["choices"][0]["message"]["content"]
    
    def _split_document(self, text, chunk_size=3000, overlap=200):
        """
        ドキュメントをオーバーラップ付きで分割
        chunk_size: 各チャンクの文字数（约500-1000トークン）
        """
        chunks = []
        start = 0
        
        while start < len(text):
            end = start + chunk_size
            chunks.append(text[start:end])
            start = end - overlap  # オーバーラップで文の途切れを防ぐ
        
        return chunks
    
    def _map_step(self, chunk, summary_instructions):
        """Mapフェーズ：各チャンクを要約"""
        messages = [
            {"role": "system", "content": "あなたは简潔な要約エキスパートです。与えられたテキストの要点を简潔にまとめてください。"},
            {"role": "user", "content": f"{summary_instructions}\n\n以下の部分を要約してください：\n\n{chunk}"}
        ]
        
        return self._call_api(messages, max_tokens=300)
    
    def _reduce_step(self, partial_summaries):
        """Reduceフェーズ：部分要約を統合"""
        combined = "\n\n---\n\n".join(partial_summaries)
        
        messages = [
            {"role": "system", "content": """あなたは文档統合エキスパートです。
            複数の部分要約を1つの首尾一貫した要約に統合してください。
            重複を排除し、论理的な流れを作ってくだよい。"""},
            {"role": "user", "content": f"以下の部分要約を統合して、最终的な要約を作成してください：\n\n{combined}"}
        ]
        
        return self._call_api(messages, temperature=0.4, max_tokens=1500)
    
    def summarize(self, document_text, summary_instructions="主要な论点、重要なポイント、結論を举げて"):
        """
        Map-Reduce戦略でドキュメント要約を実行
        """
        print("📄 ドキュメントを分割中...")
        chunks = self._split_document(document_text)
        print(f"   {len(chunks)}個のチャンクに分割しました")
        
        # Mapフェーズ：並列処理で各チャンクを要約
        print("🔄 各チャンクを並列要約中...")
        partial_summaries = []
        
        with ThreadPoolExecutor(max_workers=5) as executor:
            future_to_idx = {
                executor.submit(self._map_step, chunk, summary_instructions): idx
                for idx, chunk in enumerate(chunks)
            }
            
            for future in as_completed(future_to_idx):
                idx = future_to_idx[future]
                try:
                    summary = future.result()
                    partial_summaries.append((idx, summary))
                    print(f"   チャンク {idx + 1}/{len(chunks)} 完了")
                except Exception as e:
                    print(f"   チャンク {idx + 1} エラー: {e}")
        
        # 顺序を维持して結合
        partial_summaries.sort(key=lambda x: x[0])
        ordered_summaries = [s for _, s in partial_summaries]
        
        # Reduceフェーズ：統合
        print("📝 部分要約を統合中...")
        final_summary = self._reduce_step(ordered_summaries)
        
        return final_summary


使用例
api_key = "YOUR_HOLYSHEEP_API_KEY"
summarizer = MapReduceSummarizer(api_key, model="gemini-2.5-flash")  # $2.50/MTokで経済的

with open("long_report.txt", "r", encoding="utf-8") as f:
    report = f.read()

summary = summarizer.summarize(report)
print("\n===== 最终要約 =====")
print(summary)

向いている人・向いていない人

向いている人

50ページ以上の長いレポート
複数のファイルを同時に処理したい人
処理速度を重視する場面
並列処理によるコスト最適化が必要な人

向いていない人

文脈の连贯性が非常に重要な場面
非常に短い文書の処理（オーバーヘッドが大きい）
リアルタイムのストリーミング出力を必要とする人

戦略3：Refine（リファイン）— 高品質な段階的処理

基本的な考え方

Refine戦略は、蓮坂的にドキュメントを处理しながら、要約を次第に细化していくアプローチです。各チャンクを顺次に处理し、前のチャンクで生成された要約に新しいチャンクの 정보를追加・更新していきます。これにより、文脈の连贯性を保ちながら高品质な要約を実現できます。

コード例：Pythonでの実装

import requests
import time

class RefineSummarizer:
    """
    Refine戦略の実装
    段階的に要約を细化していくアプローチ
    """
    
    def __init__(self, api_key, model="claude-sonnet-4"):
        self.api_key = api_key
        self.model = model
        self.url = "https://api.holysheep.ai/v1/chat/completions"
        self.chunk_count = 0
    
    def _call_api(self, messages, temperature=0.3, max_tokens=800):
        """APIコールを実行"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        data = {
            "model": self.model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        response = requests.post(self.url, headers=headers, json=data)
        
        if response.status_code != 200:
            raise Exception(f"API Error {response.status_code}: {response.text}")
        
        return response.json()["choices"][0]["message"]["content"]
    
    def _split_into_chunks(self, text, chunk_size=2500):
        """ドキュメントを分割"""
        words = text.split()
        chunks = []
        current_chunk = []
        current_length = 0
        
        for word in words:
            current_length += len(word) + 1
            if current_length > chunk_size:
                chunks.append(' '.join(current_chunk))
                current_chunk = [word]
                current_length = len(word)
            else:
                current_chunk.append(word)
        
        if current_chunk:
            chunks.append(' '.join(current_chunk))
        
        return chunks
    
    def _refine_iteration(self, current_summary, new_chunk):
        """1回の细化イテレーション"""
        self.chunk_count += 1
        
        messages = [
            {"role": "system", "content": """あなたは文档要約のエキスパートです。
            既存の要約に新しい情報を внимательно統合してください。
            
            指示：
            1. 既存の要約优点を確認し、维持
            2. 新しいチャンクから重要な 정보를追加
            3. 矛盾があれば適切に调整
            4. 不要な重複を排除
            5. 首尾一貫した文章にまとめる"""},
            {"role": "user", "content": f"""既存の要約：
---
{current_summary}
---

新しいチャンク：
---
{new_chunk}
---

上記の既存要約を新しいチャンクの情報で细化・更新してください。""" }
        ]
        
        # レイテンシ測定のため処理开始時刻を記録
        start_time = time.time()
        
        new_summary = self._call_api(messages, temperature=0.3, max_tokens=1000)
        
        elapsed = (time.time() - start_time) * 1000
        print(f"   イテレーション {self.chunk_count} 完了 ({elapsed:.0f}ms)")
        
        return new_summary
    
    def summarize(self, document_text, initial_prompt=None):
        """
        Refine戦略で要約を実行
        """
        print("🔄 Refine戦略で要約を開始...")
        
        # 初期要約または初期プロンプト
        if initial_prompt:
            current_summary = initial_prompt
        else:
            initial_messages = [
                {"role": "system", "content": "あなたは简潔な要約エキスパートです。与えられたテキストの主要な论点、重要なポイント、结论を简洁にまとめてください。"},
                {"role": "user", "content": f"以下のテキストを简単に要約してください：\n\n{document_text[:3000]}"}
            ]
            current_summary = self._call_api(initial_messages)
            print("   初期要約を生成しました")
        
        # ドキュメントを分割
        chunks = self._split_into_chunks(document_text)
        print(f"   {len(chunks)}個のチャンクに分割")
        
        # 最初のチャンクは初期要約に済み済みのため、残りを处理
        for i, chunk in enumerate(chunks[1:], 1):
            print(f"\n   --- チャンク {i + 1}/{len(chunks)} ---")
            current_summary = self._refine_iteration(current_summary, chunk)
            time.sleep(0.1)  # レートリミット対策
        
        return current_summary


使用例
api_key = "YOUR_HOLYSHEEP_API_KEY"
refiner = RefineSummarizer(api_key, model="claude-sonnet-4")  # 高品质出力

with open("annual_report.txt", "r", encoding="utf-8") as f:
    annual_report = f.read()

print("=" * 50)
print("処理開始時刻:", time.strftime("%Y-%m-%d %H:%M:%S"))
print("=" * 50)

final_summary = refiner.summarize(annual_report)

print("=" * 50)
print("処理完了 - 最终要約：")
print(final_summary)
print("=" * 50)

向いている人・向いていない人

向いている人

高品质な要約を求める人
文脈の完全性が重要な場面
长いドキュメントで首尾一貫した出力を必要とする人
報告書や论文の要約

向いていない人

fastest处理速度が必要な場面
预算が严格に制限されている人
非常に简单なタスク

3戦略の比較まとめ

評価轴	Stuff	Map-Reduce	Refine
実装难度	⭐ 簡単	⭐⭐⭐ 中程度	⭐⭐⭐⭐ やや复杂
処理速度	⭐⭐⭐⭐⭐ 最速	⭐⭐⭐⭐ 高速（並列）	⭐⭐ 逐次処理
要約品質	⭐⭐⭐ 普通	⭐⭐⭐ 良好	⭐⭐⭐⭐⭐ 最高
コスト効率	⭐⭐⭐ 普通	⭐⭐⭐⭐ 良好	⭐⭐ やや高い
長文対応	❌ 不可（<10Kトークン）	✅ 可能（无制限）	✅ 可能
文脈连贯性	⭐⭐⭐⭐⭐ 最高	⭐⭐⭐ 良好	⭐⭐⭐⭐⭐ 最高

HolySheep AIを選ぶ理由

この3つの戦略を实务に適用するなら、APIプロバイダーとしてHolySheep AIをお勧めします有以下理由：

価格とROI

モデル	2026年価格(/MTok)	Stuff処理の例	Map-Reduce処理の例
GPT-4.1	$8.00	約$0.008/文書	約$0.04/文書
Claude Sonnet 4.5	$15.00	約$0.015/文書	約$0.075/文書
Gemini 2.5 Flash	$2.50	約$0.0025/文書	約$0.0125/文書
DeepSeek V3.2	$0.42	約$0.0004/文書	約$0.002/文書

экономи的观奵：DeepSeek V3.2を使用すれば、Map-Reduce戦略でも1文書あたり約$0.002（约0.3円）と极めて低コスト。月間1,000文書の處理でも约300円、月間10,000文書でも约3,000円で運用可能です。

その他のメリット

為替レート：¥1=$1で、公式¥7.3=$1と比べて85%節約
支払い方法：WeChat Pay、Alipay、国内送金対応
高速响应：<50msのレイテンシでリアルタイム処理が可能
免费クレジット：新規登録で無料クレジット付与
高い可用性：GPT-4o、Claude 3.5、Gemini、DeepSeekなど主要モデルに対応

実装のコツとベストプラクティス

チャンクサイズの选择

Map-ReduceとRefineでは、チャンクサイズの设定が重要です。一般的に：

推奨サイズ：2,000〜4,000文字（约500〜1,000トークン）
オーバーラップ：200〜500文字で文の分割を防止
注意：モデルによって最大トークン数が異なるため、事前に确认

プロンプトの细化

# 効果的な要約プロンプトの例

SYSTEM_PROMPT = """あなたは专业的ドキュメント要約エキスパートです。
以下のルールに従って要約を作成してください：

1. 【構造】以下のセクション构成で出力：
   - エグゼクティブサマリー（3文以内）
   - 主要な论点（箇条書き、3〜5項目）
   - 重要なデータ・事实（数值を含む）
   - 结论と建议

2. 【约束】
   - 原文の意図を正確に伝える
   - 自分の意见を加えない
   - 専門用語は適切に説明
   - 文字数は元の20〜30%程度

3. 【出力形式】
   - マークダウン形式
   - 重要部分是太字
   -  Појединаの观奵があれば明記"""

USER_PROMPT_TEMPLATE = """以下のドキュメントを上記ルールに従って要約してください。

【文档タイプ】：{doc_type}
【意図的な焦点】：{focus_area}

{document_content}"""

よくあるエラーと対処法

エラー1：コンテキスト長超過（Maximum Context Length Exceeded）

# ❌ 错误な実装例
messages = [
    {"role": "user", "content": very_long_text}  # 全体の代わりに
]

✅ 正しい実装例
def split_and_summarize(text, api_key):
    # 文字数ベースで分割（便宜上1万文字씩）
    chunks = [text[i:i+10000] for i in range(0, len(text), 10000)]
    
    # 各チャンクを处理
    summaries = []
    for chunk in chunks:
        messages = [
            {"role": "system", "content": "简単に要約してください。"},
            {"role": "user", "content": f"要約：{chunk}"}
        ]
        # API呼び出し...
        summary = call_api(messages, api_key)
        summaries.append(summary)
    
    return "\n\n".join(summaries)

原因：ドキュメントがモデルのコンテキストウィンドウを超えている

解決：Map-Reduce戦略，采用してドキュメントを分割处理

エラー2：APIキー認証失败（401 Unauthorized）

# ❌ 错误な実装例
headers = {
    "Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY"  # 定数文字列
}

✅ 正しい実装例
import os

API_KEY = os.environ.get("HOLYSHEEP_API_KEY")  # 環境変数から取得
または
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # 直接代入（開発时のみ）

def call_api(api_key, messages):
    headers = {
        "Authorization": f"Bearer {api_key}",  # 变量を正しく参照
        "Content-Type": "application/json"
    }
    # ...

原因：APIキーが正しく設定されていない、または过期

解決：HolySheep AIで新しいAPIキーを生成し、正しく环境変数に設定

エラー3：レートリミット（429 Too Many Requests）

# ❌ 错误な実装例：レート制限を考慮しない
for document in documents:
    summarize(document)  # 连续呼叫でレート制限に抵触

✅ 正しい実装例：指数バックオフ付きリトライ
import time
from requests.exceptions import RequestException

def call_api_with_retry(url, headers, data, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=data)
            
            if response.status_code == 429:
                # レート制限時：指数バックオフ
                wait_time = 2 ** attempt + random.uniform(0, 1)
                print(f"レート制限待ち ({wait_time:.1f}秒)...")
                time.sleep(wait_time)
                continue
            
            return response
            
        except RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    
    raise Exception("最大リトライ回数を超过")

原因：短时间に过多的リクエストを送信

解決：リクエスト間に適切な延迟を挿入し、エラー時は指数バックオフでリトライ

エラー4：チャンク分割時の文章の途切れ

# ❌ 错误な実装例：简单な文字数分割
chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]

✅ 正しい実装例：文境界を考慮
import re

def smart_split(text, chunk_size):
    """文境界を尊重して分割"""
    # まず文章に分割
    sentences = re.split(r'(?<=[。！？.!?])', text)
    
    chunks = []
    current_chunk = []
    current_size = 0
    
    for sentence in sentences:
        sentence_size = len(sentence)
        
        if current_size + sentence_size > chunk_size and current_chunk:
            chunks.append(''.join(current_chunk))
            # 前の文の后半を次のチャンクの冒頭に追加（オーバーラップ）
            overlap_text = ''.join(current_chunk)[-200:]
            current_chunk = [overlap_text, sentence]
            current_size = len(overlap_text) + sentence_size
        else:
            current_chunk.append(sentence)
            current_size += sentence_size
    
    if current_chunk:
        chunks.append(''.join(current_chunk))
    
    return chunks

原因：単語や文の途中で分割，导致情報の损失

解決：正規表現で文境界を检测し、オーバーラップ付きで分割

まとめと導入提案

长文ドキュメント要約の3つのPrompt戦略を学べるました。总结如下：

Stuff：短〜中程度の文書に最適。简单・高速・低コスト
Map-Reduce：長い文書や複数ファイルの處理に最適。并列処理で高速
Refine：最高品质な要約が必要な場面に最適。段階的细化で一贯性保证

实务では、文档の長さ・品质要件・コスト制約に応じて、これらの戦略を适度に组合せてご利用いただくことをお勧めします。

立即行动

本記事の内容を実際に试してみるには、HolySheep AI に登録して無料クレジットを獲得してください。DeepSeek V3.2なら$0.42/MTok、Gemini 2.5 Flashは$2.50/MTokと非常に經濟的に始められます。

注册後、以下のステップで立即実践できます：

APIキーをダッシュボードから取得
本記事のサンプルコードをコピー
YOUR_HOLYSHEEP_API_KEYを置换
テストドキュメントで动作确认

HolySheep AIなら、レート¥1=$1（85%節約）・WeChat Pay/Alipay対応・<50msレイテンシで、API初心者のあなたでもすぐに高质量なドキュメント要約システムを構築できます。

👉 HolySheep AI に登録して無料クレジットを獲得

なぜ長文要約は特別な戦略が必要なのか

3つのPrompt戦略の概要

前提準備：HolySheep AIの始め方

戦略1：Stuff（スタッフ）— 最も简单な方法

基本的な考え方

コード例：Pythonでの実装

使用例

10,000トークン以下の文書に適しています

向いている人・向いていない人

向いている人

向いていない人

戦略2：Map-Reduce（マップリダース）— 並列処理の名人

基本的な考え方

コード例：Pythonでの実装

使用例

向いている人・向いていない人

向いている人

向いていない人

戦略3：Refine（リファイン）— 高品質な段階的処理

基本的な考え方

コード例：Pythonでの実装

使用例

向いている人・向いていない人

向いている人

向いていない人

3戦略の比較まとめ

HolySheep AIを選ぶ理由

価格とROI

その他のメリット

実装のコツとベストプラクティス

チャンクサイズの选择

プロンプトの细化

よくあるエラーと対処法

エラー1：コンテキスト長超過（Maximum Context Length Exceeded）

✅ 正しい実装例

エラー2：APIキー認証失败（401 Unauthorized）

✅ 正しい実装例

または

エラー3：レートリミット（429 Too Many Requests）

✅ 正しい実装例：指数バックオフ付きリトライ

エラー4：チャンク分割時の文章の途切れ

✅ 正しい実装例：文境界を考慮

まとめと導入提案

立即行动

関連リソース

関連記事

🔥 HolySheep AIを使ってみる