token-optimization

トークン最適化

googleadsagent.ai™によるAgent Skills™の一部です

説明

トークン最適化とは、出力品質を損なうことなく、エージェントの操作全体でトークン消費量を体系的に削減することです。本番環境のAIシステムでは、トークンはコストとレイテンシの両方を左右する基本単位です。不要なトークンが増えるたびに、API料金が上がり、応答時間も遅くなります。このスキルでは、Everything Claude Code エコシステム（15万以上のスター）とgoogleadsagent.ai™の本番プラットフォームで使われている最適化手法をまとめています。このプラットフォームでは、Buddy™が厳しいコスト予算内で、毎日数千件の Google Ads 分析を処理しています。

最適化の対象は、モデル選択（タスクの複雑さに応じたモデルの能力とコストの調整）、プロンプト圧縮（指示の忠実性を保ちながら冗長なトークンを削減）、バックグラウンド処理（コストの高い操作を非同期ワークフローに移行）、キャッシュ（同一または類似した入力に対する重複計算の回避）の4つの領域にわたります。4つすべての領域を導入した本番システムでは、一般に、単純な実装と比べてトークンコストを60～80％削減できます。

トークン最適化は、単にコストを切り詰めることではなく、効率を高めることです。冗長なシステムプロンプトや重複するツール出力にトークンを浪費するエージェントは、コストがかさむだけでなく、コンテキストウィンドウを早く使い切り、実際の推論に使える余地も減らします。最適化によって、経済性と品質の両方を同時に向上できます。

使用する場面

• AI エージェントの運用にかかる月間 API コストが予算目標を超えている場合
• ユーザー向けエージェントの応答レイテンシが許容範囲を超えている場合
• 複雑なタスクが完了する前にコンテキストウィンドウがいっぱいになる場合
• 複数のモデル階層が利用でき、インテリジェントなルーティングが必要な場合
• バッチ処理のワークロードで大量のトークンが発生する場合
• コストを比例して増やすことなく、エージェントの利用を拡大したい場合

仕組み

graph TD
    A[Incoming Task] --> B[Complexity Classifier]
    B -->|Simple| C[Fast Model<br/>Haiku/Flash]
    B -->|Medium| D[Balanced Model<br/>Sonnet/GPT-4o]
    B -->|Complex| E[Premium Model<br/>Opus/o1]
    C --> F[Prompt Compressor]
    D --> F
    E --> F
    F --> G{Cache Hit?}
    G -->|Yes| H[Return Cached Result]
    G -->|No| I[Execute with Budget]
    I --> J[Cache Result]
    J --> K[Response]
    H --> K
    I --> L{Background Eligible?}
    L -->|Yes| M[Async Queue]
    M --> I
    L -->|No| I

タスクは複雑さ分類器を通じて処理され、適切なモデル階層にルーティングされます。プロンプト圧縮機能は冗長な内容を取り除き、冗長な指示を短縮し、説明文を構造化形式に置き換えます。キャッシュ層は、繰り返しのクエリやほぼ同一のクエリを受け取ります。バックグラウンド処理が可能なタスク（対話を伴わない分析、バッチ処理）は、ピーク時間外に非同期処理するためにキューに入れられます。各段階でトークン予算が適用され、操作ごとの消費量に上限が設定されます。

実装

タスク複雑さ分類器：

class ComplexityClassifier:
    THRESHOLDS = {
        "simple": {"max_tokens": 500, "patterns": ["summarize", "format", "list", "count"]},
        "medium": {"max_tokens": 2000, "patterns": ["analyze", "compare", "explain", "review"]},
        "complex": {"max_tokens": 8000, "patterns": ["architect", "refactor", "debug", "optimize"]},
    }

    def classify(self, task: str) -> str:
        task_lower = task.lower()
        scores = {}
        for level, config in self.THRESHOLDS.items():
            score = sum(1 for p in config["patterns"] if p in task_lower)
            scores[level] = score

        if scores["complex"] > 0:
            return "complex"
        if scores["medium"] > 0:
            return "medium"
        return "simple"

    def select_model(self, complexity: str) -> dict:
        models = {
            "simple": {"name": "claude-haiku", "cost_per_1k": 0.00025, "max_tokens": 1024},
            "medium": {"name": "claude-sonnet", "cost_per_1k": 0.003, "max_tokens": 4096},
            "complex": {"name": "claude-opus", "cost_per_1k": 0.015, "max_tokens": 8192},
        }
        return models[complexity]

プロンプト圧縮エンジン：

