この記事の対象読者

LLMのAPIを触ったことがある方
AIの推論コストに課題を感じている方
Gemini 3シリーズのAPIパラメータを理解したい方

この記事で得られること

Thinking Levelの設計思想: なぜ「考える深さ」を制御するパラメータが必要なのか
LOW / MEDIUM / HIGHの使い分け: 用途別の最適解と、コストへの具体的なインパクト
Pythonでの実装方法: Thinking Level切り替えのコード例と、ルーティング戦略

この記事で扱わないこと

Gemini以外のモデル（Claude、GPTなど）の推論制御の詳細
Thinking Levelの内部アーキテクチャ（Transformer層の制御等）
ファインチューニングとの関係

1. Thinking Levelとの出会い

最初にGemini 3.1 ProのAPIを叩いたとき、私は何も考えずにデフォルト設定で使っていた。「Hello, World!」レベルのテストなのに、レスポンスが返ってくるまで妙に時間がかかる。しかもトークン使用量を見ると、出力の3倍近い「Thinking Token」が課金されている。

「え、"Hello"に返事するだけで、そんなに考える必要ある？」

調べてみてわかった。Gemini 3シリーズはデフォルトでThinking Level = HIGHが適用される。つまり、何も指定しないと最も深く、最もコストが高い推論モードで動く。簡単な質問でも、フルパワーで「考えて」しまうのだ。

Thinking Levelを一言で表すなら、「AIのギア」だ。車で言えば、街中を走るのにずっと1速全開で走っているようなもの。用途に応じてギアを変えれば、燃費（コスト）も走り心地（レイテンシ）も劇的に改善する。

ここまでで、Thinking Levelがどんなものか、なんとなくイメージできたでしょうか。次は、この記事で使う用語を整理しておきましょう。

2. 前提知識の確認

本題に入る前に、この記事で登場する用語を確認します。

2.1 Thinking Token（思考トークン）とは

AIモデルが「回答を出力する前に、内部で考えるために消費するトークン」のこと。ユーザーには見えないが、しっかり課金される。Googleの公式ドキュメントでは次のように説明されている。

Thinking models generate full thoughts to improve the quality of the final response, and then output summaries to provide insight into the thought process. Pricing is based on the full thought tokens the model needs to generate to create a summary, despite only the summary being output from the API.

つまり、ユーザーに見えるのは「考えた要約」だけだが、課金は「考えた全量」に対して発生する。これがThinking Level制御が重要な理由だ。

2.2 Thought Signature（思考署名）とは

Gemini 3シリーズで導入された、AIの推論状態を暗号化して保存する仕組み。複数回のAPI呼び出しにまたがるエージェント型ワークフローで、推論の文脈を維持するために使われる。ゲームで言う「セーブデータ」のようなものだと思ってほしい。前の推論ステップで考えた内容を、次のステップに正確に引き継げる。

2.3 Deep Think Miniとは

Gemini 3.1 ProのThinking Level = HIGHで発動する特別な推論モード。Google DeepMindの重量級推論モデル「Deep Think」のミニ版であり、ARC-AGI-2で77.1%を達成した推論能力の源泉。通常のHIGHモードよりもさらに深いChain-of-Thought分析を行う。

2.4 thinking_budgetとは

Gemini 2.5シリーズまで使われていた旧パラメータ。数値（トークン数）で推論の深さを指定する方式だった。Gemini 3以降では thinking_level（LOW/MEDIUM/HIGH）に置き換えられ、より直感的に制御できるようになった。両方を同時に指定するとHTTP 400エラーになるので、移行時は注意が必要だ。

これらの用語が押さえられたら、Thinking Levelの背景を見ていきましょう。

3. Thinking Levelが生まれた背景

3.1 「考えすぎ」問題の発見

2024年後半にOpenAIのo1モデルが「推論するLLM」の時代を開いた。しかし開発者はすぐに気づいた。推論モデルは賢いが、簡単なタスクでも全力で考えてしまい、コストとレイテンシが爆発する。「1+1は？」という質問に30秒かけて数学的証明を考え始めるような状態だ。

3.2 thinking_budgetの限界

Gemini 2.5シリーズでは thinking_budget パラメータで推論トークン数を直接指定できた。しかし「このタスクに何トークン必要か」を開発者が事前に見積もるのは至難の業だった。少なすぎれば品質が落ち、多すぎればコストが膨らむ。ちょうどいい数値を見つけるのは、体感温度でエアコンの設定温度を当てるようなものだ。

