Gemini 2.5 Flash Thinking

Gemini 2.5 Flash Thinking は、1,048,576 トークンのコンテキストが記載されている、テキストと画像を扱う名前付きプロファイルです。文章で示した質問と関連画像を組み合わせ、焦点の定まったテキスト回答を求めてください。

Ailoot · Anthropic メッセージ POST /v1/messages gemini-2.5-flash-thinking
Ailoot · Gemini generateContent POST /v1beta/models/{model}:generateContent gemini-2.5-flash-thinking

モデルについて

この説明はモデルの機能を紹介するものです。Ailootで利用できる入力、出力、オプションは、選択したメソッドごとに以下に記載されています。

Gemini 2.5 Flash Thinkingは、ここで紹介するテキストと画像の入力、テキスト出力のプロファイル名です。記載されたコンテキストは1,048,576トークンで、記載された最大出力は65,536トークンです。

画像の質問では、画像を提供し、見える文字、グラフ、レイアウト、特定の細部など、何を調べるかを明示してください。文書の指示では、比較する部分と回答の形式を指定します。

使う証拠と応答の長さを指示に明記してください。Thinkingという修飾語は、このプロファイル名の一部です。

実用タスク

英語の技術例

Separate two contract obligations

Compare these written clauses. C1: 'The supplier sends a dispatch notice within one business day of shipment.' C2: 'The buyer reports damaged goods within three calendar days of receipt.' Return who acts, the trigger and the time unit for each clause, followed by one sentence explaining why the deadlines cannot share a single start date.

期待される結果

Two clause-linked obligation records and a short distinction between their triggers.

結果の確認

Preserve business days versus calendar days and shipment versus receipt.

Ailoot · Anthropic メッセージ POST /v1/messages gemini-2.5-flash-thinking

gemini-2.5-flash-thinking

Google /gemini-2.5-flash-thinking

はじめに

対応する入力: テキスト · 画像
結果: テキスト

Ailootで利用可能 · 入力とメソッド

Ailoot · Anthropic メッセージ POST /v1/messages

入力の種類: text, image
出力の種類: text
コンテキスト: 1,048,576 tokens
最大出力: 65,536 tokens
出力形式: jsonまたはSSE

フィールド	種類	要件	値と制限	デフォルト
フィールド`model`	種類`string`	要件必須	値と制限 gemini-2.5-flash-thinking	デフォルト—
フィールド`messages`	種類`message[]`	要件必須	値と制限最小項目数: 1	デフォルト—
フィールド`messages[].role`	種類`string`	要件必須	値と制限 user, assistant	デフォルト—
フィールド`messages[].content`	種類`string\|content_block[]`	要件必須	値と制限	デフォルト—
フィールド`system`	種類`string\|content_block[]`	要件任意	値と制限	デフォルト—
フィールド`max_tokens`	種類`integer`	要件必須	値と制限最小値: 1 制限の適用対象: 選択したモデル／カードに固有の正確な上限	デフォルト—
フィールド`stream`	種類`boolean`	要件任意	値と制限	デフォルトfalse
フィールド`temperature`	種類`number`	要件任意	値と制限モデルによる	デフォルト—
フィールド`top_p`	種類`number`	要件任意	値と制限モデルによる	デフォルト—
フィールド`stop_sequences`	種類`string[]`	要件任意	値と制限モデルによる	デフォルト—
フィールド`tools`	種類`tool[]`	要件任意	値と制限モデルによる	デフォルト—
フィールド`tools[].name`	種類`string`	要件任意	値と制限適用条件: ツールの指定あり	デフォルト—
フィールド`tools[].description`	種類`string`	要件任意	値と制限	デフォルト—
フィールド`tools[].input_schema`	種類`JSON_schema`	要件任意	値と制限	デフォルト—
フィールド`tool_choice`	種類`object`	要件任意	値と制限モデルによる	デフォルト—
フィールド`thinking.type`	種類`string`	要件任意	値と制限モデルによる	デフォルト—
フィールド`thinking.budget_tokens`	種類`integer`	要件任意	値と制限モデルによる	デフォルト—
フィールド`output_config.effort`	種類`string`	要件任意	値と制限モデルによる	デフォルト—
フィールド`metadata`	種類`object`	要件任意	値と制限	デフォルト—
フィールド`cache_control`	種類`object`	要件任意	値と制限モデルによる	デフォルト—

