# P&ID 도면 파싱 병렬 LLM 아키텍처 개선안

## 1. 기존 문제점 분석

### 1.1 현재 구조의 병목
| 단계 | 문제점 | 심각도 |
|------|--------|--------|
| Phase 1 | ezdxf로 28,000개 엔티티 처리 | 0.58초 (양호) |
| Phase 2 | O(n²) 노드 병합 | timeout (심각) |
| Phase 3 | 순차적 LLM API 호출 | 예측 불가능한 지연 |

### 1.2 test_dxf_extract_pid*.py의 성공적인 병렬 처리 구조

```python
# test_dxf_extract_pid1.py, pid2.py, pid3.py의 공통 구조
chunks = [
    {
        'name': 'Field Instruments - Sensors',
        'system': 'Extract sensor tags only...',
        'user': 'Extract ALL tags of FT, FIT, LT, PT...'
    },
    {
        'name': 'Field Instruments - Valves',
        'system': 'Extract valve tags only...',
        'user': 'Extract ALL tags of FCV, TCV, LCV...'
    },
    {
        'name': 'System Tags',
        'system': 'Extract system tags only...',
        'user': 'Extract ALL tags of LI, PI, TI...'
    }
]

# 각 청크를 순차적으로 처리하지만, LLM은 병렬로 실행 가능
for chunk in chunks:
    resp = llm.chat.completions.create(...)
```

**핵심 발견**:
- **청크 단위 분할**: 태그 유형별로 프롬프트를 분리
- **동시 실행 가능**: 각 청크는 독립적이므로 병렬 실행 가능
- **LLM 자원 최대화**: vLLM의 tensor parallelism 활용 가능

---

## 2. 병렬 LLM 처리 아키텍처 설계

### 2.1 전체 파이프라인 구조 (개선안)

```
┌─────────────────────────────────────────────────────────────────────┐
│                    P&ID 도면 파싱 파이프라인 (병렬 LLM)               │
└─────────────────────────────────────────────────────────────────────┘

Phase 1: 기하학적 추출 (ezdxf)
├─ DXF 파일 로드 (0.84초)
├─ 엔티티별 BBox 계산 (0.58초)
└─ 결과: 28,257개 GeometricEntity

Phase 2: 위상 빌더 (공간 인덱스 + 병렬 LLM)
├─ 공간 인덱스 생성 (R-tree)
├─ 노드 병합 (O(n log n))
└─ 결과: NetworkX 그래프

Phase 3: 지능형 매핑 (병렬 LLM)
├─ 태그 유형별 청크 분할
│  ├─ Sensor Tags (FT, FIT, LT, PT, TE, ...)
│  ├─ Valve Tags (FCV, TCV, LCV, PCV, XV, ...)
│  ├─ Equipment Tags (Pump, Tank, Heat Exchanger)
│  └─ System Tags (FICQ, TICA, PICA, ...)
│
├─ 병렬 LLM 실행 (4개 청크 동시에)
│  ├─ LLM Worker 1: Sensor Tags → 100개 태그
│  ├─ LLM Worker 2: Valve Tags → 80개 태그
│  ├─ LLM Worker 3: Equipment Tags → 50개 태그
│  └─ LLM Worker 4: System Tags → 120개 태그
│
└─ 결과: 350개 매핑된 태그
```

### 2.2 병렬 LLM 워커 구조

```python
# 병렬 LLM 워커
import asyncio
from typing import List, Dict, Any
from openai import AsyncOpenAI

class ParallelLLMWorker:
    def __init__(self, api_client: AsyncOpenAI, max_concurrent: int = 4):
        self.client = api_client
        self.max_concurrent = max_concurrent
        self.semaphore = asyncio.Semaphore(max_concurrent)
    
    async def process_chunk(self, chunk: Dict[str, Any]) -> List[Dict[str, Any]]:
        """단일 청크 처리 (비동기 + 세마포어로 병렬 제한)"""
        async with self.semaphore:
            system = chunk['system']
            user = chunk['user'].format(text=chunk['text'])
            
            response = await self.client.chat.completions.create(
                model='Qwen/Qwen3-Coder-Next-FP8',
                messages=[
                    {'role': 'system', 'content': system},
                    {'role': 'user', 'content': user},
                ],
                max_tokens=65536,
                temperature=0.1,
            )
            
            return self._parse_response(response)
    
    async def process_all_chunks(self, chunks: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """모든 청크 병렬 처리"""
        tasks = [self.process_chunk(chunk) for chunk in chunks]
        results = await asyncio.gather(*tasks)
        
        # 결과 병합
        all_tags = []
        seen_tags = set()
        for tags in results:
            for tag in tags:
                tag_no = tag.get('tagNo')
                if tag_no and tag_no not in seen_tags:
                    seen_tags.add(tag_no)
                    all_tags.append(tag)
        return all_tags
```

