AI Agent 本番デプロイとエンジニアリング

本番デプロイは、信頼性、スケーラビリティ、コスト管理など複数の側面に関わります。

エンジニアリング実践により、システムの安定稼働を確保し、保守を容易にします。


本番デプロイアーキテクチャ

本番環境ではシステムに対するより高い要件があります。

信頼性、スケーラビリティ、監視・アラートなど複数の側面を考慮する必要があります。

デプロイモード

スタンドアロンデプロイ

開発・テスト環境に適しています。

シンプルでデプロイしやすいですが、本番レベルのトラフィックには対応できません。

分散デプロイ

本番環境に適しており、複数の側面を考慮する必要があります。

負荷分散:リクエストを複数のインスタンスに分散します。

サービスディスカバリー:インスタンスリストを動的に管理します。

状態管理:分散状態の一貫性問題を処理します。

フォールトトレランス処理:単一障害点が全体サービスに影響を与えません。

コンテナ化デプロイ

Dockerfile の例

# Python 3.11 イメージに基づく
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 の設定

span style="color: green;">
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 hashlib
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

import asyncio

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())

非同期タスクキュー

長時間実行されるタスクには、非同期キューを使用して処理します。

ユーザーがタスクを送信するとすぐに返され、バックグラウンドで非同期に実行されます。

非同期タスクキューの実装

import asyncio
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 最適化によりコストを削減します。

ストリーミングと非同期ユーザー体験とシステムスループットを向上させます。

マイクロサービス化設計システムの保守性とスケーラビリティを向上させます。

本番デプロイでは、信頼性、パフォーマンス、コストなど複数の側面を総合的に考慮する必要があります。

小規模から始めて、徐々に複雑さを増やすことをお勧めします。

その他の拡張