3.3 セマンティックレベルへの進化

Gemini 3シリーズで、Googleは数値指定から「意味的なレベル」への転換を決断した。LOW / MEDIUM / HIGHという抽象度の高いパラメータにすることで、開発者は「このタスクにはどのくらいの推論が必要か」という判断だけに集中できるようになった。Gemini 3.1 Proでは、さらにMEDIUMレベルが追加され、3段階の粒度になっている。

背景がわかったところで、基本的な仕組みを見ていきましょう。

4. 基本概念と仕組み

4.1 3つのThinking Level — 完全比較

項目	LOW	MEDIUM ★3.1新規	HIGH（デフォルト）
推論の深さ	最小限	バランス型	最大（Deep Think Mini発動）
レイテンシ	1〜3秒	3〜10秒	10〜30秒以上
Thinking Token消費	少	中	大（出力の2〜5倍）
コスト	最安	中	最高
向いているタスク	翻訳、分類、要約	コードレビュー、分析	数学、研究、複雑な推論
向いていないタスク	多段推論、数学	単純なFAQ応答	チャットボット、定型処理

重要な注意点: Gemini 3 ProはLOWとHIGHの2段階のみ。MEDIUMはGemini 3.1 Proで追加された。Gemini 3 FlashにはMINIMAL（最小）も存在するが、Thought Signatureの取り扱いが必要になるため上級者向けだ。

4.2 コストインパクトの実測値

80%のタスクをLOWまたはMEDIUMに振り分け、残り20%の複雑なタスクだけHIGHにする戦略で、API費用を50〜70%削減できると報告されている。

具体的な計算例を示そう。

【シナリオ】月間10万リクエスト、平均入力1,000トークン

■ 全リクエストHIGH（デフォルト）の場合:
  入力:  100K × 1,000 = 1億トークン → $200
  出力:  100K × 500 = 5,000万トークン → $600
  思考:  100K × 1,500 = 1.5億トークン → $1,800 ★ここが高い
  合計: 約$2,600/月

■ 80% LOW + 20% HIGH の場合:
  LOW (80K): 入力$160 + 出力$480 + 思考$240 = $880
  HIGH(20K): 入力$40 + 出力$120 + 思考$360 = $520
  合計: 約$1,400/月 → 46%削減

4.3 Thinking Levelが推論品質に与える影響

Gemini 3 ProのHIGHは、Gemini 3.1 ProのMEDIUMとほぼ同等の推論品質だと報告されている。つまり、3 Proから3.1 Proに移行する場合、MEDIUMから始めれば同等品質でコストを削減できる。

モデル × Level	推論品質の目安
3 Pro HIGH	≒ 3.1 Pro MEDIUM
3.1 Pro HIGH	Deep Think Mini発動（最高品質）
3.1 Pro LOW	3 Pro LOW と同等

4.4 Thought Signature — マルチターンで推論を引き継ぐ

Function Calling（ツール呼び出し）を使うエージェント型ワークフローでは、Thought Signatureが重要になる。

1. ユーザー: 「先月の売上を分析して」
   ↓
2. モデル: [推論] → functionCall("search_db", ...) + thoughtSignature
   ↓
3. アプリ: DB検索実行 → functionResponse(結果) + thoughtSignature を返す
   ↓
4. モデル: [前の推論を引き継いで] → 分析結果を出力

Function Calling時にThought Signatureを返さないとHTTP 400エラーになる。ただし、公式SDKを使っていれば自動で処理されるので、手動管理は不要だ。

基本概念が理解できたところで、実際にコードを書いて動かしてみましょう。

5. 実践：Thinking Levelを制御してみよう

5.1 環境構築

# Python SDKのインストール（1.51.0以上が必須）
pip install google-genai>=1.51.0

# APIキーの設定
export GEMINI_API_KEY="your-api-key-here"

5.2 環境別の設定ファイル

以下の3種類の設定ファイルを用意しました。Thinking Levelのデフォルト値を環境ごとに変えています。

開発環境用（config.yaml）

# config.yaml - 開発環境用
# コスト節約のためMEDIUMをデフォルトに
gemini:
  model: "gemini-3.1-pro-preview"
  default_thinking_level: "MEDIUM"
  max_output_tokens: 8192
  temperature: 0.7

