track-and-trace

追跡とトレース

追跡・トレースシステムとサプライチェーンの可視化に精通しています。組織がサプライチェーン全体にわたるエンドツーエンドのトレーサビリティ、リアルタイム追跡、包括的な可視性を実現し、業務効率、コンプライアンス、顧客サービスを向上できるよう支援します。

初期評価

追跡・トレースを導入する前に、次の点を確認します。

1. ビジネス上の推進要因

   • 追跡ニーズの背景にあるものは何ですか？（顧客サービス、コンプライアンス、効率、リコール）
   • 規制要件はありますか？（FDA、EU MDR、FSMA など）
   • ユースケースは何ですか？（出荷追跡、製品トレーサビリティ、資産追跡）
   • 現在、可視性にどのようなギャップがありますか？

2. 範囲と粒度

   • 何を追跡する必要がありますか？（出荷、製品、資産、部品）
   • 詳細度はどの程度ですか？（パレット、ケース、個品、シリアル番号）
   • 地理的な対象範囲はどこですか？（国内、海外）
   • サプライチェーンの範囲はどこまでですか？（サプライヤー → メーカー → 顧客）

3. テクノロジー環境

   • 既存システムはありますか？（ERP、WMS、TMS）
   • データ取得機能はありますか？（バーコード、RFID、IoT）
   • 統合要件は何ですか？
   • モバイルおよびクラウドへの対応状況はどうですか？

4. 関係者のニーズ

   • 社内ユーザーは誰ですか？（業務、品質、顧客サービス）
   • 外部への可視性は必要ですか？（顧客、サプライヤー、規制当局）
   • リアルタイム更新と定期更新のどちらが必要ですか？
   • アラートや例外処理の要件はありますか？

---

追跡・トレースのフレームワーク

追跡とトレースの違い

追跡（前方への追跡）

• 現在、どこにありますか？
• どこへ向かっていますか？
• いつ到着しますか？
• 出荷状況のリアルタイム監視
• 到着予定時刻の予測
• 例外アラート

トレース（後方への追跡）

• どこから来ましたか？
• 誰が取り扱いましたか？
• どのようなことがありましたか？
• 系譜と来歴
• リコール管理
• 保管・管理の連鎖

トレーサビリティのレベル

レベル 1：社内トレーサビリティ

• 単一施設内
• バッチ／ロット追跡
• 基本的な記録管理
• 限定的な統合

レベル 2：一段階上流、一段階下流

• 直近のサプライヤーと顧客を追跡
• 基本的なサプライチェーンの可視化
• コンプライアンスの最低要件（FDA、EU）
• エンドツーエンドの可視性は限定的

レベル 3：エンドツーエンドのトレーサビリティ

• サプライチェーン全体の可視化
• 複数階層にわたる追跡
• 統合システム
• 包括的なデータ

レベル 4：リアルタイムのデジタルツイン

• リアルタイムの追跡と監視
• IoT とセンサー
• 予測分析
• 自律的な意思決定

レベル 5：ブロックチェーン対応

• 改ざん不可能な記録
• 複数当事者間の信頼
• スマートコントラクト
• 完全な来歴

---

出荷追跡システム

出荷状況のリアルタイム可視化

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import json