class PromptCompressor:
    REPLACEMENTS = [
        (r"\s+", " "),
        (r"Please note that ", ""),
        (r"It is important to ", ""),
        (r"Make sure to ", ""),
        (r"You should ", ""),
        (r"In order to ", "To "),
        (r"At this point in time", "Now"),
    ]

    def compress(self, prompt: str, target_reduction: float = 0.3) -> str:
        compressed = prompt
        for pattern, replacement in self.REPLACEMENTS:
            compressed = re.sub(pattern, replacement, compressed)

        original_tokens = count_tokens(prompt)
        compressed_tokens = count_tokens(compressed)
        reduction = 1 - (compressed_tokens / original_tokens)

        if reduction < target_reduction:
            compressed = self.structural_compress(compressed, target_reduction)

        return compressed.strip()

    def structural_compress(self, text: str, target: float) -> str:
        lines = text.split("\n")
        scored = [(line, self.line_importance(line)) for line in lines]
        scored.sort(key=lambda x: x[1], reverse=True)

        result = []
        tokens = 0
        budget = int(count_tokens(text) * (1 - target))
        for line, score in scored:
            line_tokens = count_tokens(line)
            if tokens + line_tokens <= budget:
                result.append(line)
                tokens += line_tokens
        return "\n".join(result)

    def line_importance(self, line: str) -> float:
        if line.strip().startswith("#"):
            return 1.0
        if any(kw in line.lower() for kw in ["must", "required", "never", "always"]):
            return 0.9
        if line.strip().startswith("-") or line.strip().startswith("*"):
            return 0.7
        return 0.5

セマンティックキャッシュ層：

import { createHash } from "crypto";

interface CacheEntry {
  result: string;
  timestamp: number;
  tokens_saved: number;
  model: string;
}

class SemanticCache {
  private cache: Map<string, CacheEntry> = new Map();
  private ttlMs: number;
  private totalSaved = 0;

  constructor(ttlMinutes = 60) {
    this.ttlMs = ttlMinutes * 60 * 1000;
  }

  private keyFor(prompt: string, model: string): string {
    const normalized = prompt.toLowerCase().replace(/\s+/g, " ").trim();
    return createHash("sha256").update(`${model}:${normalized}`).digest("hex").slice(0, 32);
  }

  get(prompt: string, model: string): CacheEntry | null {
    const key = this.keyFor(prompt, model);
    const entry = this.cache.get(key);
    if (!entry) return null;
    if (Date.now() - entry.timestamp > this.ttlMs) {
      this.cache.delete(key);
      return null;
    }
    this.totalSaved += entry.tokens_saved;
    return entry;
  }

  set(prompt: string, model: string, result: string, tokensUsed: number): void {
    const key = this.keyFor(prompt, model);
    this.cache.set(key, {
      result,
      timestamp: Date.now(),
      tokens_saved: tokensUsed,
      model,
    });
  }

  stats(): { entries: number; totalTokensSaved: number } {
    return { entries: this.cache.size, totalTokensSaved: this.totalSaved };
  }
}

ベストプラクティス

1. 最適化の前に測定する — システムプロンプト、ユーザーメッセージ、ツールの結果、生成など、操作の種類ごとにトークン使用量を計測し、効果の大きい最適化対象を特定します。
2. モデルの規模を適切にする — 単純なタスク（書式設定、要約）には高速で低コストのモデルを使い、複雑な推論には高コストのモデルを使います。ほとんどのタスクで、最も高性能なモデルは必要ありません。
3. システムプロンプトを積極的に圧縮する — システムプロンプトはリクエストのたびに送信されるため、ここで30％圧縮すれば、呼び出しのたびに効果が得られます。
4. セマンティックレベルでキャッシュする — 完全一致キャッシュは重複を検出し、セマンティック類似性キャッシュは、同一の結果を生成するほぼ同一の入力を検出します。
5. 操作ごとにトークン予算を設定する — 厳格な上限を設けることで、予想外に冗長なモデル出力や循環するツール呼び出しによるコストの急増を防ぎます。
6. 文章より構造化形式を優先する — JSON や YAML は、自然言語の説明よりも1トークンあたりの情報量が多くなります。
7. ツール出力を適切に切り詰める — API の応答全体ではなく、モデルに必要なフィールドだけを返します。Google Ads API の応答は、必要なフィールドを選択的に抽出することで、5万トークンから2千トークンに削減できます。
8. タスクの成功あたりのコストを監視する — 生のトークン使用量だけでなく、完了したタスクあたりのトークン数も追跡し、再試行や失敗の影響も把握します。

プラットフォームの互換性

機能	Claude Code	Cursor	Codex	Gemini CLI
モデルのルーティング	✅ --model flag	✅ Model selector	✅ Model config	✅ Model flag
プロンプトの圧縮	✅ Full	✅ Full	✅ Full	✅ Full
レスポンスのキャッシュ	✅ Custom	✅ Custom	✅ Custom	✅ Context caching
バックグラウンドタスク	✅ Subagents	✅ Subagents	✅ Async	✅ Async
トークンの予算	✅ max_tokens	✅ max_tokens	✅ max_tokens	✅ max_tokens

関連スキル

• マルチモデルルーティング - モデルのルーティングは、トークンコスト削減に最も効果的な手法です
• ナレッジベースの注入 - Top-K パターンの選択により、過剰な注入によるコンテキストウィンドウの肥大化を防ぎます
• メモリの永続化 - メモリの注入予算は、現在のタスクに必要なコンテキストとのバランスを取る必要があります
• 予算の最適化 - 広告費の配分に類似した、コスト効率の最適化原則を適用します

キーワード

トークン最適化、コスト削減、モデルルーティング、プロンプト圧縮、キャッシュ、バッチ処理、トークン予算、モデル選択、レイテンシ最適化、エージェントスキル

---

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License