入力素材の組み合わせ

テキスト · UTF8テキスト

messages[].contentまたはtype=textブロック

テキスト + 画像

{type:image,source:{type:base64,media_type,data}}またはtype=urlのソース

メソッドのパラメータとライフサイクル

パラメータ	仕様
パラメータ`material_types`	仕様text, image
パラメータ`required`	仕様model, messages, max_tokens
パラメータ`optional_controls`	仕様null
パラメータ`content_type`	仕様application/json
パラメータ`text_file_material`	仕様実際のUTF-8内容をテキストとして挿入します。ファイルID/URLsには別途、正確な対応が必要です

ライフサイクル: exact retained published method

メソッドの形式とIDは正確に記載しています。供給元の対応能力とリクエストの受け入れは別です。

料金

Ailootのメソッド料金

Ailoot Anthropic メッセージPOST /v1/messages

入力: $0.0003 / 1K
出力: $0.0025 / 1K
キャッシュ読み取り: ≈$0.00003 / 1K

Ailootはリクエスト前に見積額を確保します。結果の取得後、実測使用量に基づいて最終料金を精算します。ストリーミング時の精算には最終の使用量記録を使用します。金額の確保と精算の仕組み →

リクエスト例

Ailoot · Anthropic メッセージ

テキストのサンプル入力、画像Python SDKNode.js SDKPythonストリーミング

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gemini-2.5-flash-thinking", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT

set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gemini-2.5-flash-thinking", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT

import anthropic
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
    model="gemini-2.5-flash-thinking",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(msg.to_dict(mode="json"))

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

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
  model: "gemini-2.5-flash-thinking",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";

function saveResult(data, stem = "result") {
  writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
  console.log(JSON.stringify(data, null, 2));
  const saveBlob = (encoded, suffix, label) => {
    const raw = Buffer.from(encoded, "base64");
    const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
    const file = `${stem}-${label}.${ext}`;
    writeFileSync(file, raw); console.log("Saved", file);
  };
  for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
  for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
  for (const [i, item] of (data.output || []).entries()) {
    console.log("Output", i, JSON.stringify(item));
    if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
  }
  for (const [ci, candidate] of (data.candidates || []).entries()) {
    for (const [pi, part] of (candidate.content?.parts || []).entries()) {
      console.log("Candidate/part", ci, pi, JSON.stringify(part));
      const blob = part.inlineData || part.inline_data;
      if (blob?.data) {
        const mime = blob.mimeType || blob.mime_type;
        const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
        saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
      }
    }
  }
}

saveResult(msg);

import anthropic,os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.messages.stream(model='gemini-2.5-flash-thinking',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_message()
    save_result(final.to_dict(mode="json"),"stream-result")

結果を受け取って保存

Ailoot · Anthropic メッセージ

jsonまたはSSE

完了した結果をすべて保存

返された完全なレスポンス、ファイル、コンテンツ部分をすべて保存してください。

すべてのコンテンツブロック、思考署名、実際のツール利用IDを保持してください。SSEのすべてのブロック差分を組み立てます。最初のテキストブロックだけでは完全な出力になりません。

元のレスポンスを確認する場合

リクエスト／応答IDとヘッダーを保持してください。テキストジョブを取得する汎用URLは提供されません。

レスポンスのフィールド

フィールド	種類
フィールド`id`	種類string
フィールド`model`	種類string
フィールド`content[]`	種類text\|thinking\|tool_use\|other content block
フィールド`stop_reason`	種類string\|null
フィールド`usage`	種類object

エラーと次の手順

レスポンス	条件	次の手順
レスポンス400 · `invalid_request_error`	条件必須フィールド、素材の表現形式、またはパラメーター値が不正です	次の手順新しい生成リクエストを送る前に、指定されたフィールドを修正してください。

エイリアス

モデルのエイリアス

Ailoot gemini-2.5-flash-thinking

メソッドパスのエイリアス

上記に表示されたメソッドパスを使用してください。