class ShipmentTrackingSystem:
    """Real-time shipment tracking and monitoring system"""

    def __init__(self):
        self.shipments = {}
        self.tracking_events = []
        self.exceptions = []
        self.carriers = {}

    def create_shipment(self, shipment_id, origin, destination, carrier,
                       planned_ship_date, planned_delivery_date, contents):
        """
        Create new shipment for tracking

        contents: list of dicts with product and quantity info
        """

        self.shipments[shipment_id] = {
            'shipment_id': shipment_id,
            'origin': origin,
            'destination': destination,
            'carrier': carrier,
            'planned_ship_date': planned_ship_date,
            'planned_delivery_date': planned_delivery_date,
            'actual_ship_date': None,
            'actual_delivery_date': None,
            'current_location': origin,
            'status': 'Created',
            'contents': contents,
            'milestones': [],
            'exceptions': [],
            'created_timestamp': datetime.now()
        }

    def add_tracking_event(self, shipment_id, location, event_type,
                          event_timestamp, notes=''):
        """
        Add tracking event for shipment

        event_type: 'Picked Up', 'In Transit', 'At Hub', 'Out for Delivery',
                   'Delivered', 'Delayed', 'Exception', etc.
        """

        if shipment_id not in self.shipments:
            return None

        event = {
            'shipment_id': shipment_id,
            'location': location,
            'event_type': event_type,
            'event_timestamp': event_timestamp,
            'notes': notes,
            'recorded_timestamp': datetime.now()
        }

        self.tracking_events.append(event)

        # Update shipment
        shipment = self.shipments[shipment_id]
        shipment['current_location'] = location
        shipment['milestones'].append(event)

        # Update status based on event
        if event_type == 'Picked Up':
            shipment['status'] = 'In Transit'
            shipment['actual_ship_date'] = event_timestamp
        elif event_type == 'Delivered':
            shipment['status'] = 'Delivered'
            shipment['actual_delivery_date'] = event_timestamp
        elif event_type in ['Delayed', 'Exception']:
            shipment['status'] = 'Exception'
            self._create_exception(shipment_id, event_type, notes)

        return event

    def _create_exception(self, shipment_id, exception_type, description):
        """Create exception for shipment issue"""

        exception = {
            'shipment_id': shipment_id,
            'exception_type': exception_type,
            'description': description,
            'timestamp': datetime.now(),
            'status': 'Open',
            'resolution': None
        }

        self.exceptions.append(exception)
        self.shipments[shipment_id]['exceptions'].append(exception)

    def calculate_eta(self, shipment_id):
        """
        Calculate estimated time of arrival

        Uses historical performance and current status
        """

        if shipment_id not in self.shipments:
            return None

        shipment = self.shipments[shipment_id]

        if shipment['status'] == 'Delivered':
            return shipment['actual_delivery_date']

        # Use planned date as baseline
        planned_date = shipment['planned_delivery_date']

        # Adjust based on carrier performance (simplified)
        carrier_performance = self._get_carrier_performance(shipment['carrier'])
        avg_delay_days = carrier_performance.get('avg_delay_days', 0)

        # Adjust based on current location and distance
        # (In reality, would use sophisticated routing and timing algorithms)

        if isinstance(planned_date, str):
            planned_date = datetime.strptime(planned_date, '%Y-%m-%d')

        estimated_date = planned_date + timedelta(days=avg_delay_days)

        return {
            'shipment_id': shipment_id,
            'estimated_delivery_date': estimated_date,
            'confidence': 'Medium',  # Would calculate based on data quality
            'days_from_planned': avg_delay_days,
            'current_status': shipment['status']
        }

    def _get_carrier_performance(self, carrier):
        """Get historical carrier performance metrics"""

        # In reality, would query historical database
        # Simplified example

        default_performance = {
            'avg_delay_days': 0,
            'on_time_pct': 90
        }

        return self.carriers.get(carrier, default_performance)

    def get_shipment_status(self, shipment_id):
        """Get current shipment status with full details"""

        if shipment_id not in self.shipments:
            return None

        shipment = self.shipments[shipment_id]

        # Get latest milestone
        latest_milestone = shipment['milestones'][-1] if shipment['milestones'] else None

        # Calculate performance
        performance = self._calculate_performance(shipment)

        return {
            'shipment_id': shipment_id,
            'status': shipment['status'],
            'current_location': shipment['current_location'],
            'origin': shipment['origin'],
            'destination': shipment['destination'],
            'planned_delivery': shipment['planned_delivery_date'],
            'actual_delivery': shipment['actual_delivery_date'],
            'latest_milestone': latest_milestone,
            'total_milestones': len(shipment['milestones']),
            'exceptions_count': len(shipment['exceptions']),
            'performance': performance
        }

    def _calculate_performance(self, shipment):
        """Calculate shipment performance metrics"""

        if shipment['status'] != 'Delivered':
            return {'status': 'In Progress'}

        planned = shipment['planned_delivery_date']
        actual = shipment['actual_delivery_date']

        if isinstance(planned, str):
            planned = datetime.strptime(planned, '%Y-%m-%d')
        if isinstance(actual, str):
            actual = datetime.strptime(actual, '%Y-%m-%d')

        delay_days = (actual - planned).days

        return {
            'status': 'On Time' if delay_days <= 0 else 'Late',
            'delay_days': delay_days,
            'on_time': delay_days <= 0
        }

    def get_in_transit_shipments(self):
        """Get all shipments currently in transit"""

        in_transit = [
            s for s in self.shipments.values()
            if s['status'] in ['In Transit', 'Created']
        ]

        return pd.DataFrame(in_transit) if in_transit else pd.DataFrame()

    def get_exception_shipments(self):
        """Get all shipments with exceptions"""

        exception_shipments = [
            s for s in self.shipments.values()
            if len(s['exceptions']) > 0
        ]

        return pd.DataFrame(exception_shipments) if exception_shipments else pd.DataFrame()

    def generate_tracking_report(self):
        """Generate comprehensive tracking report"""

        total_shipments = len(self.shipments)
        delivered = len([s for s in self.shipments.values() if s['status'] == 'Delivered'])
        in_transit = len([s for s in self.shipments.values() if s['status'] == 'In Transit'])
        exceptions = len([s for s in self.shipments.values() if len(s['exceptions']) > 0])

        # Calculate on-time performance
        delivered_shipments = [s for s in self.shipments.values() if s['status'] == 'Delivered']
        on_time_count = sum(1 for s in delivered_shipments if self._calculate_performance(s).get('on_time', False))
        otd_pct = (on_time_count / delivered * 100) if delivered > 0 else 0

        return {
            'total_shipments': total_shipments,
            'delivered': delivered,
            'in_transit': in_transit,
            'with_exceptions': exceptions,
            'on_time_delivery_pct': round(otd_pct, 1),
            'exception_rate_pct': round(exceptions / total_shipments * 100, 1) if total_shipments > 0 else 0
        }