routing:
  # タスク別のThinking Level自動選択
  simple_tasks: "LOW"       # 翻訳、要約、分類
  standard_tasks: "MEDIUM"  # コードレビュー、分析
  complex_tasks: "HIGH"     # 数学、研究、多段推論

logging:
  level: "DEBUG"
  log_thinking_tokens: true  # 思考トークン数をログ出力

本番環境用（config.production.yaml）

# config.production.yaml - 本番環境用
# ルーティングで最適化、デフォルトはLOW
gemini:
  model: "gemini-3.1-pro-preview"
  default_thinking_level: "LOW"
  max_output_tokens: 65536
  temperature: 0.3

routing:
  simple_tasks: "LOW"
  standard_tasks: "MEDIUM"
  complex_tasks: "HIGH"

cost_control:
  monthly_budget_usd: 500
  alert_threshold_percent: 80
  auto_downgrade_on_budget: true  # 予算超過時にLOWに自動切替

logging:
  level: "INFO"
  log_thinking_tokens: true

テスト環境用（config.test.yaml）

# config.test.yaml - CI/CD用
# 全タスクLOWでコスト最小化
gemini:
  model: "gemini-3.1-pro-preview"
  default_thinking_level: "LOW"
  max_output_tokens: 1024
  temperature: 0.0

routing:
  simple_tasks: "LOW"
  standard_tasks: "LOW"   # テストではMEDIUM不要
  complex_tasks: "LOW"    # テストではHIGH不要

logging:
  level: "WARNING"
  log_thinking_tokens: false

5.3 基本的な使い方

"""
Thinking Level 制御サンプル
実行方法: python thinking_level_demo.py
前提条件: pip install google-genai>=1.51.0
         環境変数 GEMINI_API_KEY を設定済み
"""
from google import genai
from google.genai import types


def demo_low():
    """LOW: 翻訳・分類など単純タスク向け"""
    client = genai.Client()

    response = client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents="以下の文を英語に翻訳してください: 今日は天気がいいですね。",
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(
                thinking_level="LOW"
            ),
            max_output_tokens=256,
        ),
    )

    print(f"[LOW] 結果: {response.text}")
    print(f"  入力トークン: {response.usage_metadata.prompt_token_count}")
    print(f"  出力トークン: {response.usage_metadata.candidates_token_count}")
    # thinking_token_count があればそれも表示
    if hasattr(response.usage_metadata, "thoughts_token_count"):
        print(f"  思考トークン: {response.usage_metadata.thoughts_token_count}")


def demo_medium():
    """MEDIUM: コードレビュー・分析向け"""
    client = genai.Client()

    code = """
def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    return db.execute(query)
"""

    response = client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents=f"以下のPythonコードのセキュリティ問題を指摘してください:\n{code}",
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(
                thinking_level="MEDIUM"
            ),
            max_output_tokens=2048,
        ),
    )

    print(f"[MEDIUM] 結果: {response.text[:200]}...")
    print(f"  入力トークン: {response.usage_metadata.prompt_token_count}")
    print(f"  出力トークン: {response.usage_metadata.candidates_token_count}")


def demo_high():
    """HIGH: 数学・研究・複雑推論向け（Deep Think Mini発動）"""
    client = genai.Client()

    response = client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents=(
            "3つの異なる正の整数a, b, cがあり、"
            "a + b + c = 100 かつ a × b × c が最大になる組み合わせを求め、"
            "数学的に証明してください。"
        ),
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(
                thinking_level="HIGH"
            ),
            max_output_tokens=8192,
        ),
    )

    print(f"[HIGH] 結果: {response.text[:300]}...")
    print(f"  入力トークン: {response.usage_metadata.prompt_token_count}")
    print(f"  出力トークン: {response.usage_metadata.candidates_token_count}")


if __name__ == "__main__":
    print("=" * 60)
    print("Thinking Level デモ")
    print("=" * 60)

    print("\n--- LOW（翻訳タスク） ---")
    demo_low()

    print("\n--- MEDIUM（コードレビュー） ---")
    demo_medium()

    print("\n--- HIGH（数学的証明） ---")
    demo_high()

5.4 タスク自動ルーティングの実装

"""
Thinking Level 自動ルーティング
タスクの複雑度に応じてThinking Levelを自動選択する
"""
from google import genai
from google.genai import types

