OpenAI
OpenAI 総合概要 — 機能・アーキテクチャ・設定ガイド
作成日: 2026-04-07
対象読者: エンジニア・アーキテクト・AI導入を検討する技術者
想定知識レベル: REST API・クラウドサービスの基礎知識があること
目次
- はじめに — OpenAI とは
- OpenAI の歴史と組織構造
- モデルファミリー全体像
- OpenAI API アーキテクチャ
- Chat Completions API
- Responses API（新世代API）
- Assistants API
- Function Calling / Tool Use
- Embeddings API
- 画像生成 — DALL·E / GPT Image Generation
- 音声 API — Whisper / TTS
- マルチモーダル入力（Vision）
- Realtime API
- Fine-tuning（ファインチューニング）
- Batch API
- Agents SDK
- コンテンツモデレーションと安全性
- セキュリティ・コンプライアンス・データプライバシー
- 料金体系と最適化戦略
- ベストプラクティスと実践的設定例
- まとめ
1. はじめに — OpenAI とは
1.1 OpenAI の概要
OpenAI は、2015年に設立された人工知能（AI）研究組織であり、「安全で有益な汎用人工知能（AGI: Artificial General Intelligence）の実現」をミッションとして掲げている。設立以来、GPTシリーズ、DALL·E、Whisper、Codex など、多数の革新的なAIモデルとサービスを世界に送り出してきた。
2022年11月に公開された ChatGPT は、わずか2ヶ月で1億ユーザーを超え、AIの民主化を一気に加速させた。企業向けには OpenAI API を通じて、テキスト生成、コード補完、画像生成、音声認識・合成、埋め込みベクトル生成など、包括的なAI機能をプログラマティックに利用できるプラットフォームを提供している。
1.2 本記事の目的
本記事では、OpenAI が提供する機能とサービスの全体像を体系的に整理し、以下を目的とする。
- モデルファミリーの理解: GPT-4o、GPT-4.5、o1、o3、o4-mini など各モデルの特性と使い分け
- API アーキテクチャの把握: Chat Completions API、Responses API、Assistants API など複数のAPIの関係性
- 実践的な設定例の提供: 各APIの具体的なリクエスト/レスポンス例
- 運用上の考慮事項: セキュリティ、コンプライアンス、コスト最適化のポイント
1.3 OpenAI が提供する主要サービス
| サービス | 概要 |
|---|---|
| ChatGPT | 消費者・ビジネス向け対話型AIアシスタント |
| OpenAI API | 開発者向けAPIプラットフォーム |
| ChatGPT Enterprise / Team | 企業向けセキュアなChatGPT環境 |
| GPT Store / GPTs | カスタムGPTのマーケットプレイス |
| OpenAI Platform | ファインチューニング・バッチ処理・評価ツール |
| Codex (CLI) | ターミナルベースのAIコーディングエージェント |
2. OpenAI の歴史と組織構造
2.1 設立と進化の年表
| 年 | 出来事 |
|---|---|
| 2015年12月 | OpenAI 設立（Sam Altman, Elon Musk, Greg Brockman ら）。非営利として発足 |
| 2018年6月 | GPT-1 発表（1.17億パラメータ、Transformer デコーダーベース） |
| 2019年2月 | GPT-2 発表（15億パラメータ）。当初「危険すぎる」として全体公開を保留 |
| 2019年3月 | OpenAI LP 設立（営利部門、"capped profit" 構造） |
| 2020年6月 | GPT-3 発表（1750億パラメータ）。APIベータ提供開始 |
| 2021年1月 | DALL·E 発表（テキストから画像を生成） |
| 2022年9月 | Whisper 公開（多言語音声認識モデル） |
| 2022年11月 | ChatGPT 公開（GPT-3.5ベース） |
| 2023年3月 | GPT-4 発表（マルチモーダル対応） |
| 2023年11月 | GPTs / GPT Store 発表。Sam Altman CEO 解任・復帰劇 |
| 2024年5月 | GPT-4o 発表（"omni" — テキスト・音声・画像の統合） |
| 2024年9月 | o1 (推論モデル) 発表 — "thinking" による推論強化 |
| 2024年12月 | o3 発表（ARC-AGI で画期的スコア） |
| 2025年1月 | o3-mini リリース。Operator (エージェント) 発表 |
| 2025年2月 | GPT-4.5 発表（研究プレビュー、最大規模モデル） |
| 2025年4月 | o4-mini、GPT-4.1 シリーズ発表。Codex CLI リリース |
2.2 組織構造
OpenAI は複雑な組織構造を持つ。2019年に非営利部門と営利部門（OpenAI LP）に分かれ、2024-2025年にかけて営利法人（Public Benefit Corporation）への転換を進めている。
OpenAI Inc. (非営利)
├── OpenAI Global LLC (営利部門 → PBC への転換中)
│ ├── API / Platform 事業
│ ├── ChatGPT 事業
│ ├── 研究開発
│ └── セーフティ / アライメント研究
└── OpenAI Startup Fund (投資部門)
主要な投資パートナーとして Microsoft が130億ドル以上を出資し、Azure 上での OpenAI モデルの提供（Azure OpenAI Service）も行っている。
2.3 OpenAI と Azure OpenAI Service の関係
| 項目 | OpenAI API | Azure OpenAI Service |
|---|---|---|
| 提供元 | OpenAI 直接 | Microsoft Azure |
| 認証 | API Key / OAuth | Azure AD / API Key |
| SLA | ベストエフォート | 99.9% SLA あり |
| データ所在地 | 米国中心 | Azure リージョン選択可 |
| コンプライアンス | SOC 2 Type II | Azure 準拠認証群 |
| モデル | 最新モデル即時利用可 | 一部遅延あり |
| ネットワーク | パブリック | VNet / Private Endpoint 対応 |
企業でのプロダクション利用では、Azure OpenAI Service が選択されることが多い。これはSLA、データ所在地の制御、既存のAzureセキュリティ基盤との統合が可能なためである。
3. モデルファミリー全体像
3.1 モデルの分類体系
OpenAI のモデルは大きく以下のカテゴリに分類される。
(A) GPT シリーズ（生成モデル）
標準的なテキスト生成モデル。低レイテンシーで多用途。
| モデル | コンテキスト長 | 特徴 | 推奨用途 |
|---|---|---|---|
| GPT-4.1 | 1,047,576 | GPT-4oの後継。コーディング・指示追従で大幅向上 | コード生成、複雑なワークフロー |
| GPT-4.1 mini | 1,047,576 | 4.1のコスト効率版 | バランス型の一般用途 |
| GPT-4.1 nano | 1,047,576 | 最も高速・低コスト | 分類、抽出、軽量タスク |
| GPT-4o | 128,000 | マルチモーダル（テキスト・画像・音声） | 汎用、リアルタイム音声 |
| GPT-4o mini | 128,000 | GPT-4oの軽量版 | コスト重視の一般用途 |
| GPT-4.5 Preview | 128,000 | 最大規模モデル。創造性・ニュアンスに優れる | 創作、研究、複雑な分析 |
| GPT-4 Turbo | 128,000 | GPT-4の高速版（レガシー） | 既存システムの互換用 |
(B) o シリーズ（推論モデル）
内部で "thinking"（思考プロセス）を実行し、複雑な推論タスクに特化したモデル。
| モデル | コンテキスト長 | 特徴 | 推奨用途 |
|---|---|---|---|
| o4-mini | 200,000 | 高速推論モデル。コスト効率が高い | コーディング、数学、分析 |
| o3 | 200,000 | 最高推論能力。全ツール対応 | 高難度STEM、戦略立案 |
| o3-mini | 200,000 | o3の軽量版 | 推論が必要だがコスト重視 |
| o1 | 200,000 | 初代推論モデル | 科学、数学、コーディング |
| o1-mini | 128,000 | o1の軽量版 | 推論タスクの高速処理 |
(C) 特化モデル
| モデル | 用途 |
|---|---|
| DALL·E 3 | テキストから画像生成 |
| GPT Image (GPT-4o) | モデル内蔵の画像生成（編集対応） |
| Whisper | 音声認識（多言語） |
| TTS (tts-1, tts-1-hd) | テキスト読み上げ |
| text-embedding-3-small/large | テキスト埋め込みベクトル |
| Moderation (omni-moderation-latest) | コンテンツモデレーション |
3.2 モデル選択のフローチャート
タスクの種類を判定
│
├─ 複雑な推論が必要（数学、科学、戦略的分析）
│ ├─ 最高精度が必要 → o3
│ ├─ コスト効率重視 → o4-mini
│ └─ 低コスト推論 → o3-mini
│
├─ 一般的なテキスト生成
│ ├─ 長大コンテキスト（100K+トークン） → GPT-4.1
│ ├─ マルチモーダル（画像・音声入力） → GPT-4o
│ ├─ 高品質・創造性重視 → GPT-4.5 Preview
│ ├─ コスト効率重視 → GPT-4.1 mini
│ └─ 最低コスト → GPT-4.1 nano / GPT-4o mini
│
├─ 画像生成 → DALL·E 3 / GPT-4o (image generation)
├─ 音声認識 → Whisper
├─ 音声合成 → TTS
├─ テキスト検索・類似度 → text-embedding-3-small/large
└─ コンテンツ安全性 → omni-moderation-latest
3.3 GPT モデルと o モデルの根本的な違い
GPTモデルと o モデルの最大の違いは「思考プロセス」の有無にある。
GPT モデル（例: GPT-4o）:
- 入力を受け取り、直接的に出力を生成
- レイテンシーが低い
temperature、top_pなどのサンプリングパラメータを制御可能- ストリーミング出力に完全対応
o モデル（例: o3）:
- 入力を受け取った後、内部で「思考チェーン」を実行
- 思考トークンは出力に含まれる（課金対象）が、内容は非公開
reasoning_effortパラメータで思考の深さを制御（low/medium/high）- レイテンシーは高いが、複雑なタスクの正確性が大幅に向上
# o モデルでの reasoning_effort 設定例
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="o4-mini",
reasoning={
"effort": "high" # low, medium, high から選択
},
input="この微分方程式を解いてください: dy/dx + 2xy = x"
)
4. OpenAI API アーキテクチャ
4.1 API の全体構成
OpenAI API は RESTful な HTTP API として提供され、以下の主要エンドポイント群で構成される。
OpenAI API (api.openai.com)
│
├── /v1/chat/completions ← Chat Completions API（従来の主力）
├── /v1/responses ← Responses API（新世代、推奨）
│
├── /v1/embeddings ← 埋め込みベクトル生成
├── /v1/images/generations ← 画像生成 (DALL·E)
├── /v1/images/edits ← 画像編集
│
├── /v1/audio/transcriptions ← 音声認識 (Whisper)
├── /v1/audio/translations ← 音声翻訳
├── /v1/audio/speech ← 音声合成 (TTS)
│
├── /v1/moderations ← コンテンツモデレーション
│
├── /v1/fine_tuning/jobs ← ファインチューニング
├── /v1/batches ← バッチ処理
├── /v1/files ← ファイルアップロード
├── /v1/uploads ← 大容量ファイルアップロード
│
├── /v1/vector_stores ← ベクトルストア（ファイル検索用）
│
├── /v1/assistants ← Assistants API
├── /v1/threads ← スレッド管理
│
├── /v1/realtime ← Realtime API (WebSocket / WebRTC)
│
├── /v1/organization/ ← 組織管理
├── /v1/organization/usage ← 使用量追跡
└── /v1/organization/costs ← コスト追跡
4.2 認証とアクセス制御
API キーの種類
| キーの種類 | プレフィックス | スコープ | 用途 |
|---|---|---|---|
| Standard API Key | sk- | プロジェクト単位 | 一般的なAPI利用 |
| User API Key | sk- | ユーザー全プロジェクト | レガシー（非推奨） |
| Service Account Key | sk- | プロジェクト単位 | サービス間通信 |
| Admin Key | sk-admin- | 組織全体 | 管理操作 |
認証ヘッダーの設定
# 基本的な認証
curl https://api.openai.com/v1/chat/completions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-H "OpenAI-Organization: org-xxxxxxxx" \
-H "OpenAI-Project: proj-xxxxxxxx" \
-d '{...}'
# Python SDK での設定
from openai import OpenAI
client = OpenAI(
api_key="sk-...", # 環境変数 OPENAI_API_KEY が推奨
organization="org-...", # オプション
project="proj-...", # オプション
timeout=60.0, # タイムアウト設定
max_retries=3 # 自動リトライ
)
4.3 レート制限とクォータ
OpenAI API にはティア制のレート制限が設けられている。
| ティア | 条件 | RPM (例: GPT-4o) | TPM (例: GPT-4o) |
|---|---|---|---|
| Free | 初期状態 | 500 | 30,000 |
| Tier 1 | $5 支払い済 | 500 | 30,000 |
| Tier 2 | $50 支払い + 7日以上 | 5,000 | 450,000 |
| Tier 3 | $100 支払い + 7日以上 | 5,000 | 800,000 |
| Tier 4 | $250 支払い + 14日以上 | 10,000 | 2,000,000 |
| Tier 5 | $1,000 支払い + 30日以上 | 30,000 | 150,000,000 |
RPM: Requests Per Minute（1分あたりリクエスト数）
TPM: Tokens Per Minute（1分あたりトークン数）
レート制限に関するレスポンスヘッダー:
x-ratelimit-limit-requests: 5000
x-ratelimit-limit-tokens: 800000
x-ratelimit-remaining-requests: 4999
x-ratelimit-remaining-tokens: 799800
x-ratelimit-reset-requests: 12ms
x-ratelimit-reset-tokens: 15ms
4.4 エラーハンドリング
| HTTP ステータスコード | エラータイプ | 対処法 |
|---|---|---|
| 400 | invalid_request_error | リクエストパラメータを確認 |
| 401 | authentication_error | APIキーを確認 |
| 403 | permission_error | 権限・リージョン制限を確認 |
| 404 | not_found_error | エンドポイント・モデル名を確認 |
| 429 | rate_limit_error | 指数バックオフでリトライ |
| 500 | server_error | OpenAI 側の障害。リトライ |
| 503 | service_unavailable | 高負荷時。リトライ |
# 堅牢なエラーハンドリング例
import openai
from openai import OpenAI
import time
client = OpenAI()
def call_with_retry(messages, max_retries=5):
for attempt in range(max_retries):
try:
response = client.chat.completions.create(
model="gpt-4o",
messages=messages
)
return response
except openai.RateLimitError as e:
wait_time = 2 ** attempt # 指数バックオフ
print(f"Rate limited. Waiting {wait_time}s...")
time.sleep(wait_time)
except openai.APIStatusError as e:
if e.status_code >= 500:
time.sleep(2 ** attempt)
continue
raise # 4xx エラーはリトライ不要
raise Exception("Max retries exceeded")
4.5 SDK のサポート状況
| 言語 | パッケージ名 | 公式/コミュニティ |
|---|---|---|
| Python | openai | 公式 |
| Node.js / TypeScript | openai | 公式 |
| C# / .NET | OpenAI | 公式 |
| Java | openai-java | 公式 |
| Go | openai-go | 公式 |
| Ruby | コミュニティ | 非公式 |
| Rust | コミュニティ | 非公式 |
# Python SDK インストール
pip install openai
# Node.js SDK インストール
npm install openai
5. Chat Completions API
5.1 概要
Chat Completions API は OpenAI の最も広く使用されている API であり、会話形式でテキスト生成を行う。2023年のリリース以来、事実上の標準 API として定着している。
注意: 2025年以降、OpenAI は Chat Completions API の後継として Responses API を推奨している。ただし Chat Completions API は引き続きサポートされる。
5.2 基本リクエスト構造
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": "あなたは親切なアシスタントです。"
},
{
"role": "user",
"content": "量子コンピューティングとは何ですか？"
}
],
temperature=0.7,
max_tokens=1000,
top_p=1.0,
frequency_penalty=0.0,
presence_penalty=0.0
)
print(response.choices[0].message.content)
5.3 メッセージロールの詳細
| ロール | 説明 | 特記事項 |
|---|---|---|
system | モデルの振る舞いを定義 | 最初のメッセージとして配置 |
user | ユーザーの入力 | テキスト・画像URLを含められる |
assistant | モデルの応答 | 会話履歴として含める |
tool | ツール呼び出しの結果 | Function Calling 時に使用 |
developer | 開発者の指示（Responses API） | system の後継的な役割 |
5.4 主要パラメータの詳細
temperature（温度）
出力のランダム性を制御する。0〜2 の範囲。
# 決定論的な出力（コード生成、分類に最適）
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Pythonでクイックソートを実装"}],
temperature=0.0 # 常に最も確率の高いトークンを選択
)
# 創造的な出力（ブレインストーミング、創作に最適）
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "SF短編小説の冒頭を書いて"}],
temperature=1.2 # より多様な出力
)
Structured Outputs（構造化出力）
JSON Schema に従った出力を保証する機能。
from pydantic import BaseModel
from openai import OpenAI
client = OpenAI()
class CalendarEvent(BaseModel):
name: str
date: str
participants: list[str]
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "イベント情報を構造化して出力してください。"},
{"role": "user", "content": "来週の金曜日に田中さんと佐藤さんとプロジェクト会議があります"}
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "calendar_event",
"strict": True,
"schema": CalendarEvent.model_json_schema()
}
}
)
event = CalendarEvent.model_validate_json(
response.choices[0].message.content
)
print(event)
# CalendarEvent(name='プロジェクト会議', date='2026-04-17', participants=['田中', '佐藤'])
SDK の parse ヘルパー
# SDK の parse ヘルパーを使うとより簡潔に書ける
completion = client.beta.chat.completions.parse(
model="gpt-4o",
messages=[
{"role": "system", "content": "イベント情報を抽出してください。"},
{"role": "user", "content": "明日10時からチームスタンドアップ。参加者: 鈴木、田中"}
],
response_format=CalendarEvent
)
event = completion.choices[0].message.parsed
print(event.name) # "チームスタンドアップ"
5.5 ストリーミング
ストリーミングを使用すると、完全な応答を待たずにトークン単位で逐次出力を受け取れる。
# ストリーミング出力
stream = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "桜の美しさについて語ってください"}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content is not None:
print(chunk.choices[0].delta.content, end="", flush=True)
// TypeScript でのストリーミング
import OpenAI from 'openai';
const client = new OpenAI();
const stream = await client.chat.completions.create({
model: 'gpt-4o',
messages: [{ role: 'user', content: '桜の美しさについて語ってください' }],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content || '';
process.stdout.write(content);
}
5.6 レスポンス構造
{
"id": "chatcmpl-abc123",
"object": "chat.completion",
"created": 1712345678,
"model": "gpt-4o-2025-03-27",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "量子コンピューティングとは..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 25,
"completion_tokens": 150,
"total_tokens": 175,
"prompt_tokens_details": {
"cached_tokens": 0
},
"completion_tokens_details": {
"reasoning_tokens": 0
}
},
"system_fingerprint": "fp_abc123"
}
5.7 会話管理のパターン
Chat Completions API はステートレスであるため、会話の文脈を維持するにはクライアント側で履歴を管理する必要がある。
class ConversationManager:
def __init__(self, system_prompt: str, model: str = "gpt-4o"):
self.model = model
self.messages = [
{"role": "system", "content": system_prompt}
]
def send(self, user_message: str) -> str:
self.messages.append({"role": "user", "content": user_message})
response = client.chat.completions.create(
model=self.model,
messages=self.messages
)
assistant_message = response.choices[0].message.content
self.messages.append({"role": "assistant", "content": assistant_message})
# コンテキストウィンドウ管理: 古いメッセージを削除
self._trim_history()
return assistant_message
def _trim_history(self, max_messages: int = 20):
"""system メッセージを保持しつつ、古い履歴を削除"""
if len(self.messages) > max_messages:
self.messages = [self.messages[0]] + self.messages[-(max_messages-1):]
# 使用例
chat = ConversationManager("あなたは Python の専門家です。")
print(chat.send("リスト内包表記について教えてください"))
print(chat.send("それをジェネレータ式に変えるにはどうしますか？"))
6. Responses API（新世代API）
6.1 概要と位置づけ
Responses API は 2025年にリリースされた OpenAI の新しい API プリミティブで、Chat Completions API の後継として位置づけられている。以下の特徴を持つ。
- 組み込みツール: Web検索、ファイル検索、コード実行をネイティブサポート
- マルチターンの会話管理:
previous_response_idによるサーバーサイドの会話状態管理 - ストリーミングイベント: より細粒度のイベントベースストリーミング
- 統一されたインターフェース: GPTモデルと o モデルの両方で同一APIを使用
6.2 基本的な使用方法
from openai import OpenAI
client = OpenAI()
# 基本的なテキスト生成
response = client.responses.create(
model="gpt-4.1",
input="日本の四季について教えてください"
)
print(response.output_text)
6.3 マルチターン会話
# 1回目の会話
response1 = client.responses.create(
model="gpt-4.1",
input="東京の有名な観光地を3つ教えてください"
)
print(response1.output_text)
# 2回目の会話（前の応答を参照）
response2 = client.responses.create(
model="gpt-4.1",
input="その中で一番おすすめはどれですか？理由も教えてください",
previous_response_id=response1.id # 会話の文脈を保持
)
print(response2.output_text)
6.4 システム指示（Instructions）
response = client.responses.create(
model="gpt-4.1",
instructions="あなたはシニアソフトウェアエンジニアです。コードレビューを行い、改善点を具体的に指摘してください。",
input="""
以下のPythonコードをレビューしてください:
def get_user(id):
users = db.query("SELECT * FROM users WHERE id = " + str(id))
return users[0]
"""
)
6.5 組み込みツール — Web 検索
# Web検索ツールの使用
response = client.responses.create(
model="gpt-4.1",
tools=[{"type": "web_search_preview"}],
input="2026年の主要なAIカンファレンスの日程を教えてください"
)
print(response.output_text)
# 検索結果のソース（引用）にアクセス
for item in response.output:
if item.type == "message":
for annotation in item.content[0].annotations:
print(f" 出典: {annotation.url} - {annotation.title}")
6.6 組み込みツール — ファイル検索
# ベクトルストアの作成
vector_store = client.vector_stores.create(
name="社内ドキュメント"
)
# ファイルのアップロードと追加
file = client.files.create(
file=open("company_policy.pdf", "rb"),
purpose="assistants"
)
client.vector_stores.files.create(
vector_store_id=vector_store.id,
file_id=file.id
)
# ファイル検索ツールを使った質問
response = client.responses.create(
model="gpt-4.1",
tools=[{
"type": "file_search",
"vector_store_ids": [vector_store.id]
}],
input="有給休暇の申請方法を教えてください"
)
6.7 組み込みツール — コード実行（Code Interpreter）
response = client.responses.create(
model="gpt-4.1",
tools=[{
"type": "code_interpreter",
"container": {"type": "auto"} # 自動コンテナ管理
}],
input="フィボナッチ数列の最初の20項を計算し、成長率をグラフにしてください"
)
# 生成されたファイル（画像等）へのアクセス
for item in response.output:
if hasattr(item, 'content'):
for content in item.content:
if hasattr(content, 'file_id'):
print(f"生成ファイル: {content.file_id}")
6.8 Chat Completions API vs Responses API 比較
| 機能 | Chat Completions | Responses |
|---|---|---|
| ステートフルな会話 | クライアント管理 | previous_response_id |
| Web検索 | 外部実装が必要 | 組み込み |
| ファイル検索 | Assistants API 経由 | 組み込み |
| コード実行 | Assistants API 経由 | 組み込み |
| MCP連携 | 非対応 | 対応 |
| Function Calling | 対応 | 対応 |
| Structured Output | 対応 | 対応 |
| ストリーミング | チャンクベース | イベントベース |
| o モデル対応 | 対応 | 対応（推奨） |
7. Assistants API
7.1 概要
Assistants API は、ステートフルなAIアシスタントを構築するための高レベルAPIである。スレッドベースの会話管理、ツール統合、ファイル処理を組み込みでサポートする。
注意: OpenAI は 2025年以降、Assistants API の代わりに Responses API の使用を推奨している。ただし Assistants API は引き続き利用可能。
7.2 アーキテクチャ
┌─────────────────────────────────────────────┐
│ Assistant │
│ ┌──────────────────────────────────────────┐│
│ │ Instructions (システムプロンプト) ││
│ │ Model (使用モデル) ││
│ │ Tools (code_interpreter, file_search, ││
│ │ function calling) ││
│ └──────────────────────────────────────────┘│
│ │
│ Thread ─────────────────────────────────── │
│ │ Message 1 (user) │
│ │ Message 2 (assistant) │
│ │ Message 3 (user) │
│ │ ... │
│ └──────────────── Run ──────────────────── │
│ │ │
│ ├─ queued │
│ ├─ in_progress │
│ ├─ requires_action │
│ ├─ completed │
│ └─ failed / cancelled │
└─────────────────────────────────────────────┘
7.3 基本的なワークフロー
from openai import OpenAI
client = OpenAI()
# 1. アシスタントの作成
assistant = client.beta.assistants.create(
name="データ分析アシスタント",
instructions="""あなたはデータ分析の専門家です。
ユーザーがアップロードしたデータを分析し、
インサイトを日本語で提供してください。""",
model="gpt-4o",
tools=[
{"type": "code_interpreter"},
{"type": "file_search"}
]
)
# 2. スレッドの作成
thread = client.beta.threads.create()
# 3. メッセージの追加
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="売上データの傾向分析をお願いします",
attachments=[{
"file_id": "file-abc123",
"tools": [{"type": "code_interpreter"}]
}]
)
# 4. Run の実行（ストリーミング）
from openai import AssistantEventHandler
class EventHandler(AssistantEventHandler):
def on_text_created(self, text):
print("\nassistant > ", end="", flush=True)
def on_text_delta(self, delta, snapshot):
print(delta.value, end="", flush=True)
def on_tool_call_created(self, tool_call):
print(f"\n[ツール呼出: {tool_call.type}]", flush=True)
with client.beta.threads.runs.stream(
thread_id=thread.id,
assistant_id=assistant.id,
event_handler=EventHandler()
) as stream:
stream.until_done()
8. Function Calling / Tool Use
8.1 概要
Function Calling（ツール使用）は、LLMが外部のAPIやデータベース、計算ロジックと連携するための仕組みである。モデルが「どの関数をどの引数で呼ぶべきか」を判断し、開発者はその結果を実行してモデルに返す。
8.2 動作フロー
ユーザー入力
│
▼
┌──────────┐ ┌──────────────────┐
│ OpenAI │────▶│ ツール呼出し判断 │
│ Model │ │ (引数のJSON生成) │
└──────────┘ └──────────────────┘
│
▼
┌──────────────────┐
│ 開発者がローカルで │
│ 関数を実行 │
└──────────────────┘
│
▼
┌──────────────────┐
│ 実行結果をモデルに │
│ フィードバック │
└──────────────────┘
│
▼
┌──────────────────┐
│ 最終応答を生成 │
└──────────────────┘
8.3 Chat Completions API での Function Calling
import json
from openai import OpenAI
client = OpenAI()
# ツール（関数）の定義
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "指定した都市の現在の天気を取得する",
"strict": True, # Structured Output で引数を保証
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "都市名（例: 東京、大阪）"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "温度の単位"
}
},
"required": ["city", "unit"],
"additionalProperties": False
}
}
},
{
"type": "function",
"function": {
"name": "search_restaurants",
"description": "指定エリアのレストランを検索する",
"strict": True,
"parameters": {
"type": "object",
"properties": {
"area": {
"type": "string",
"description": "検索エリア"
},
"cuisine": {
"type": "string",
"enum": ["japanese", "italian", "chinese", "french", "other"],
"description": "料理ジャンル"
},
"budget_max": {
"type": "integer",
"description": "予算上限（円）"
}
},
"required": ["area", "cuisine", "budget_max"],
"additionalProperties": False
}
}
}
]
# 実際の関数実装（通常は外部APIを呼び出す）
def get_weather(city: str, unit: str) -> dict:
# 実際にはWeather APIを呼び出す
return {"city": city, "temperature": 22, "unit": unit, "condition": "晴れ"}
def search_restaurants(area: str, cuisine: str, budget_max: int) -> dict:
return {"results": [{"name": "和食処たなか", "rating": 4.5, "price": 3000}]}
# ツール呼出しを含む会話ループ
messages = [
{"role": "user", "content": "東京の天気を教えて、あとランチで良い和食のお店ある？予算5000円くらいで"}
]
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools,
tool_choice="auto" # モデルが自動判断
)
# ツール呼出しの処理（パラレル呼出し対応）
if response.choices[0].message.tool_calls:
messages.append(response.choices[0].message)
for tool_call in response.choices[0].message.tool_calls:
func_name = tool_call.function.name
func_args = json.loads(tool_call.function.arguments)
# 関数の実行
if func_name == "get_weather":
result = get_weather(**func_args)
elif func_name == "search_restaurants":
result = search_restaurants(**func_args)
# 結果をメッセージに追加
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result, ensure_ascii=False)
})
# 最終応答を取得
final_response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
8.4 Responses API での Function Calling
response = client.responses.create(
model="gpt-4.1",
tools=[
{
"type": "function",
"name": "get_weather",
"description": "指定した都市の天気を取得",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string"},
"unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
},
"required": ["city", "unit"],
"additionalProperties": False
},
"strict": True
}
],
input="東京の今日の天気は？"
)
# ツール呼出しの処理
for item in response.output:
if item.type == "function_call":
# 関数実行
result = get_weather(**json.loads(item.arguments))
# 結果を返して最終応答を取得
final = client.responses.create(
model="gpt-4.1",
previous_response_id=response.id,
input=[{
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(result, ensure_ascii=False)
}]
)
print(final.output_text)
8.5 並列 Function Calling
GPT-4o 以降のモデルは、1回のレスポンスで複数のツールを同時に呼び出すことができる（Parallel Function Calling）。これにより、独立した複数のAPIコールを並行して実行でき、レイテンシーの削減が可能となる。
# モデルが「天気API」と「レストランAPI」を同時に呼ぶ場合
# response.choices[0].message.tool_calls に複数のエントリが含まれる
# → 並行してAPIを呼び出し、全結果をまとめて返す
import asyncio
async def execute_parallel_tools(tool_calls):
"""ツール呼出しを並列実行"""
tasks = []
for tc in tool_calls:
args = json.loads(tc.function.arguments)
if tc.function.name == "get_weather":
tasks.append(async_get_weather(**args))
elif tc.function.name == "search_restaurants":
tasks.append(async_search_restaurants(**args))
return await asyncio.gather(*tasks)
9. Embeddings API
9.1 概要
Embeddings API は、テキストを高次元のベクトル（浮動小数点数の配列）に変換するAPIである。このベクトルはテキストの意味的な情報をエンコードしており、以下の用途に使用される。
- 意味検索（Semantic Search）: クエリとドキュメントの類似度計算
- RAG（Retrieval Augmented Generation）: 関連ドキュメントの検索と取得
- 分類: テキストのカテゴリ分け
- クラスタリング: 類似テキストのグループ化
- 異常検出: 外れ値の検出
9.2 利用可能なモデル
| モデル | 次元数 | 最大入力トークン | 特徴 |
|---|---|---|---|
| text-embedding-3-large | 3,072（デフォルト） | 8,191 | 最高精度 |
| text-embedding-3-small | 1,536（デフォルト） | 8,191 | コスト効率重視 |
| text-embedding-ada-002 | 1,536 | 8,191 | レガシー |
9.3 基本的な使用方法
from openai import OpenAI
client = OpenAI()
# 単一テキストの埋め込み
response = client.embeddings.create(
model="text-embedding-3-small",
input="OpenAIは人工知能研究の最前線にある企業です",
dimensions=512 # 次元数を削減してコスト・速度を最適化
)
embedding = response.data[0].embedding
print(f"次元数: {len(embedding)}") # 512
print(f"先頭5要素: {embedding[:5]}")
# バッチ処理（複数テキスト）
texts = [
"機械学習の基本概念",
"ディープラーニングの応用",
"自然言語処理の最新動向"
]
response = client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
for i, data in enumerate(response.data):
print(f"テキスト{i}: {len(data.embedding)}次元")
9.4 類似度計算と検索の実装例
import numpy as np
from openai import OpenAI
client = OpenAI()
def cosine_similarity(a, b):
"""コサイン類似度の計算"""
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
# ドキュメントの埋め込み
documents = [
"Python は汎用プログラミング言語です",
"東京タワーは東京都港区にあります",
"機械学習はAIの一分野です",
"寿司は日本の伝統的な料理です",
"TensorFlow はGoogleが開発した機械学習フレームワークです"
]
doc_response = client.embeddings.create(
model="text-embedding-3-small",
input=documents
)
doc_embeddings = [d.embedding for d in doc_response.data]
# クエリの埋め込み
query = "AIプログラミングについて教えて"
query_response = client.embeddings.create(
model="text-embedding-3-small",
input=query
)
query_embedding = query_response.data[0].embedding
# 類似度ランキング
similarities = []
for i, doc_emb in enumerate(doc_embeddings):
sim = cosine_similarity(query_embedding, doc_emb)
similarities.append((sim, documents[i]))
similarities.sort(reverse=True)
for sim, doc in similarities:
print(f" 類似度: {sim:.4f} | {doc}")
9.5 RAG（Retrieval Augmented Generation）パイプライン
class SimpleRAG:
def __init__(self, model="text-embedding-3-small"):
self.client = OpenAI()
self.embed_model = model
self.documents = []
self.embeddings = []
def add_documents(self, docs: list[str]):
"""ドキュメントを追加"""
response = self.client.embeddings.create(
model=self.embed_model,
input=docs
)
self.documents.extend(docs)
self.embeddings.extend([d.embedding for d in response.data])
def query(self, question: str, top_k: int = 3) -> str:
"""質問に回答"""
# 1. 質問の埋め込み
q_response = self.client.embeddings.create(
model=self.embed_model,
input=question
)
q_embedding = q_response.data[0].embedding
# 2. 関連ドキュメントの検索
similarities = []
for i, emb in enumerate(self.embeddings):
sim = cosine_similarity(q_embedding, emb)
similarities.append((sim, self.documents[i]))
similarities.sort(reverse=True)
relevant_docs = [doc for _, doc in similarities[:top_k]]
# 3. コンテキスト付きで生成
context = "\n".join(relevant_docs)
response = self.client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": f"以下の参考情報に基づいて回答してください:\n\n{context}"},
{"role": "user", "content": question}
]
)
return response.choices[0].message.content
# 使用例
rag = SimpleRAG()
rag.add_documents([
"当社の有給休暇は年間20日です。入社半年後から取得可能です。",
"リモートワークは週3日まで可能です。事前申請が必要です。",
"交通費は月額5万円まで支給されます。",
# ... 多数のドキュメント
])
answer = rag.query("有給休暇は何日もらえますか？")
print(answer)
10. 画像生成 — DALL·E / GPT Image Generation
10.1 概要
OpenAI は2つの画像生成アプローチを提供している。
- DALL·E 3: 専用の画像生成モデル（Images API 経由）
- GPT Image Generation: GPT-4o に組み込まれた画像生成機能
10.2 DALL·E 3 による画像生成
from openai import OpenAI
client = OpenAI()
# 基本的な画像生成
response = client.images.generate(
model="dall-e-3",
prompt="富士山の前に咲く桜の木、日本画風、穏やかな春の朝",
size="1024x1024", # 1024x1024, 1024x1792, 1792x1024
quality="hd", # standard, hd
style="natural", # vivid, natural
n=1 # DALL·E 3 は 1枚のみ
)
image_url = response.data[0].url
revised_prompt = response.data[0].revised_prompt # モデルが改良したプロンプト
print(f"画像URL: {image_url}")
print(f"改良プロンプト: {revised_prompt}")
10.3 GPT-4o による画像生成（GPT Image Generation）
# Responses API 経由での画像生成
response = client.responses.create(
model="gpt-4o",
input="東京の夜景をサイバーパンク風に描いてください",
tools=[{"type": "image_generation"}]
)
# 生成された画像の取得
for item in response.output:
if hasattr(item, 'result'):
# Base64エンコードされた画像データ
import base64
image_data = base64.b64decode(item.result)
with open("tokyo_cyberpunk.png", "wb") as f:
f.write(image_data)
10.4 画像編集
# DALL·E 2 による画像編集（マスクベース）
response = client.images.edit(
model="dall-e-2",
image=open("original.png", "rb"),
mask=open("mask.png", "rb"), # 編集領域を示すマスク
prompt="赤い花を追加",
size="1024x1024",
n=1
)
10.5 画像のバリエーション生成
response = client.images.create_variation(
model="dall-e-2",
image=open("original.png", "rb"),
size="1024x1024",
n=3 # 3つのバリエーション
)
for i, data in enumerate(response.data):
print(f"バリエーション {i+1}: {data.url}")
10.6 DALL·E 3 vs GPT Image Generation の比較
| 機能 | DALL·E 3 | GPT Image Generation |
|---|---|---|
| API | Images API | Responses API / Chat Completions |
| テキスト描画 | 限定的 | 高精度 |
| 画像編集 | マスクベース(DALL·E 2) | テキスト指示による自然な編集 |
| スタイル制御 | vivid/natural | プロンプトで柔軟に制御 |
| 会話コンテキスト | なし | あり（前の会話を考慮） |
| 出力形式 | URL or Base64 | Base64 |
11. 音声 API — Whisper / TTS
11.1 音声認識 — Whisper
Whisper は OpenAI が開発した汎用音声認識モデルで、多言語対応、翻訳機能を持つ。
基本的な文字起こし
from openai import OpenAI
client = OpenAI()
# 音声ファイルの文字起こし
with open("meeting_recording.mp3", "rb") as audio_file:
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
language="ja", # 言語ヒント（省略可能）
response_format="verbose_json", # json, text, srt, verbose_json, vtt
timestamp_granularities=["word", "segment"] # タイムスタンプの粒度
)
print(transcript.text)
# セグメント（タイムスタンプ付き）の表示
for segment in transcript.segments:
print(f"[{segment.start:.1f}s - {segment.end:.1f}s] {segment.text}")
音声翻訳（任意の言語 → 英語）
with open("japanese_speech.mp3", "rb") as audio_file:
translation = client.audio.translations.create(
model="whisper-1",
file=audio_file,
response_format="text"
)
print(translation) # 英語のテキストが出力される
対応フォーマットと制限
| 項目 | 値 |
|---|---|
| 対応フォーマット | mp3, mp4, mpeg, mpga, m4a, wav, webm |
| 最大ファイルサイズ | 25MB |
| 対応言語 | 50以上の言語 |
| 長時間音声の処理 | チャンク分割が必要 |
長時間音声の処理例
from pydub import AudioSegment
import io
def transcribe_long_audio(file_path: str, chunk_length_ms: int = 600000):
"""長時間音声を10分ごとに分割して文字起こし"""
audio = AudioSegment.from_file(file_path)
full_transcript = []
for i in range(0, len(audio), chunk_length_ms):
chunk = audio[i:i + chunk_length_ms]
# チャンクをバッファに書き出し
buffer = io.BytesIO()
chunk.export(buffer, format="mp3")
buffer.name = "chunk.mp3"
buffer.seek(0)
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=buffer,
language="ja"
)
full_transcript.append(transcript.text)
return " ".join(full_transcript)
11.2 音声合成 — TTS
基本的な音声生成
# テキストから音声を生成
response = client.audio.speech.create(
model="tts-1", # tts-1（高速）または tts-1-hd（高品質）
voice="nova", # alloy, echo, fable, onyx, nova, shimmer
input="こんにちは。本日はOpenAIの技術概要についてご説明します。",
speed=1.0, # 0.25〜4.0
response_format="mp3" # mp3, opus, aac, flac, wav, pcm
)
# ファイルに保存
with open("output.mp3", "wb") as f:
for chunk in response.iter_bytes():
f.write(chunk)
ストリーミング音声生成
# リアルタイムストリーミング
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice="nova",
input="ストリーミングで音声を生成しています。"
) as response:
response.stream_to_file("stream_output.mp3")
音声の種類
| Voice ID | 特徴 |
|---|---|
alloy | ニュートラル、汎用的 |
echo | 落ち着いた男性的な声 |
fable | 表現力豊か、ストーリーテリング向き |
onyx | 深く力強い声 |
nova | 明るく活発な声 |
shimmer | 温かみのある声 |
12. マルチモーダル入力（Vision）
12.1 概要
GPT-4o、GPT-4.1、GPT-4 Turbo は画像を入力として受け付け、画像の内容を理解・分析できる（Vision 機能）。
12.2 画像入力の方法
# 方法1: URL指定
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "この画像に何が写っていますか？"},
{
"type": "image_url",
"image_url": {
"url": "https://example.com/photo.jpg",
"detail": "high" # low, high, auto
}
}
]
}
]
)
# 方法2: Base64エンコード
import base64
with open("screenshot.png", "rb") as image_file:
base64_image = base64.standard_b64encode(image_file.read()).decode("utf-8")
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "このスクリーンショットのUIを分析してください"},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{base64_image}",
"detail": "high"
}
}
]
}
]
)
12.3 detail パラメータの影響
| detail | 動作 | トークン消費 | 推奨用途 |
|---|---|---|---|
low | 512x512 に縮小して処理 | 85 トークン固定 | 大まかな理解で十分な場合 |
high | 高解像度で詳細に処理 | 最大 1,105 トークン | OCR、詳細分析 |
auto | モデルが自動判断 | 可変 | 一般的な用途 |
12.4 複数画像の比較分析
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "これら2つのグラフを比較して、主な違いを分析してください"},
{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{graph1_b64}"}
},
{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{graph2_b64}"}
}
]
}
]
)
12.5 Vision の実用例
- OCR/文書解析: 請求書、レシート、手書きメモの読み取り
- UI/UXレビュー: スクリーンショットからUIの問題点を指摘
- コードレビュー: コードのスクリーンショットからバグを発見
- データ可視化分析: グラフ・チャートの内容解釈
- アクセシビリティ: 画像の代替テキスト生成
13. Realtime API
13.1 概要
Realtime API は、低レイテンシーの音声対話を実現するAPIである。音声入力をリアルタイムで処理し、音声出力を生成する。WebSocket または WebRTC 接続を使用する。
13.2 接続方式の比較
| 項目 | WebSocket | WebRTC |
|---|---|---|
| 接続元 | サーバーサイド | ブラウザ/クライアント |
| 認証 | APIキー | エフェメラルトークン |
| レイテンシー | 低い | 最も低い（P2Pに近い） |
| 用途 | バックエンド統合 | クライアントアプリ |
13.3 WebSocket 接続例
import asyncio
import websockets
import json
import base64
async def realtime_session():
url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview"
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}",
"OpenAI-Beta": "realtime=v1"
}
async with websockets.connect(url, extra_headers=headers) as ws:
# セッション設定
await ws.send(json.dumps({
"type": "session.update",
"session": {
"modalities": ["text", "audio"],
"instructions": "あなたは日本語で会話する親切なアシスタントです。",
"voice": "nova",
"input_audio_format": "pcm16",
"output_audio_format": "pcm16",
"input_audio_transcription": {
"model": "whisper-1"
},
"turn_detection": {
"type": "server_vad", # サーバーサイドの音声検出
"threshold": 0.5,
"prefix_padding_ms": 300,
"silence_duration_ms": 500
},
"tools": [
{
"type": "function",
"name": "get_time",
"description": "現在の時刻を取得",
"parameters": {
"type": "object",
"properties": {},
"required": []
}
}
]
}
}))
# イベントループ
async for message in ws:
event = json.loads(message)
match event["type"]:
case "session.created":
print("セッション開始")
case "response.audio.delta":
# 音声データの受信（Base64エンコード）
audio_chunk = base64.b64decode(event["delta"])
# オーディオプレイヤーに送信
case "response.audio_transcript.delta":
# 応答のテキスト版
print(event["delta"], end="", flush=True)
case "input_audio_buffer.speech_started":
print("\n[発話検出]")
case "response.function_call_arguments.done":
# ツール呼出しの処理
pass
asyncio.run(realtime_session())
13.4 WebRTC 接続（ブラウザ向け）
// エフェメラルトークンの取得（サーバーサイドで実行）
// POST https://api.openai.com/v1/realtime/sessions
// → { client_secret: { value: "ek_..." } }
// ブラウザでの WebRTC 接続
async function startRealtimeSession(ephemeralToken) {
const pc = new RTCPeerConnection();
// マイク入力の追加
const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
stream.getTracks().forEach(track => pc.addTrack(track, stream));
// 音声出力の処理
pc.ontrack = (event) => {
const audioEl = document.createElement('audio');
audioEl.srcObject = event.streams[0];
audioEl.autoplay = true;
document.body.appendChild(audioEl);
};
// データチャネル（イベント受信用）
const dc = pc.createDataChannel('oai-events');
dc.onmessage = (event) => {
const data = JSON.parse(event.data);
console.log('Event:', data.type);
};
// SDP オファーの作成
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
// OpenAI に SDP を送信
const response = await fetch(
'https://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview',
{
method: 'POST',
headers: {
'Authorization': `Bearer ${ephemeralToken}`,
'Content-Type': 'application/sdp'
},
body: offer.sdp
}
);
const answerSdp = await response.text();
await pc.setRemoteDescription({ type: 'answer', sdp: answerSdp });
}
13.5 Realtime API の料金体系
| 項目 | 料金 (GPT-4o Realtime) |
|---|---|
| テキスト入力 | $5.00 / 1M tokens |
| テキスト出力 | $20.00 / 1M tokens |
| 音声入力 | $40.00 / 1M tokens |
| 音声出力 | $80.00 / 1M tokens |
14. Fine-tuning（ファインチューニング）
14.1 概要
ファインチューニングは、既存のモデルを独自のデータセットで追加学習させ、特定のタスクに最適化する機能である。以下のような場合に有効。
- 品質の向上: プロンプトだけでは達成できない出力品質が必要な場合
- レイテンシーの削減: 長いプロンプトの代わりにモデルに知識を組み込む
- コスト削減: 短いプロンプトで同等の品質を実現
- 一貫したスタイル: ブランドのトーン・フォーマットの統一
14.2 対応モデル
| モデル | ファインチューニング | 特徴 |
|---|---|---|
| GPT-4o | 対応 | 最新の高性能モデル |
| GPT-4o mini | 対応 | コスト効率重視 |
| GPT-4.1 | 対応 | 長コンテキスト対応 |
| GPT-4.1 mini | 対応 | 軽量版 |
| GPT-4.1 nano | 対応 | 最軽量 |
| o4-mini | 対応（推論モデル） | 推論タスク特化 |
| GPT-3.5 Turbo | 対応 | レガシー |
14.3 データ準備
// training_data.jsonl — JSONL形式
{"messages": [{"role": "system", "content": "あなたはカスタマーサポートの専門家です。"}, {"role": "user", "content": "返品したいのですが"}, {"role": "assistant", "content": "承知いたしました。ご注文番号をお教えいただけますか？返品の手続きをお手伝いいたします。"}]}
{"messages": [{"role": "system", "content": "あなたはカスタマーサポートの専門家です。"}, {"role": "user", "content": "配送状況を知りたい"}, {"role": "assistant", "content": "配送状況の確認ですね。ご注文番号をお知らせいただけますか？最新のステータスをお調べいたします。"}]}
14.4 ファインチューニングの実行
from openai import OpenAI
client = OpenAI()
# 1. 訓練データのアップロード
training_file = client.files.create(
file=open("training_data.jsonl", "rb"),
purpose="fine-tune"
)
# 2. (オプション) 検証データのアップロード
validation_file = client.files.create(
file=open("validation_data.jsonl", "rb"),
purpose="fine-tune"
)
# 3. ファインチューニングジョブの作成
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
validation_file=validation_file.id,
model="gpt-4o-mini-2024-07-18",
hyperparameters={
"n_epochs": 3, # エポック数（auto で自動設定）
"batch_size": "auto", # バッチサイズ
"learning_rate_multiplier": "auto" # 学習率の倍率
},
suffix="customer-support-v1" # モデル名のサフィックス
)
print(f"Job ID: {job.id}")
print(f"Status: {job.status}")
# 4. ジョブの監視
import time
while True:
job = client.fine_tuning.jobs.retrieve(job.id)
print(f"Status: {job.status}")
if job.status in ["succeeded", "failed", "cancelled"]:
break
time.sleep(60)
# 5. ファインチューニングモデルの使用
if job.status == "succeeded":
fine_tuned_model = job.fine_tuned_model
print(f"Model: {fine_tuned_model}")
response = client.chat.completions.create(
model=fine_tuned_model, # ft:gpt-4o-mini-2024-07-18:org:customer-support-v1:abc123
messages=[
{"role": "system", "content": "あなたはカスタマーサポートの専門家です。"},
{"role": "user", "content": "商品が届かないのですが"}
]
)
print(response.choices[0].message.content)
14.5 推論モデル (o4-mini) のファインチューニング
推論モデルのファインチューニングでは、"thinking" プロセスも学習データに含めることができる。
{"messages": [{"role": "user", "content": "この数学の問題を解いてください: ..."}, {"role": "assistant", "content": [{"type": "thinking", "thinking": "まず問題を分解して..."}, {"type": "text", "text": "答えは42です。理由は..."}]}]}
14.6 ファインチューニングのベストプラクティス
| 項目 | 推奨 |
|---|---|
| データ量 | 最低50例、推奨500-1000例 |
| データ品質 | 一貫性があり高品質なデータ |
| 評価 | 検証データセットで定量評価 |
| イテレーション | 小規模で開始し段階的に改善 |
| プロンプトの併用 | FT後もシステムプロンプトは有効活用 |
15. Batch API
15.1 概要
Batch API は、大量のリクエストを一括で非同期処理するAPIである。通常のAPI料金の50%割引で利用でき、24時間以内に処理が完了する。
15.2 対応エンドポイント
/v1/chat/completions/v1/responses/v1/embeddings
15.3 バッチ処理の手順
from openai import OpenAI
import json
client = OpenAI()
# 1. バッチ入力ファイルの作成 (JSONL)
requests = []
for i, question in enumerate(["質問1", "質問2", "質問3"]):
requests.append({
"custom_id": f"request-{i}",
"method": "POST",
"url": "/v1/chat/completions",
"body": {
"model": "gpt-4o-mini",
"messages": [
{"role": "system", "content": "簡潔に回答してください。"},
{"role": "user", "content": question}
],
"max_tokens": 500
}
})
# JSONL ファイルに書き出し
with open("batch_input.jsonl", "w") as f:
for req in requests:
f.write(json.dumps(req) + "\n")
# 2. ファイルのアップロード
batch_file = client.files.create(
file=open("batch_input.jsonl", "rb"),
purpose="batch"
)
# 3. バッチジョブの作成
batch = client.batches.create(
input_file_id=batch_file.id,
endpoint="/v1/chat/completions",
completion_window="24h",
metadata={
"description": "週次レポート生成バッチ"
}
)
print(f"Batch ID: {batch.id}")
print(f"Status: {batch.status}")
# 4. ステータスの確認
batch = client.batches.retrieve(batch.id)
print(f"Status: {batch.status}")
print(f"Completed: {batch.request_counts.completed}/{batch.request_counts.total}")
# 5. 結果の取得
if batch.status == "completed":
result_file = client.files.content(batch.output_file_id)
for line in result_file.text.strip().split("\n"):
result = json.loads(line)
custom_id = result["custom_id"]
content = result["response"]["body"]["choices"][0]["message"]["content"]
print(f"{custom_id}: {content}")
15.4 コスト比較
| 処理方式 | 料金 | レイテンシー | 制限 |
|---|---|---|---|
| 同期API | 通常料金 | 秒単位 | レート制限あり |
| Batch API | 50%割引 | 最大24時間 | 大量処理向き |
Batch API は、大規模なデータ処理、定期的なレポート生成、ドキュメントの一括分析など、即時性が不要な処理に最適である。
16. Agents SDK
16.1 概要
OpenAI Agents SDK は、LLMを活用したエージェントアプリケーションを構築するための公式フレームワークである。Python で提供され、以下のコアプリミティブを持つ。
- Agent: LLMに指示・ツール・ガードレールを設定したエンティティ
- Handoff: エージェント間のタスク委譲
- Guardrail: 入出力の検証・フィルタリング
- Tracing: 実行の可視化とデバッグ
16.2 基本的なエージェント
from agents import Agent, Runner
# エージェントの定義
agent = Agent(
name="カスタマーサポート",
instructions="""あなたはECサイトのカスタマーサポートエージェントです。
顧客からの問い合わせに丁寧に対応してください。
返品・交換・配送に関する質問に答えられます。""",
model="gpt-4.1"
)
# エージェントの実行
result = Runner.run_sync(
agent,
"注文した商品が3日経っても届きません。注文番号は#12345です。"
)
print(result.final_output)
16.3 ツール付きエージェント
from agents import Agent, Runner, function_tool
@function_tool
def check_order_status(order_id: str) -> str:
"""注文の配送状況を確認する"""
# 実際にはDBやAPI呼出し
return f"注文 {order_id}: 発送済み。到着予定: 2026年4月9日"
@function_tool
def initiate_return(order_id: str, reason: str) -> str:
"""返品手続きを開始する"""
return f"注文 {order_id} の返品手続きを開始しました。理由: {reason}"
agent = Agent(
name="サポートエージェント",
instructions="顧客の問い合わせに対応し、必要に応じてツールを使用してください。",
model="gpt-4.1",
tools=[check_order_status, initiate_return]
)
result = Runner.run_sync(agent, "注文#12345の状況を教えてください")
16.4 マルチエージェントとハンドオフ
from agents import Agent, Runner
# 専門エージェントの定義
billing_agent = Agent(
name="請求担当",
instructions="請求・支払いに関する問い合わせに対応します。",
model="gpt-4.1",
tools=[check_billing, process_refund]
)
shipping_agent = Agent(
name="配送担当",
instructions="配送・追跡に関する問い合わせに対応します。",
model="gpt-4.1",
tools=[track_package, reschedule_delivery]
)
# トリアージエージェント（振り分け役）
triage_agent = Agent(
name="トリアージ",
instructions="""顧客の問い合わせ内容を判断し、適切な専門エージェントに引き継いでください。
- 請求・返金関連 → 請求担当
- 配送・追跡関連 → 配送担当""",
model="gpt-4.1",
handoffs=[billing_agent, shipping_agent]
)
# 実行
result = Runner.run_sync(
triage_agent,
"先月の請求額がおかしいのですが確認してもらえますか？"
)
# → triage_agent が billing_agent にハンドオフ
16.5 ガードレール
from agents import Agent, Runner, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel
class SafetyCheck(BaseModel):
is_safe: bool
reason: str
# 入力ガードレール
safety_guardrail = InputGuardrail(
name="安全性チェック",
guardrail_function=lambda ctx, agent, input: GuardrailFunctionOutput(
output_info=SafetyCheck(is_safe=True, reason=""),
tripwire_triggered=False
)
)
agent = Agent(
name="アシスタント",
instructions="ユーザーの質問に回答してください。",
model="gpt-4.1",
input_guardrails=[safety_guardrail]
)
16.6 MCP（Model Context Protocol）統合
from agents import Agent
from agents.mcp import MCPServerStdio
# MCPサーバーとの統合
mcp_server = MCPServerStdio(
name="ファイルシステム",
command="npx",
args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
)
agent = Agent(
name="ファイル管理エージェント",
instructions="ファイルシステムを操作して、ユーザーのリクエストに応えてください。",
model="gpt-4.1",
mcp_servers=[mcp_server]
)
17. コンテンツモデレーションと安全性
17.1 Moderation API
from openai import OpenAI
client = OpenAI()
response = client.moderations.create(
model="omni-moderation-latest", # テキスト+画像対応
input=[
{"type": "text", "text": "チェックしたいテキスト"},
{
"type": "image_url",
"image_url": {"url": "https://example.com/image.jpg"}
}
]
)
result = response.results[0]
print(f"フラグ付き: {result.flagged}")
for category, flagged in result.categories.dict().items():
if flagged:
score = getattr(result.category_scores, category)
print(f" {category}: スコア {score:.4f}")
17.2 検出カテゴリ
| カテゴリ | 説明 |
|---|---|
hate | 憎悪表現 |
hate/threatening | 脅迫を含む憎悪表現 |
harassment | ハラスメント |
harassment/threatening | 脅迫を含むハラスメント |
self-harm | 自傷行為 |
self-harm/intent | 自傷の意図 |
self-harm/instructions | 自傷の方法 |
sexual | 性的コンテンツ |
sexual/minors | 未成年に関する性的コンテンツ |
violence | 暴力 |
violence/graphic | 生々しい暴力描写 |
illicit | 違法行為 |
illicit/violent | 暴力的な違法行為 |
17.3 安全性のベストプラクティス
- 入力のサニタイズ: ユーザー入力をModeration APIで事前チェック
- 出力のフィルタリング: 生成されたコンテンツの事後チェック
- システムプロンプトの防御: プロンプトインジェクション対策
- レート制限の実装: 悪用防止のためのアプリケーションレベルの制限
- 監査ログ: すべてのAPI呼出しの記録
18. セキュリティ・コンプライアンス・データプライバシー
18.1 データ取り扱いポリシー
| 項目 | API利用 | ChatGPT |
|---|---|---|
| 学習への使用 | デフォルトで不使用 | オプトアウト可 |
| データ保持期間 | 30日間（不正利用監視） | 可変 |
| Zero Data Retention | 対象モデルで利用可 | N/A |
| 暗号化（転送時） | TLS 1.2+ | TLS 1.2+ |
| 暗号化（保存時） | AES-256 | AES-256 |
18.2 コンプライアンス認証
- SOC 2 Type II: セキュリティ、可用性、処理の整合性
- GDPR: EU一般データ保護規則準拠
- CCPA: カリフォルニア消費者プライバシー法準拠
- CSA STAR Level 1: クラウドセキュリティ
18.3 API キーのセキュリティ
# ✗ 悪い例: ハードコード
client = OpenAI(api_key="sk-abc123...")
# ✓ 良い例: 環境変数
import os
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
# ✓ さらに良い例: シークレット管理サービス
from your_secret_manager import get_secret
client = OpenAI(api_key=get_secret("openai-api-key"))
18.4 組織・プロジェクト管理
# プロジェクト単位でのアクセス制御
# 各プロジェクトに独立したAPIキー・レート制限を設定可能
# 組織の使用量確認
usage = client.organization.usage.completions.list(
start_time=1711929600, # Unix timestamp
end_time=1712016000
)
19. 料金体系と最適化戦略
19.1 主要モデルの料金（2025年時点）
| モデル | 入力 ($/1M tokens) | 出力 ($/1M tokens) | キャッシュ入力 |
|---|---|---|---|
| GPT-4.1 | $2.00 | $8.00 | $0.50 |
| GPT-4.1 mini | $0.40 | $1.60 | $0.10 |
| GPT-4.1 nano | $0.10 | $0.40 | $0.025 |
| GPT-4o | $2.50 | $10.00 | $1.25 |
| GPT-4o mini | $0.15 | $0.60 | $0.075 |
| GPT-4.5 Preview | $75.00 | $150.00 | $37.50 |
| o3 | $10.00 | $40.00 | $2.50 |
| o4-mini | $1.10 | $4.40 | $0.275 |
| その他サービス | 料金 |
|---|---|
| Whisper | $0.006 / 分 |
| TTS | $15.00 / 1M 文字 |
| TTS HD | $30.00 / 1M 文字 |
| DALL·E 3 (1024x1024) | $0.040 / 画像 |
| DALL·E 3 HD (1024x1024) | $0.080 / 画像 |
| Embedding (small) | $0.020 / 1M tokens |
| Embedding (large) | $0.130 / 1M tokens |
19.2 Prompt Caching（プロンプトキャッシュ）
同じプレフィックスを持つリクエストのキャッシュにより、入力トークンのコストが大幅に削減される。
# 長いシステムプロンプトをキャッシュ活用
# 最初のリクエスト: 全額課金
# 以降のリクエスト: キャッシュヒットで50-75%割引
# キャッシュの確認
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": very_long_system_prompt}, # キャッシュ対象
{"role": "user", "content": "質問1"}
]
)
# usage.prompt_tokens_details.cached_tokens でキャッシュ量を確認
print(f"キャッシュトークン: {response.usage.prompt_tokens_details.cached_tokens}")
19.3 コスト最適化の戦略
| 戦略 | 効果 | 実装難易度 |
|---|---|---|
| 適切なモデル選択 | 高（10-100x コスト差） | 低 |
| Prompt Caching | 中（50-75%削減） | 低 |
| Batch API | 中（50%割引） | 低 |
| max_tokens 制限 | 低〜中 | 低 |
| 埋め込み次元削減 | 低 | 低 |
| ファインチューニング | 中（短プロンプト化） | 高 |
| Predicted Outputs | 中（編集タスク） | 中 |
19.4 Predicted Outputs
編集タスクなど、出力の大部分が入力と同じ場合、予測出力を指定することで出力トークンのコストとレイテンシーを削減できる。
# コードの一部修正タスク
code = open("large_file.py").read()
response = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": f"以下のコードのバグを修正してください:\n\n{code}"}
],
prediction={
"type": "content",
"content": code # 出力の大部分が元のコードと同じと予測
}
)
20. ベストプラクティスと実践的設定例
20.1 プロンプトエンジニアリングのベストプラクティス
明確で具体的な指示
# ✗ 曖昧
messages = [
{"role": "user", "content": "このコードを改善して"}
]
# ✓ 具体的
messages = [
{"role": "system", "content": """あなたはシニアPythonエンジニアです。
コードレビューでは以下の観点で改善を提案してください:
1. パフォーマンス（時間/空間計算量）
2. 可読性（命名、構造）
3. エラーハンドリング
4. セキュリティ（インジェクション等）
各改善点は「問題」「影響」「修正案」の形式で記述してください。"""},
{"role": "user", "content": f"以下のコードをレビューしてください:\n\n```python\n{code}\n```"}
]
Few-shot 学習
messages = [
{"role": "system", "content": "ユーザーの質問を適切なカテゴリに分類してください。"},
{"role": "user", "content": "パスワードをリセットしたい"},
{"role": "assistant", "content": '{"category": "account", "subcategory": "password_reset", "priority": "medium"}'},
{"role": "user", "content": "注文した商品が届かない"},
{"role": "assistant", "content": '{"category": "shipping", "subcategory": "delivery_issue", "priority": "high"}'},
{"role": "user", "content": "返品の送料は誰が負担しますか？"}
]
20.2 本番環境でのアーキテクチャパターン
パターン1: ルーターパターン
# 軽量モデルで分類 → 適切なモデルで処理
def route_request(user_input: str):
# Step 1: GPT-4.1 nano で分類（低コスト）
classification = client.chat.completions.create(
model="gpt-4.1-nano-2025-04-14",
messages=[
{"role": "system", "content": "タスクを分類: simple/complex/reasoning"},
{"role": "user", "content": user_input}
],
max_tokens=10
)
task_type = classification.choices[0].message.content.strip()
# Step 2: 分類結果に応じたモデル選択
model_map = {
"simple": "gpt-4.1-nano-2025-04-14",
"complex": "gpt-4.1-2025-04-14",
"reasoning": "o4-mini"
}
model = model_map.get(task_type, "gpt-4.1-mini-2025-04-14")
# Step 3: 選択したモデルで処理
response = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": user_input}]
)
return response.choices[0].message.content
パターン2: RAG + Structured Output
from pydantic import BaseModel
class AnswerWithSources(BaseModel):
answer: str
confidence: float
sources: list[str]
follow_up_questions: list[str]
def answer_with_rag(question: str, vector_store_id: str):
# Responses API + ファイル検索 + Structured Output
response = client.responses.create(
model="gpt-4.1",
tools=[{
"type": "file_search",
"vector_store_ids": [vector_store_id]
}],
input=question,
text={
"format": {
"type": "json_schema",
"name": "answer_with_sources",
"strict": True,
"schema": AnswerWithSources.model_json_schema()
}
}
)
return AnswerWithSources.model_validate_json(response.output_text)
パターン3: エラー処理とフォールバック
import openai
def resilient_completion(messages, primary_model="gpt-4.1", fallback_model="gpt-4.1-mini"):
"""プライマリモデルが失敗した場合、フォールバックモデルを使用"""
try:
return client.chat.completions.create(
model=primary_model,
messages=messages,
timeout=30
)
except openai.RateLimitError:
# レート制限 → フォールバックモデル
return client.chat.completions.create(
model=fallback_model,
messages=messages,
timeout=30
)
except openai.APITimeoutError:
# タイムアウト → リトライ
return client.chat.completions.create(
model=fallback_model,
messages=messages,
timeout=60
)
20.3 監視とオブザーバビリティ
# 使用量の追跡
import logging
logger = logging.getLogger("openai_usage")
def tracked_completion(**kwargs):
response = client.chat.completions.create(**kwargs)
# 使用量のログ記録
usage = response.usage
logger.info(
"API Call",
extra={
"model": response.model,
"prompt_tokens": usage.prompt_tokens,
"completion_tokens": usage.completion_tokens,
"total_tokens": usage.total_tokens,
"cached_tokens": usage.prompt_tokens_details.cached_tokens,
"reasoning_tokens": usage.completion_tokens_details.reasoning_tokens,
}
)
return response
20.4 環境変数による設定管理
# .env ファイル（本番環境ではシークレット管理サービスを使用）
OPENAI_API_KEY=sk-proj-...
OPENAI_ORG_ID=org-...
OPENAI_PROJECT_ID=proj-...
OPENAI_DEFAULT_MODEL=gpt-4.1
OPENAI_TIMEOUT=60
OPENAI_MAX_RETRIES=3
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get("OPENAI_API_KEY"),
organization=os.environ.get("OPENAI_ORG_ID"),
project=os.environ.get("OPENAI_PROJECT_ID"),
timeout=float(os.environ.get("OPENAI_TIMEOUT", "60")),
max_retries=int(os.environ.get("OPENAI_MAX_RETRIES", "3"))
)
21. まとめ
21.1 OpenAI エコシステムの全体像
OpenAI は、基盤モデル（GPT、o シリーズ）を中心に、テキスト生成、画像生成、音声処理、埋め込み、モデレーションまでをカバーする包括的なAIプラットフォームを提供している。
┌─────────────────────────────────────────────────────┐
│ OpenAI Platform │
│ │
│ ┌─────────────┐ ┌──────────────┐ ┌────────────┐ │
│ │ Foundation │ │ Specialized │ │ Developer │ │
│ │ Models │ │ Models │ │ Tools │ │
│ │ │ │ │ │ │ │
│ │ GPT-4.1 │ │ DALL·E 3 │ │ API │ │
│ │ GPT-4o │ │ Whisper │ │ SDK │ │
│ │ GPT-4.5 │ │ TTS │ │ Agents SDK │ │
│ │ o3 / o4-mini │ │ Embeddings │ │ Playground │ │
│ │ GPT-4.1 nano │ │ Moderation │ │ Fine-tune │ │
│ └─────────────┘ └──────────────┘ └────────────┘ │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ API Interfaces │ │
│ │ Responses API | Chat Completions | Realtime │ │
│ │ Assistants | Batch | Images | Audio │ │
│ └──────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────┘
21.2 API 選択ガイド
| ユースケース | 推奨API |
|---|---|
| 新規プロジェクト | Responses API |
| ツール統合（Web検索、ファイル検索） | Responses API |
| 既存のChat Completionsからの移行 | 段階的に Responses API へ |
| リアルタイム音声対話 | Realtime API |
| 大量バッチ処理 | Batch API |
| マルチエージェント | Agents SDK |
21.3 今後の展望
OpenAI は以下の方向性で進化を続けている。
- AGI への段階的進化: o シリーズの推論能力の強化
- マルチモーダルの統合深化: テキスト・画像・音声・動画の統合処理
- エージェント機能の拡充: Operator、Codex CLI など自律的なAIエージェント
- コスト効率の改善: nano/mini モデルによる低コスト化
- 安全性とアライメント: より堅牢な安全機構の開発
- エンタープライズ対応: コンプライアンス、データ制御の強化
免責事項: 本記事の情報は2026年4月時点のものです。OpenAI のサービス・料金・機能は頻繁に更新されるため、最新情報は OpenAI 公式ドキュメント をご確認ください。