# Example shipment tracking
tracking_system = ShipmentTrackingSystem()

# Create shipments
tracking_system.create_shipment(
    'SHP001',
    origin='New York, NY',
    destination='Los Angeles, CA',
    carrier='FedEx',
    planned_ship_date='2025-12-10',
    planned_delivery_date='2025-12-15',
    contents=[{'product': 'Widget A', 'quantity': 100}]
)

tracking_system.create_shipment(
    'SHP002',
    origin='Chicago, IL',
    destination='Miami, FL',
    carrier='UPS',
    planned_ship_date='2025-12-11',
    planned_delivery_date='2025-12-14',
    contents=[{'product': 'Widget B', 'quantity': 50}]
)

# Add tracking events
tracking_system.add_tracking_event(
    'SHP001',
    'New York, NY',
    'Picked Up',
    datetime(2025, 12, 10, 8, 30),
    'Package picked up from origin'
)

tracking_system.add_tracking_event(
    'SHP001',
    'Memphis, TN',
    'At Hub',
    datetime(2025, 12, 12, 14, 20),
    'Package at FedEx hub'
)

tracking_system.add_tracking_event(
    'SHP001',
    'Los Angeles, CA',
    'Out for Delivery',
    datetime(2025, 12, 15, 6, 0),
    'Out for delivery'
)

tracking_system.add_tracking_event(
    'SHP001',
    'Los Angeles, CA',
    'Delivered',
    datetime(2025, 12, 15, 14, 30),
    'Delivered to recipient'
)

