AI Agent 本番デプロイとエンジニアリング
本番デプロイは、信頼性、スケーラビリティ、コスト管理など複数の側面に関わります。
エンジニアリング実践により、システムの安定稼働を確保し、保守を容易にします。
本番デプロイアーキテクチャ
本番環境ではシステムに対するより高い要件があります。
信頼性、スケーラビリティ、監視・アラートなど複数の側面を考慮する必要があります。
デプロイモード
スタンドアロンデプロイ
開発・テスト環境に適しています。
シンプルでデプロイしやすいですが、本番レベルのトラフィックには対応できません。
分散デプロイ
本番環境に適しており、複数の側面を考慮する必要があります。
負荷分散:リクエストを複数のインスタンスに分散します。
サービスディスカバリー:インスタンスリストを動的に管理します。
状態管理:分散状態の一貫性問題を処理します。
フォールトトレランス処理:単一障害点が全体サービスに影響を与えません。
コンテナ化デプロイ
Dockerfile の例
FROM python:3.11-slim
# ワークディレクトリを設定
WORKDIR /app
# 依存関係をインストール
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# アプリケーションコードをコピー
COPY . .
# 非 root ユーザーを作成(セキュリティ上の考慮)
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser
# ポートを公開
EXPOSE 8000
# 起動コマンド
CMD ["python", "agent.py"]
Kubernetes デプロイ
Kubernetes Deployment の設定
apiVersion: apps/v1
kind: Deployment
metadata:
name: ai-agent
labels:
app: ai-agent
spec:
# レプリカ数
replicas: 3
selector:
matchLabels:
app: ai-agent
template:
metadata:
labels:
app: ai-agent
spec:
containers:
- name: agent
image: your-registry/ai-agent:latest
ports:
- containerPort: 8000
# リソース制限
resources:
limits:
memory: "2Gi"
cpu: "1"
requests:
memory: "1Gi"
cpu: "0.5"
# ヘルスチェック
livenessProbe:
httpGet:
path: /health
port: 8000
initialDelaySeconds: 10
periodSeconds: 30
readinessProbe:
httpGet:
path: /ready
port: 8000
initialDelaySeconds: 5
periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
name: ai-agent-service
spec:
selector:
app: ai-agent
ports:
- port: 80
targetPort: 8000
type: LoadBalancer
コスト管理
Agent システムのコストは主に LLM API 呼び出しによるものです。
コスト最適化は本番デプロイの重要な課題です。
Token最適化戦略
プロンプト圧縮:プロンプトを簡素化し、不要な文字を減らします。
コンテキストの切り詰め:重要なコンテキスト内容のみを保持します。
レスポンスのキャッシュ:同一または類似のクエリのレスポンスをキャッシュします。
コード実装
コスト最適化 Agent の実装
import json
from functools import lru_cache
class CostOptimizedAgent:
"""
コスト最適化された Agent
キャッシュと圧縮により API 呼び出しコストを削減します
"""
def __init__(self, base_agent, cache, embedder=None):
# 基本 Agent
self.base_agent = base_agent
# キャッシュストレージ
self.cache = cache
# エンベッダー(類似度キャッシュマッチング用)
self.embedder = embedder
def process(self, request):
"""
リクエストを処理し、コスト最適化ロジックを含む
"""
# リクエストフィンガープリントを生成
request_fingerprint = self.generate_fingerprint(request)
# 完全一致キャッシュを確認
cached_result = self.cache.get(request_fingerprint)
if cached_result:
return {
**cached_result,
"from_cache": True
}
# エンベッダーがある場合、セマンティック類似キャッシュを確認
if self.embedder:
similar = self.find_similar_cached(request)
if similar:
return {
**similar,
"from_cache": True,
"similar_to": similar.get("request_id")
}
# リクエストを実行
result = self.base_agent.process(request)
# 結果をキャッシュ
self.cache.set(
request_fingerprint,
result,
ttl=3600 # 1時間で期限切れ
)
return {
**result,
"from_cache": False
}
def generate_fingerprint(self, request):
"""
リクエストフィンガープリントを生成
完全一致キャッシュマッチングに使用
"""
content = json.dumps(request, sort_keys=True)
return hashlib.sha256(content.encode()).hexdigest()
def find_similar_cached(self, request, threshold=0.95):
"""
セマンティックに類似したキャッシュ結果を検索
エンベッディングベクトルのコサイン類似度を使用
"""
if not self.embedder:
return None
# リクエストをベクトル化
request_vector = self.embedder.embed([str(request)])[0]
# キャッシュ内で類似リクエストを検索
best_match = None
best_similarity = 0
for cached in self.cache.get_all():
cached_vector = cached["vector"]
similarity = cosine_similarity(request_vector, cached_vector)
if similarity > best_similarity and similarity >= threshold:
best_similarity = similarity
best_match = cached
return best_match
class ResponseCache:
"""
レスポンスキャッシュ
シンプルなインメモリキャッシュ実装
本番環境では Redis を使用可能
"""
def __init__(self):
self.cache = {}
self.timestamps = {}
def get(self, key):
"""キャッシュを取得"""
if key in self.cache:
# 期限切れかどうかを確認
if self.is_expired(key):
self.delete(key)
return None
return self.cache[key]
return None
def set(self, key, value, ttl=3600):
"""キャッシュを設定"""
self.cache[key] = value
self.timestamps[key] = time.time() + ttl
def delete(self, key):
"""キャッシュを削除"""
if key in self.cache:
del self.cache[key]
if key in self.timestamps:
del self.timestamps[key]
def is_expired(self, key):
"""期限切れかどうかを確認"""
if key not in self.timestamps:
return True
return time.time() > self.timestamps[key]
def get_all(self):
"""すべてのキャッシュ項目を取得"""
return list(self.cache.values())
def cosine_similarity(vec1, vec2):
"""コサイン類似度を計算"""
dot_product = sum(a * b for a, b in zip(vec1, vec2))
norm1 = math.sqrt(sum(a * a for a in vec1))
norm2 = math.sqrt(sum(b * b for b in vec2))
return dot_product / (norm1 * norm2)
ストリーミングと非同期
ストリーミングレスポンス
ストリーミングレスポンスは待ち時間を減らし、ユーザー体験を向上させます。
完全なレスポンスを待つ必要がなく、生成された内容を段階的に表示できます。
コード実装
ストリーミングレスポンス Agent
class StreamingAgent:
"""
ストリーミングレスポンスをサポートする Agent
生成しながら返却し、待ち時間を削減
"""
def __init__(self, llm):
self.llm = llm
async def stream_generate(self, prompt):
"""
レスポンスのストリーミング生成
async generator パターンを使用
:yield: 生成されたテキスト断片
"""
# 非同期生成タスクを開始
async for chunk in self.llm.stream_generate(prompt):
yield chunk
async def process_stream(self, request):
"""
ストリーミングリクエストを処理
非同期ジェネレーターを返す
"""
prompt = self.build_prompt(request)
# ジェネレーターを返す
async def generate():
async for chunk in self.stream_generate(prompt):
yield chunk
return generate()
# 使用例
async def main():
agent = StreamingAgent(llm)
# ストリーミング生成を開始
async for token in agent.stream_generate("量子計算を説明"):
# 生成しながらプリント
print(token, end="", flush=True)
print() # 改行
# 実行
asyncio.run(main())
非同期タスクキュー
長時間実行されるタスクには、非同期キューを使用して処理します。
ユーザーがタスクを送信するとすぐに返され、バックグラウンドで非同期に実行されます。
非同期タスクキューの実装
from queue import Queue
from threading import Thread
import uuid
class AsyncAgent:
"""
非同期 Agent
タスクキューを使用して長時間実行されるタスクを処理
"""
def __init__(self, agent, task_queue):
# 基本 Agent
self.agent = agent
# タスクキュー
self.task_queue = task_queue
# 結果ストレージ
self.results = {}
# バックグラウンドワーカースレッドを開始
self.worker_thread = Thread(target=self.process_queue, daemon=True)
self.worker_thread.start()
async def submit(self, task):
"""
タスクを送信
タスク ID をすぐに返す
"""
# 一意のタスク ID を生成
task_id = str(uuid.uuid4())
# キューに追加
await self.task_queue.enqueue({
"id": task_id,
"task": task,
"status": "pending",
"created_at": time.time()
})
return task_id
async def get_result(self, task_id):
"""
タスク結果を取得
ノンブロッキング方式
"""
if task_id in self.results:
return self.results[task_id]
# タスク状態を確認
status = await self.task_queue.get_status(task_id)
if status is None:
return None # タスクが存在しない
if status == "pending" or status == "processing":
return {
"status": status,
"result": None
}
return None
def process_queue(self):
"""
バックグラウンドワーカースレッド
キューからタスクを取り出して実行
"""
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
while True:
task = loop.run_until_complete(self.task_queue.dequeue())
if task:
# 状態を処理中に更新
loop.run_until_complete(
self.task_queue.update_status(task["id"], "processing")
)
try:
# タスクを実行
result = self.agent.process(task["task"])
# 結果を保存
self.results[task["id"]] = {
"status": "completed",
"result": result,
"completed_at": time.time()
}
loop.run_until_complete(
self.task_queue.update_status(task["id"], "completed")
)
except Exception as e:
self.results[task["id"]] = {
"status": "failed",
"error": str(e)
}
loop.run_until_complete(
self.task_queue.update_status(task["id"], "failed")
)
class TaskQueue:
"""シンプルなタスクキューの実装"""
def __init__(self):
self.queue = Queue()
self.statuses = {}
async def enqueue(self, task):
"""タスクをキューに追加"""
self.queue.put(task)
self.statuses[task["id"]] = "pending"
async def dequeue(self):
"""タスクを1つ取り出す"""
if not self.queue.empty():
return self.queue.get()
return None
async def get_status(self, task_id):
"""タスク状態を取得"""
return self.statuses.get(task_id)
async def update_status(self, task_id, status):
"""タスク状態を更新"""
self.statuses[task_id] = status
マイクロサービス化設計
Agent システムを複数の独立したサービスに分割し、保守性とスケーラビリティを向上させます。
サービスの分割
| サービス | 責務 |
|---|---|
| API ゲートウェイ | 統一エントリポイント、認証・レート制限、ルーティング転送 |
| Agent サービス | コアロジック、推論・計画 |
| ツールサービス | 外部 API 統合、ツール呼び出し |
| ストレージサービス | ナレッジベース、状態管理、キャッシュ |
| 監視サービス | ログ収集、メトリクス監視、アラート |
サービス間通信
同期通信:HTTP/gRPC。リアルタイムのリクエストレスポンスに使用します。
非同期通信:メッセージキュー。時間のかかる操作やイベント通知に使用します。
章のまとめ
この章では、本番デプロイとエンジニアリングの重要な実践を紹介しました。
本番デプロイアーキテクチャスタンドアロンから分散へ、段階的に拡張します。
コンテナ化デプロイDocker と Kubernetes を使用します。
コスト管理キャッシュと Token 最適化によりコストを削減します。
ストリーミングと非同期ユーザー体験とシステムスループットを向上させます。
マイクロサービス化設計システムの保守性とスケーラビリティを向上させます。
本番デプロイでは、信頼性、パフォーマンス、コストなど複数の側面を総合的に考慮する必要があります。
小規模から始めて、徐々に複雑さを増やすことをお勧めします。
その他の拡張