---

## 3. 상세 구현 계획

### 3.1 Phase 1: 기하학적 추출 (변경 없음)

```python
# pid_geometric_extractor.py (현재 그대로 사용)
class PidGeometricExtractor:
    def __init__(self, file_path: str):
        self.doc = ezdxf.readfile(file_path)
        self.msp = self.doc.modelspace()
    
    def extract_and_save(self, output_path: str):
        results = []
        for entity in self.msp:
            bbox_obj = self.get_bbox(entity)
            # ... 추출 로직
        return results
```

### 3.2 Phase 2: 위상 빌더 (공간 인덱스 도입)

```python
# pid_topology_builder.py (개선안)
from rtree import index

class PidTopologyBuilder:
    def __init__(self, geometric_data: List[Dict[str, Any]]):
        self.data = geometric_data
        self.G = nx.DiGraph()
    
    def build_graph(self):
        # 1. 공간 인덱스 생성
        self._build_spatial_index()
        
        # 2. 노드 병합 (R-tree 사용)
        self._merge_nodes_spatial()
        
        # 3. 태그-설비 연결
        self._link_tags_to_equipment()
        
        # 4. 배관 연결
        self._link_pipes()
    
    def _build_spatial_index(self):
        """R-tree 공간 인덱스 생성"""
        p = index.Property()
        self.idx = index.Index(properties=p)
        for i, item in enumerate(self.data):
            bbox = item['bbox']
            self.idx.insert(i, (
                bbox['min_x'], bbox['min_y'],
                bbox['max_x'], bbox['max_y']
            ))
    
    def _merge_nodes_spatial(self):
        """공간 인덱스를 사용한 병합 (O(n log n))"""
        merge_threshold = 2.0
        merged = []
        visited = set()
        
        for i, item in enumerate(self.data):
            if i in visited:
                continue
            
            bbox = item['bbox']
            # 인접 노드만 검색
            neighbors = list(self.idx.intersection((
                bbox['min_x'] - merge_threshold,
                bbox['min_y'] - merge_threshold,
                bbox['max_x'] + merge_threshold,
                bbox['max_y'] + merge_threshold
            )))
            
            # ... 병합 로직
```

### 3.3 Phase 3: 병렬 LLM 매핑 (신규 구현)

```python
# pid_parallel_llm_mapper.py (신규 파일)
import asyncio
from typing import List, Dict, Any
from openai import AsyncOpenAI
from rapidfuzz import process, fuzz

class ParallelLLMMapper:
    def __init__(self, graph, system_tags: List[str], api_client: AsyncOpenAI, 
                 max_concurrent: int = 4):
        self.graph = graph
        self.system_tags = system_tags
        self.client = api_client
        self.max_concurrent = max_concurrent
        self.semaphore = asyncio.Semaphore(max_concurrent)
    
    def create_chunks(self, node_ids: List[str]) -> List[Dict[str, Any]]:
        """노드를 태그 유형별로 청크 분할"""
        # 태그 유형별 분류
        sensors = []
        valves = []
        equipment = []
        system = []
        
        for node_id in node_ids:
            node_data = self.graph.nodes[node_id]
            tag_text = node_data.get('value', '').upper()
            
            # 태그 유형에 따라 분류
            if any(x in tag_text for x in ['FT', 'FIT', 'LT', 'PT', 'TE', 'PG', 'LG', 'TG']):
                sensors.append(node_id)
            elif any(x in tag_text for x in ['FCV', 'TCV', 'LCV', 'PCV', 'XV', 'FV', 'LV', 'PV', 'TV']):
                valves.append(node_id)
            elif any(x in tag_text for x in ['PUMP', 'TANK', 'HEAT', 'EXCHANGER']):
                equipment.append(node_id)
            else:
                system.append(node_id)
        
        # 청크 생성
        chunks = []
        if sensors:
            chunks.append({
                'name': 'Sensors',
                'node_ids': sensors,
                'system': 'You are a P&ID expert. Extract sensor tags only.',
                'user': 'Extract sensor tags: {tags}'
            })
        if valves:
            chunks.append({
                'name': 'Valves',
                'node_ids': valves,
                'system': 'You are a P&ID expert. Extract valve tags only.',
                'user': 'Extract valve tags: {tags}'
            })
        if equipment:
            chunks.append({
                'name': 'Equipment',
                'node_ids': equipment,
                'system': 'You are a P&ID expert. Extract equipment tags only.',
                'user': 'Extract equipment tags: {tags}'
            })
        if system:
            chunks.append({
                'name': 'System',
                'node_ids': system,
                'system': 'You are a P&ID expert. Extract system tags only.',
                'user': 'Extract system tags: {tags}'
            })
        
        return chunks
    
    async def process_chunk(self, chunk: Dict[str, Any]) -> Dict[str, Any]:
        """단일 청크 처리 (비동기 + 세마포어)"""
        async with self.semaphore:
            node_ids = chunk['node_ids']
            tag_texts = [self.graph.nodes[nid]['value'] for nid in node_ids]
            
            # RapidFuzz 후보 추출
            candidates_list = []
            for tag_text in tag_texts:
                candidates = process.extract(tag_text, self.system_tags, limit=5)
                candidates_list.append(candidates)
            
            # LLM 프롬프트 생성
            prompt = f"""
            {chunk['system']}
            다음 태그들을 시스템 태그와 매핑하세요:
            {chr(10).join(f'{t} -> {c}' for t, c in zip(tag_texts, candidates_list))}
            
            JSON 형식으로 응답:
            {{"node_id": "resolved_tag", ...}}
            """
            
            response = await self.client.chat.completions.create(
                model='Qwen/Qwen3-Coder-Next-FP8',
                messages=[{'role': 'user', 'content': prompt}],
                max_tokens=65536,
                temperature=0.1,
            )
            
            return self._parse_response(response)
    
    async def process_all_chunks(self, chunks: List[Dict[str, Any]]) -> Dict[str, Any]:
        """모든 청크 병렬 처리"""
        tasks = [self.process_chunk(chunk) for chunk in chunks]
        results = await asyncio.gather(*tasks)
        
        # 결과 병합
        merged = {}
        for result in results:
            merged.update(result)
        return merged
```