# Add exception
tracking_system.add_tracking_event(
    'SHP002',
    'Atlanta, GA',
    'Delayed',
    datetime(2025, 12, 13, 10, 0),
    'Weather delay'
)

# Get shipment status
status = tracking_system.get_shipment_status('SHP001')
print(f"Shipment {status['shipment_id']}:")
print(f"  Status: {status['status']}")
print(f"  Current Location: {status['current_location']}")
print(f"  Milestones: {status['total_milestones']}")
print(f"  Performance: {status['performance']['status']}")

# Generate report
report = tracking_system.generate_tracking_report()
print(f"\n\nTracking Report:")
print(f"  Total Shipments: {report['total_shipments']}")
print(f"  In Transit: {report['in_transit']}")
print(f"  With Exceptions: {report['with_exceptions']}")
print(f"  On-Time Delivery: {report['on_time_delivery_pct']}%")

---

製品トレーサビリティシステム

ロット／バッチ追跡

class ProductTraceabilitySystem:
    """Product traceability and genealogy tracking system"""

    def __init__(self):
        self.products = {}
        self.lots = {}
        self.movements = []
        self.transformations = []

    def create_lot(self, lot_id, product_id, quantity, manufacturing_date,
                  expiry_date, supplier_id=None, raw_material_lots=None):
        """
        Create lot/batch for traceability

        raw_material_lots: list of input lot IDs (for traceability chain)
        """

        self.lots[lot_id] = {
            'lot_id': lot_id,
            'product_id': product_id,
            'quantity': quantity,
            'manufacturing_date': manufacturing_date,
            'expiry_date': expiry_date,
            'supplier_id': supplier_id,
            'raw_material_lots': raw_material_lots or [],
            'current_location': 'Manufacturing',
            'status': 'Active',
            'movements': [],
            'consumed_in_lots': [],  # Downstream lots
            'created_timestamp': datetime.now()
        }

    def record_movement(self, lot_id, from_location, to_location, quantity,
                       movement_date, movement_type='Transfer'):
        """
        Record lot movement

        movement_type: 'Transfer', 'Sale', 'Return', 'Disposal', etc.
        """

        if lot_id not in self.lots:
            return None

        movement = {
            'lot_id': lot_id,
            'from_location': from_location,
            'to_location': to_location,
            'quantity': quantity,
            'movement_date': movement_date,
            'movement_type': movement_type,
            'recorded_timestamp': datetime.now()
        }

        self.movements.append(movement)
        self.lots[lot_id]['movements'].append(movement)
        self.lots[lot_id]['current_location'] = to_location

        return movement

    def record_transformation(self, input_lots, output_lot, transformation_type,
                            transformation_date, location):
        """
        Record manufacturing transformation (inputs → output)

        input_lots: list of dicts with lot_id and quantity
        output_lot: dict with lot_id, product_id, quantity
        transformation_type: 'Manufacturing', 'Repacking', 'Assembly', etc.
        """

        transformation = {
            'transformation_id': f"TRANS_{len(self.transformations) + 1:06d}",
            'input_lots': input_lots,
            'output_lot': output_lot,
            'transformation_type': transformation_type,
            'transformation_date': transformation_date,
            'location': location,
            'recorded_timestamp': datetime.now()
        }

        self.transformations.append(transformation)

        # Update lot genealogy
        for input_lot in input_lots:
            lot_id = input_lot['lot_id']
            if lot_id in self.lots:
                self.lots[lot_id]['consumed_in_lots'].append(output_lot['lot_id'])

        return transformation

    def trace_forward(self, lot_id):
        """
        Trace forward (where did this lot go?)

        Returns all downstream lots and movements
        """

        if lot_id not in self.lots:
            return None

        lot = self.lots[lot_id]

        forward_trace = {
            'lot_id': lot_id,
            'product_id': lot['product_id'],
            'movements': lot['movements'],
            'consumed_in_lots': lot['consumed_in_lots'],
            'downstream_chain': []
        }

        # Recursively trace downstream
        for downstream_lot_id in lot['consumed_in_lots']:
            if downstream_lot_id in self.lots:
                downstream_trace = self.trace_forward(downstream_lot_id)
                forward_trace['downstream_chain'].append(downstream_trace)

        return forward_trace

    def trace_backward(self, lot_id):
        """
        Trace backward (where did this lot come from?)

        Returns all upstream lots and suppliers
        """

        if lot_id not in self.lots:
            return None

        lot = self.lots[lot_id]

        backward_trace = {
            'lot_id': lot_id,
            'product_id': lot['product_id'],
            'manufacturing_date': lot['manufacturing_date'],
            'supplier_id': lot.get('supplier_id'),
            'raw_materials': [],
            'upstream_chain': []
        }

        # Recursively trace upstream
        for upstream_lot_id in lot.get('raw_material_lots', []):
            if upstream_lot_id in self.lots:
                upstream_trace = self.trace_backward(upstream_lot_id)
                backward_trace['upstream_chain'].append(upstream_trace)

        return backward_trace

    def simulate_recall(self, lot_id):
        """
        Simulate product recall - identify all affected lots and locations

        Critical for food safety, pharmaceuticals, etc.
        """

        # Trace forward to find all impacted lots
        forward_trace = self.trace_forward(lot_id)

        affected_lots = [lot_id]
        locations = set([self.lots[lot_id]['current_location']])

        def collect_downstream(trace):
            for downstream in trace.get('downstream_chain', []):
                affected_lots.append(downstream['lot_id'])
                if downstream['lot_id'] in self.lots:
                    locations.add(self.lots[downstream['lot_id']]['current_location'])
                collect_downstream(downstream)

        collect_downstream(forward_trace)

        # Calculate total quantity affected
        total_quantity = sum(
            self.lots[lid]['quantity'] for lid in affected_lots if lid in self.lots
        )

        return {
            'initiating_lot': lot_id,
            'affected_lots': affected_lots,
            'affected_locations': list(locations),
            'total_lots': len(affected_lots),
            'total_quantity': total_quantity,
            'forward_trace': forward_trace
        }