# タスク分類キーワード（簡易版）
TASK_ROUTING = {
    "LOW": ["翻訳", "要約", "分類", "リスト", "フォーマット", "変換"],
    "MEDIUM": ["レビュー", "分析", "比較", "リファクタリング", "説明", "デバッグ"],
    "HIGH": ["証明", "最適化", "設計", "アーキテクチャ", "数学", "研究", "戦略"],
}


def classify_thinking_level(prompt: str) -> str:
    """プロンプトからThinking Levelを自動判定"""
    prompt_lower = prompt.lower()

    for level in ["HIGH", "MEDIUM", "LOW"]:
        for keyword in TASK_ROUTING[level]:
            if keyword in prompt_lower:
                return level

    return "MEDIUM"  # デフォルトはMEDIUM


def smart_generate(prompt: str) -> str:
    """Thinking Levelを自動選択してリクエスト"""
    client = genai.Client()
    level = classify_thinking_level(prompt)

    print(f"  [ルーティング] '{level}' を選択")

    response = client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents=prompt,
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(
                thinking_level=level
            ),
        ),
    )

    return response.text


if __name__ == "__main__":
    prompts = [
        "この英文を日本語に翻訳してください: The weather is nice today.",
        "このPythonコードをレビューしてください: def add(a,b): return a+b",
        "分散システムのCAP定理について数学的に証明してください。",
    ]

    for p in prompts:
        print(f"\nプロンプト: {p[:50]}...")
        result = smart_generate(p)
        print(f"  結果: {result[:100]}...")

5.5 実行結果

$ python thinking_level_demo.py
============================================================
Thinking Level デモ
============================================================

--- LOW（翻訳タスク） ---
[LOW] 結果: The weather is nice today, isn't it?
  入力トークン: 24
  出力トークン: 12
  思考トークン: 8

--- MEDIUM（コードレビュー） ---
[MEDIUM] 結果: このコードにはSQLインジェクションの脆弱性があります。
  f-stringでuser_idを直接クエリに埋め込んでいるため、悪意のある入力で...
  入力トークン: 48
  出力トークン: 356

--- HIGH（数学的証明） ---
[HIGH] 結果: a + b + c = 100 のもとで a × b × c を最大化するには、
  AM-GM不等式から3数がなるべく等しい値に近いとき積は最大になります。
  100 ÷ 3 ≒ 33.33 なので、異なる正の整数の条件より...
  入力トークン: 52
  出力トークン: 1,847

5.6 よくあるエラーと対処法

エラー	原因	対処法
`thinking_budget and thinking_level are not supported together`	旧パラメータと新パラメータの混在	`thinking_budget` を削除し `thinking_level` のみ使用
`400 Bad Request: Thought signature missing`	Function Callingでsignature未返却	公式SDKの `chat` セッションを使えば自動処理される
レスポンスが異常に遅い	デフォルトHIGHで不要な深い推論	`thinking_level="LOW"` or `"MEDIUM"` を明示指定
課金額が予想より高い	思考トークンが大量消費	`usage_metadata` の `thoughts_token_count` を監視
`thinking_level: MINIMAL is not supported`	Gemini 3.1 ProにMINIMALはない	MINIMALはFlashのみ。ProはLOW/MEDIUM/HIGHの3段階
出力品質が低すぎる	LOWで複雑なタスクを実行	タスクに応じてMEDIUMまたはHIGHに上げる

5.7 環境診断スクリプト

#!/usr/bin/env python3
"""
Thinking Level 環境診断 & コスト見積もりスクリプト
実行方法: python check_thinking_env.py
"""
import os
import sys