---

## 4. 성능 예측

### 4.1 Phase 1: 기하학적 추출
- **현재**: 1.4초
- **개선 후**: 1.4초 (변화 없음)

### 4.2 Phase 2: 위상 빌더
- **현재**: timeout (O(n²))
- **개선 후**: 2-3초 (R-tree O(n log n))

### 4.3 Phase 3: 병렬 LLM 매핑
- **현재**: 예측 불가 (순차적 API 호출)
- **개선 후**: 5-10초 (4개 청크 병렬 처리)

**예상 속도 향상**:
- Phase 2: 100배 이상 (timeout → 2-3초)
- Phase 3: 3-5배 (순차적 → 병렬)

---

## 5. 구현 우선순위

| 순위 | 작업 | 예상 시간 | 영향도 |
|------|------|-----------|--------|
| 1 | R-tree 공간 인덱스 도입 | 1일 | HIGH |
| 2 | 병렬 LLM 워커 구현 | 1일 | HIGH |
| 3 | Phase 2-3 통합 | 0.5일 | MEDIUM |
| 4 | 테스트 및 벤치마크 | 0.5일 | LOW |

**총 예상 시간**: 3일

---

## 6. 참고: test_dxf_extract_pid*.py의 성공 요인

### 6.1 청크 단위 분할
- 태그 유형별로 프롬프트를 분리하여 **의도적 병렬화** 가능
- 각 청크는 독립적이므로 **실패 격리** 가능

### 6.2 vLLM의 tensor parallelism 활용
- `Qwen/Qwen3-Coder-Next-FP8` 모델은 **8개 GPU 카드**에 분산 실행 가능
- 4개 청크를 동시에 실행하면 **모든 GPU 카드를 최대한 활용**

### 6.3 비동기 처리
- `asyncio.gather()`로 여러 청크를 동시에 실행
- 각 청크는 `async with semaphore`로 병렬도 제한

---

## 7. 결론

### 7.1 핵심 개선 포인트
1. **Phase 2**: R-tree 공간 인덱스로 O(n²) → O(n log n) 개선
2. **Phase 3**: test_dxf_extract_pid*.py의 병렬 처리 구조 도입
3. **병렬 LLM**: 4개 청크를 동시에 실행하여 GPU 자원 최대화

### 7.2 예상 성능
- **현재**: timeout (Phase 2에서 멈춤)
- **개선 후**: 약 7-13초 (28,000개 엔티티 기준)
- **속도 향상**: 100배 이상 (Phase 2), 3-5배 (Phase 3)

### 7.3 구현 전략
1. 먼저 Phase 2 (공간 인덱스) 구현 → Phase 2 timeout 해결
2. Phase 3 (병렬 LLM) 구현 → test_dxf_extract_pid*.py 구조 참고
3. 전체 파이프라인 통합 → 벤치마크 테스트