# Example traceability
traceability = ProductTraceabilitySystem()

# Create raw material lots
traceability.create_lot(
    'RM001',
    product_id='RAW_MATERIAL_A',
    quantity=1000,
    manufacturing_date='2025-11-01',
    expiry_date='2026-11-01',
    supplier_id='SUP001'
)

traceability.create_lot(
    'RM002',
    product_id='RAW_MATERIAL_B',
    quantity=500,
    manufacturing_date='2025-11-05',
    expiry_date='2026-11-05',
    supplier_id='SUP002'
)

# Create finished product lot (using raw materials)
traceability.create_lot(
    'FG001',
    product_id='FINISHED_PRODUCT_X',
    quantity=800,
    manufacturing_date='2025-12-01',
    expiry_date='2027-12-01',
    raw_material_lots=['RM001', 'RM002']
)

# Record transformation
traceability.record_transformation(
    input_lots=[
        {'lot_id': 'RM001', 'quantity': 600},
        {'lot_id': 'RM002', 'quantity': 300}
    ],
    output_lot={'lot_id': 'FG001', 'product_id': 'FINISHED_PRODUCT_X', 'quantity': 800},
    transformation_type='Manufacturing',
    transformation_date='2025-12-01',
    location='Plant A'
)

# Record movements
traceability.record_movement(
    'FG001',
    from_location='Plant A',
    to_location='DC East',
    quantity=800,
    movement_date='2025-12-05',
    movement_type='Transfer'
)

traceability.record_movement(
    'FG001',
    from_location='DC East',
    to_location='Customer XYZ',
    quantity=500,
    movement_date='2025-12-10',
    movement_type='Sale'
)