def check_environment():
    """環境チェック + Thinking Level別のコスト見積もり"""
    issues = []
    info = []

    # Python バージョン確認
    if sys.version_info < (3, 9):
        issues.append(f"Python 3.9以上が必要（現在: {sys.version}）")
    else:
        info.append(f"Python: {sys.version.split()[0]}")

    # SDK確認
    try:
        import google.genai as genai

        version = getattr(genai, "__version__", "不明")
        info.append(f"google-genai: {version}")
    except ImportError:
        issues.append("google-genai 未インストール → pip install google-genai>=1.51.0")
        print_results(info, issues)
        return

    # APIキー確認
    api_key = os.environ.get("GEMINI_API_KEY")
    if not api_key:
        issues.append("GEMINI_API_KEY 未設定")
    else:
        info.append(f"GEMINI_API_KEY: 設定済み（{api_key[:8]}...）")

    # Thinking Level 別コスト見積もり
    print("\n" + "=" * 50)
    print("Thinking Level別 月間コスト見積もり")
    print("=" * 50)
    print("（月間10万リクエスト、平均入力1,000トークンの場合）")
    print()

    scenarios = [
        ("全部HIGH（デフォルト）", 1.0, 0.0, 0.0),
        ("全部MEDIUM", 0.0, 1.0, 0.0),
        ("全部LOW", 0.0, 0.0, 1.0),
        ("推奨: 20%H + 30%M + 50%L", 0.2, 0.3, 0.5),
    ]

    input_price = 2.0   # $/1Mトークン
    output_price = 12.0  # $/1Mトークン

    for name, h_ratio, m_ratio, l_ratio in scenarios:
        requests = 100_000
        avg_input = 1_000
        avg_output = 500

        # 思考トークン推定（HIGH=出力の3倍, MEDIUM=1.5倍, LOW=0.3倍）
        h_think = avg_output * 3.0
        m_think = avg_output * 1.5
        l_think = avg_output * 0.3

        total_input = requests * avg_input
        total_output = requests * avg_output
        total_think = requests * (h_ratio * h_think + m_ratio * m_think + l_ratio * l_think)

        cost_input = total_input / 1_000_000 * input_price
        cost_output = (total_output + total_think) / 1_000_000 * output_price

        total_cost = cost_input + cost_output
        print(f"  {name}")
        print(f"    → 月額: ${total_cost:,.0f}")
        print()

    print_results(info, issues)


def print_results(info, issues):
    """結果表示"""
    print("=" * 50)
    print("環境診断結果")
    print("=" * 50)

    if info:
        print("\n[情報]")
        for i in info:
            print(f"  ✅ {i}")

    if issues:
        print("\n[問題]")
        for issue in issues:
            print(f"  ❌ {issue}")
    else:
        print("\n🎉 環境は正常です！")


if __name__ == "__main__":
    check_environment()

実装方法がわかったので、次は具体的なユースケースを見ていきます。

6. ユースケース別ガイド

6.1 ユースケース1: チャットボットのコスト最適化

想定読者: LLMベースのチャットボットを運用しているバックエンド開発者

推奨構成: デフォルトLOW + 複雑な質問のみMEDIUMに自動昇格

サンプルコード:

"""
チャットボット向けThinking Level自動昇格
ユーザーの質問が複雑な場合のみMEDIUMに切り替え
"""
from google import genai
from google.genai import types


COMPLEX_INDICATORS = [
    "なぜ", "理由", "比較", "違い", "メリット", "デメリット",
    "設計", "アーキテクチャ", "最適", "トレードオフ",
]


def chatbot_respond(user_message: str) -> str:
    """ユーザーメッセージに応答（Thinking Level自動選択）"""
    client = genai.Client()

    # 複雑度を判定
    is_complex = any(kw in user_message for kw in COMPLEX_INDICATORS)
    level = "MEDIUM" if is_complex else "LOW"

    response = client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents=user_message,
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(thinking_level=level),
            max_output_tokens=2048,
            temperature=0.7,
        ),
    )

    return response.text


if __name__ == "__main__":
    # LOW で処理される例
    print(chatbot_respond("営業時間を教えてください"))

    # MEDIUM に昇格される例
    print(chatbot_respond("なぜ御社のサービスは他社と比較して優れているのですか？"))

6.2 ユースケース2: CI/CDパイプラインでのコードレビュー

想定読者: GitHub ActionsなどでAIレビューを自動化したいDevOpsエンジニア

推奨構成: diff量に応じてLOW → MEDIUM → HIGHを段階的に適用

サンプルコード:

"""
CI/CD向けコードレビュー（diff量でThinking Levelを決定）
"""
from google import genai
from google.genai import types


def review_pull_request(diff: str) -> str:
    """PRのdiffをレビュー"""
    client = genai.Client()

    # diff行数でThinking Levelを決定
    line_count = diff.count("\n")
    if line_count < 20:
        level = "LOW"
    elif line_count < 200:
        level = "MEDIUM"
    else:
        level = "HIGH"

    print(f"[CI] diff {line_count}行 → Thinking Level: {level}")

    response = client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents=f"以下のPR diffをレビューしてください。セキュリティ問題とバグを重点的に:\n\n{diff}",
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(thinking_level=level),
            max_output_tokens=4096,
            temperature=0.2,
        ),
    )

    return response.text


if __name__ == "__main__":
    sample_diff = """\
- def authenticate(password):
-     return password == "admin123"
+ def authenticate(password):
+     import bcrypt
+     return bcrypt.checkpw(password.encode(), stored_hash)
"""
    print(review_pull_request(sample_diff))

6.3 ユースケース3: 研究・数学の深い推論

想定読者: LLMを研究補助や数学的分析に使いたい研究者・データサイエンティスト

推奨構成: HIGH固定 + コンテキストキャッシュで入力コスト削減

サンプルコード:

"""
研究向け: HIGH固定 + コンテキストキャッシュ
同じコンテキスト（論文等）を繰り返し参照する場合にコスト削減
"""
from google import genai
from google.genai import types


def research_analysis(paper_text: str, questions: list[str]) -> list[str]:
    """論文テキストに対して複数の質問を投げる（キャッシュ活用）"""
    client = genai.Client()
    results = []

    # 最初のリクエストで論文全体を送信
    # 2回目以降はコンテキストキャッシュが効き入力コスト75%削減
    for i, question in enumerate(questions):
        prompt = f"""以下の論文を分析してください。

{paper_text}

質問: {question}
根拠となる箇所を引用しながら回答してください。"""

        response = client.models.generate_content(
            model="gemini-3.1-pro-preview",
            contents=prompt,
            config=types.GenerateContentConfig(
                thinking_config=types.ThinkingConfig(
                    thinking_level="HIGH"  # 研究用は常にHIGH
                ),
                max_output_tokens=8192,
                temperature=0.1,
            ),
        )

        results.append(response.text)
        print(f"  質問{i + 1}/{len(questions)} 完了")

    return results


if __name__ == "__main__":
    paper = "（ここに論文テキスト）"
    questions = [
        "この論文の主要な貢献は何ですか？",
        "実験手法の限界は何ですか？",
        "先行研究との差分を整理してください。",
    ]
    answers = research_analysis(paper, questions)
    for q, a in zip(questions, answers):
        print(f"\nQ: {q}\nA: {a[:200]}...")

ユースケースを把握できたところで、この先の学習パスを確認しましょう。

7. 学習ロードマップ

この記事を読んだ後、次のステップとして以下をおすすめします。

初級者向け（まずはここから）

Gemini Thinking 公式ドキュメント（Google AI for Developers）でパラメータの詳細を確認
Google AI Studio のプレイグラウンドでLOW/MEDIUM/HIGHの出力差を体感
自分のユースケースで3段階を試し、品質とコストのバランスを見つける

中級者向け（実践に進む）

タスク自動ルーティングを本番環境に導入し、コスト削減効果を計測
Gemini 3 Developer Guide（公式）でThought Signatureの詳細を学ぶ
コンテキストキャッシュとの組み合わせで更なるコスト最適化

上級者向け（さらに深く）

Vertex AI Thinking ドキュメント（Google Cloud）でエンタープライズ環境での運用方法を学ぶ
A/Bテストでタスク分類の精度を検証し、ルーティング戦略を最適化
FinOpsツールと連携してトークンコストのリアルタイム監視を構築

8. まとめ

この記事では、Thinking Levelについて以下を解説しました：

3段階の推論制御 — LOW（高速・低コスト）、MEDIUM（バランス）、HIGH（Deep Think Mini）の使い分け
コスト最適化の具体的な数字 — 適切なルーティングで50〜70%のAPI費用削減が可能
Pythonでの実装パターン — 基本的な制御から自動ルーティングまで

私の所感

Thinking Levelの本質は、「AIに"考えさせすぎない"ことが最適化のカギ」という逆説的な発見にある。人間の仕事でも、メール返信に3時間かけるのは非効率だ。AIも同じで、タスクに見合った「考える深さ」を与えるのが正しい使い方だ。

個人的に最もインパクトが大きかったのは、Gemini 3.1 ProのデフォルトがHIGHであるという事実を知ったこと。何も設定しないと最も高コストなモードで動く。これを知らずに運用すると、請求額を見て青ざめることになる。最初の一歩は、まず自分のユースケースでLOWを試してみること。驚くほど十分なケースが多いはずだ。

参考文献

この記事が参考になったら、いいね・ストックをお願いします！
他にもAI/ML関連の記事を書いています。よければフォローもお願いします。

Gemini 3.1 Proってなんだ？（親記事）
CUDAってなんだ？
GPUってなんだ？
VRAMってなんだ？

Xでも技術情報を発信しています → https://x.com/geneLab_999