# Trace backward
backward = traceability.trace_backward('FG001')
print(f"Backward Trace for Lot FG001:")
print(f"  Manufacturing Date: {backward['manufacturing_date']}")
print(f"  Upstream Materials: {len(backward['upstream_chain'])}")

# Simulate recall
recall = traceability.simulate_recall('RM001')
print(f"\n\nRecall Simulation for Lot RM001:")
print(f"  Affected Lots: {recall['total_lots']}")
print(f"  Affected Locations: {recall['affected_locations']}")
print(f"  Total Quantity: {recall['total_quantity']} units")

---

ツールとライブラリ

Python ライブラリ

データ処理：

• pandas：データ操作
• numpy：数値計算
• sqlalchemy：データベース接続

API と統合：

• requests：運送業者 API への HTTP リクエスト
• ftplib：FTP ファイル転送
• paramiko：SSH／SFTP

リアルタイム：

• kafka-python：Apache Kafka
• paho-mqtt：MQTT メッセージング
• redis：リアルタイムデータストア

ブロックチェーン：

• web3.py：Ethereum ブロックチェーン
• hyperledger-fabric-sdk-py：Hyperledger Fabric

可視化：

• matplotlib、plotly：追跡ダッシュボード
• folium：地理情報マッピング

商用ソフトウェア

出荷追跡：

• project44：複数の運送業者にわたる可視化
• FourKites：リアルタイムの出荷追跡
• Shippeo：サプライチェーンの可視化
• ClearMetal：予測型の物流可視化
• Descartes MacroPoint：貨物の追跡

トレーサビリティプラットフォーム：

• TraceLink：シリアル化とトレーサビリティ
• Optel：追跡ソリューション
• rfxcel：サプライチェーンのトレーサビリティ
• IBM Food Trust：ブロックチェーンによるトレーサビリティ
• SAP Information Collaboration Hub：追跡

IoT とセンサー：

• Tive：サプライチェーン可視化センサー
• Roambee：リアルタイム追跡デバイス
• Samsara：IoT プラットフォーム
• Zest Labs：生鮮食品の追跡

ブロックチェーン：

• IBM Blockchain：企業向けブロックチェーン
• VeChain：サプライチェーン向けブロックチェーン
• OriginTrail：分散型トレーサビリティ
• Morpheus.Network：サプライチェーンプラットフォーム

---

よくある課題と解決策

課題：データ統合

問題：

• 複数の異なるシステム（ERP、WMS、TMS、運送業者のシステム）
• データ形式と標準の違い
• リアルタイム統合とバッチ統合
• API の制限

解決策：

• ミドルウェア／統合プラットフォーム（MuleSoft、Boomi）
• 標準化されたデータモデル（GS1、EPCIS）
• API ファーストアーキテクチャ
• イベント駆動型の統合
• マスターデータ管理
• 段階的な統合アプローチ

課題：データの品質と精度

問題：

• 追跡イベントの不足
• 更新の遅延
• 位置情報の誤り
• スキャン漏れ

解決策：

• 自動データ検証
• 例外レポートとアラート
• 複数のデータソース（三角測量）
• 自動化のための IoT センサー
• トレーニングとプロセスの徹底
• データ照合プロセス

課題：リアルタイムパフォーマンス

問題：

• 追跡イベントの大量発生
• 更新の遅延
• システムパフォーマンスの低下
• 即時の可視化の必要性

解決策：

• イベント駆動型アーキテクチャ（Kafka、MQTT）
• インメモリデータベース（Redis）
• キャッシュ戦略
• 水平スケーリング
• IoT 向けエッジコンピューティング
• 非同期処理

課題：大規模運用における複雑さ

問題：

• 数百万件の出荷／製品
• 多階層のサプライチェーン
• グローバルな業務
• 組み合わせ爆発

解決策：

• 階層的な追跡（パレット → ケース → 個品）
• 選択的な追跡（価値／リスクに基づく）
• 古いデータのアーカイブ
• 分散システム
• クラウドインフラストラクチャ
• 効率的なデータ構造

課題：サプライヤー／パートナーとの統合

問題：

• サプライヤーにテクノロジーがない
• データ共有への消極姿勢
• 標準の違い
• 小規模なパートナー

解決策：

• 段階的なアプローチ（EDI、API、ポータル、メール）
• 標準化された形式（GS1、EPCIS）
• 参加へのインセンティブ
• テクノロジーの提供
• 業界内の連携
• 段階的な導入

課題：コストの正当化

問題：

• 高額な導入コスト
• 継続的な運用コスト
• 定量化しにくいメリット
• 投資回収までの期間が長い

解決策：

• パイロットから開始（価値の高いユースケース）
• メリットを定量化（効率、サービス、コンプライアンス）
• 段階的な投資
• クラウドベースの SaaS モデル
• 業界で共有するインフラストラクチャ
• コンプライアンスを推進要因とする

---

出力形式

トラック＆トレースダッシュボード

エグゼクティブサマリー：

• 追跡対象の出荷／製品の合計
• 追跡パフォーマンス
• 例外と問題
• 主要指標

出荷追跡：

出荷 ID	出発地	目的地	ステータス	現在地	到着予定日	遅延	例外
SHP-10234	NYC	LAX	輸送中	Memphis Hub	1月15日	定刻	なし
SHP-10235	CHI	MIA	遅延	Atlanta	1月16日	2日遅れ	天候
SHP-10236	SEA	BOS	例外	Portland	未定	5日遅れ	通関保留

トレーサビリティ：

ロット／バッチ ID	製品	数量	製造日	有効期限	現在地	ステータス
LOT-A12345	Product X	1,000	2025-11-15	2027-11-15	DC East	有効
LOT-A12346	Product X	800	2025-11-20	2027-11-20	Customer ABC	販売済み
LOT-A12347	Product X	500	2025-11-25	2027-11-25	リコール	隔離

パフォーマンス指標：

指標	値	目標	ステータス
追跡済み出荷数	15,234	N/A	✓
リアルタイム可視性	98.2%	95.0%	✓ 目標超過
定時納品率	91.5%	92.0%	⚠ わずかに未達
例外発生率	4.3%	<5.0%	✓ 目標範囲内
トレーサビリティ網羅率	99.8%	100%	✓ 目標に近い

例外の概要：

例外の種類	件数	平均解決時間	最古の未解決期間
遅延	127	18時間	3日
通関保留	23	4.2日	8日
破損	8	2日	1日
紛失	2	保留中	12日

---

確認事項

さらに詳しい情報が必要な場合：

1. 何を追跡する必要がありますか？（出荷、製品、資産、部品）
2. どの粒度で追跡しますか？（パレット、ケース、ユニット、シリアル番号）
3. どのような規制要件がありますか？（FDA、FSMA、EU MDR）
4. どのシステムとの連携が必要ですか？（ERP、WMS、TMS、運送業者のシステム）
5. リアルタイム追跡が必要ですか、それとも定期的な更新で十分ですか？
6. 誰が可視性を必要としていますか？（社内チーム、顧客、サプライヤー、規制当局）
7. 地理的な対象範囲はどの程度ですか？（国内、国際、複数地域）
8. どのようなデータ取得方法を利用できますか？（バーコード、RFID、IoT、手動）
9. リコールやコンプライアンスのシナリオへの対応が必要ですか？
10. 予算とスケジュールはどのようになっていますか？

---

関連スキル

• control-tower-design：一元的な監視と可視化に使用
• compliance-management：規制上のトレーサビリティ要件に使用
• circular-economy：リバースロジスティクスの追跡に使用
• supplier-collaboration：サプライヤー可視化の連携に使用
• risk-mitigation：混乱やリスクの追跡に使用
• freight-optimization：輸送の可視化に使用
• route-optimization：出荷の追跡と最適化に使用
• quality-management：品質トレーサビリティに使用