# 스킬 사례 분석: PDF, 뉴스, 회의

## 개요

로빙의 핵심 스킬 3종(PDF 처리, 뉴스 요약, 회의 다이제스트)의 설계와 구현을 상세히 분석합니다.

## 1. PDF 처리 스킬

### 스킬 개요
- **목적**: PDF 문서를 구조화된 정보로 변환
- **레벨 요구사항**: 기억 10+, 연산 15+
- **사용 시나리오**: 계약서 분석, 보고서 요약, 논문 리뷰

### 기술적 구현

```python
class PDFProcessingSkill(BaseSkill):
    name = "pdf_processor"
    required_stats = {"memory": 10, "compute": 15}
    
    async def execute(self, pdf_path: str, task_type: str):
        # 1. PDF 파싱
        content = await self.parse_pdf(pdf_path)
        
        # 2. 구조 분석
        structure = self.analyze_structure(content)
        # - 제목/부제목 계층
        # - 표/그림 추출
        # - 참조/인용 파악
        
        # 3. 작업별 처리
        if task_type == "summarize":
            return await self.summarize_document(structure)
        elif task_type == "extract_action_items":
            return await self.extract_actions(structure)
        elif task_type == "qa":
            return await self.prepare_qa_index(structure)
```

### 고급 기능 (레벨 15+)

```python
def advanced_pdf_features(self):
    features = {
        "multi_document_comparison": self.compare_pdfs,
        "legal_clause_detection": self.detect_legal_terms,
        "financial_data_extraction": self.extract_tables,
        "citation_network": self.build_reference_graph
    }
    return features
```

### 성능 최적화
- **청킹**: 대용량 PDF를 작은 단위로 분할
- **캐싱**: 자주 접근하는 문서는 구조화된 형태로 저장
- **병렬 처리**: 페이지별 독립적 처리

## 2. 뉴스 수집/요약 스킬

### 스킬 개요
- **목적**: 관련 뉴스 수집 및 핵심 정보 요약
- **레벨 요구사항**: 기억 5+, 연산 10+, 공감 10+
- **사용 시나리오**: 업계 동향 파악, 경쟁사 모니터링, 이슈 트래킹

### 구현 아키텍처

```python
class NewsSkill(BaseSkill):
    name = "news_aggregator"
    required_stats = {"memory": 5, "compute": 10, "empathy": 10}
    
    async def collect_and_summarize(self, topics: List[str], preferences: dict):
        # 1. 소스별 수집
        news_items = await self.collect_from_sources([
            GoogleNewsAPI(),
            NaverNewsAPI(),
            RSSFeedReader(),
            TwitterTrendsAPI()
        ], topics)
        
        # 2. 관련성 필터링
        relevant_news = self.filter_by_relevance(
            news_items, 
            user_interests=preferences
        )
        
        # 3. 감정 분석 (공감 스탯 활용)
        sentiment_analysis = self.analyze_sentiment(relevant_news)
        
        # 4. 요약 생성
        summary = await self.generate_summary(
            relevant_news,
            style=preferences.get('summary_style', 'executive')
        )
        
        return {
            "summary": summary,
            "sentiment": sentiment_analysis,
            "sources": [item.source for item in relevant_news]
        }
```

### 개인화 알고리즘

```python
def personalize_news_selection(self, user_history, current_news):
    # 사용자 관심사 학습
    interest_vector = self.calculate_interest_vector(user_history)
    
    # 뉴스 스코어링
    scored_news = []
    for news in current_news:
        score = cosine_similarity(interest_vector, news.embedding)
        
        # 시간 가중치 (최신 뉴스 우선)
        time_weight = self.calculate_recency_weight(news.published_at)
        
        # 다양성 보너스 (필터 버블 방지)
        diversity_bonus = self.calculate_diversity_score(news, user_history)
        
        final_score = score * 0.6 + time_weight * 0.3 + diversity_bonus * 0.1
        scored_news.append((news, final_score))
    
    return sorted(scored_news, key=lambda x: x[1], reverse=True)
```

### 실시간 업데이트

```python
class NewsMonitor:
    def __init__(self, skill_instance):
        self.skill = skill_instance
        self.update_interval = 3600  # 1시간
        
    async def monitor_breaking_news(self, keywords):
        while True:
            # 주기적 체크
            breaking_news = await self.check_breaking_news(keywords)
            
            if breaking_news and self.is_significant(breaking_news):
                # 사용자에게 즉시 알림
                await self.notify_user(breaking_news)
            
            await asyncio.sleep(self.update_interval)
```

## 3. 회의 다이제스트 (Thread Digest) 스킬

### 스킬 개요
- **목적**: Slack 스레드나 회의 내용을 구조화된 요약으로 변환
- **레벨 요구사항**: 기억 15+, 공감 15+, 통솔 10+
- **사용 시나리오**: 일일 스탠드업, 프로젝트 회의, 의사결정 과정

### 핵심 알고리즘

```python
class ThreadDigestSkill(BaseSkill):
    name = "thread_digest"
    required_stats = {"memory": 15, "empathy": 15, "leadership": 10}
    
    async def digest_thread(self, thread_messages: List[Message]):
        # 1. 대화 구조 분석
        conversation_flow = self.analyze_conversation_structure(thread_messages)
        
        # 2. 화자별 기여도 분석
        speaker_analysis = self.analyze_speakers({
            msg.user_id: {
                "messages": [m for m in thread_messages if m.user_id == msg.user_id],
                "sentiment": self.get_speaker_sentiment(msg.user_id, thread_messages),
                "role": self.infer_speaker_role(msg.user_id, thread_messages)
            }
            for msg in thread_messages
        })
        
        # 3. 핵심 주제 추출
        topics = self.extract_topics(thread_messages)
        
        # 4. 액션 아이템 식별
        action_items = self.extract_action_items(
            thread_messages,
            context=conversation_flow
        )
        
        # 5. 의사결정 포인트 추출
        decisions = self.extract_decisions(thread_messages)
        
        return ThreadDigest(
            summary=self.generate_executive_summary(topics, decisions),
            topics=topics,
            action_items=action_items,
            decisions=decisions,
            speaker_insights=speaker_analysis,
            next_steps=self.suggest_next_steps(action_items, decisions)
        )
```

### 고급 기능: 컨텍스트 인식

```python
def understand_context(self, messages):
    context_clues = {
        "meeting_type": self.detect_meeting_type(messages),
        "urgency_level": self.assess_urgency(messages),
        "emotional_tone": self.analyze_emotional_dynamics(messages),
        "decision_style": self.identify_decision_pattern(messages)
    }
    
    # 프로젝트 히스토리 참조
    historical_context = self.memory.retrieve_similar_meetings(
        messages, 
        limit=5
    )
    
    # 맥락 통합
    enriched_context = self.merge_contexts(context_clues, historical_context)
    
    return enriched_context
```

### 시각화 출력

```python
def format_digest_output(self, digest: ThreadDigest):
    output = f"""
# 회의 요약 📋

## 핵심 내용
{digest.summary}

## 주요 주제
{self.format_topics_with_time(digest.topics)}

## 의사결정 사항 ✅
{self.format_decisions_table(digest.decisions)}

## 액션 아이템 🎯
{self.format_action_items_with_owners(digest.action_items)}

## 참여자 인사이트 👥
{self.create_participation_chart(digest.speaker_insights)}

## 다음 단계 ➡️
{self.format_next_steps(digest.next_steps)}

---
_생성 시각: {datetime.now()}_
_분석 대상: {len(messages)}개 메시지_
"""
    return output
```

## 스킬 간 시너지

### 통합 워크플로우 예시

```python
async def integrated_research_workflow(self, topic: str):
    # 1. 뉴스 스킬로 최신 동향 파악
    news_summary = await self.news_skill.collect_and_summarize([topic])
    
    # 2. PDF 스킬로 관련 보고서 분석
    related_reports = await self.find_related_pdfs(topic)
    pdf_insights = await self.pdf_skill.batch_analyze(related_reports)
    
    # 3. 이전 회의 내용 참조
    past_discussions = await self.thread_skill.find_related_threads(topic)
    
    # 4. 통합 인사이트 생성
    integrated_report = await self.generate_comprehensive_report({
        "current_trends": news_summary,
        "research_findings": pdf_insights,
        "internal_discussions": past_discussions
    })
    
    return integrated_report
```

## 성능 메트릭

### 스킬별 KPI

| 스킬 | 정확도 | 처리 시간 | 사용자 만족도 |
|-----|--------|----------|--------------|
| PDF 처리 | 92% | <5초/페이지 | 4.2/5 |
| 뉴스 요약 | 87% | <10초/요청 | 4.5/5 |
| 회의 다이제스트 | 89% | <15초/스레드 | 4.7/5 |

### 리소스 사용량

```python
resource_profiles = {
    "pdf_processing": {
        "memory": "500MB per 100 pages",
        "cpu": "2 cores peak",
        "storage": "100MB cache per document"
    },
    "news_aggregation": {
        "memory": "200MB baseline",
        "cpu": "1 core average",
        "api_calls": "100/hour"
    },
    "thread_digest": {
        "memory": "300MB per 1000 messages",
        "cpu": "1.5 cores peak",
        "cache": "50MB per thread"
    }
}
```

## 향후 개발 방향

### 단기 (1-3개월)
- PDF: 표 추출 정확도 향상
- 뉴스: 실시간 알림 최적화
- 회의: 비언어적 단서 분석 추가

### 중기 (3-6개월)
- 크로스 스킬 학습 (한 스킬의 output이 다른 스킬의 training data)
- 멀티모달 지원 (이미지, 동영상 포함)
- 프로액티브 제안 시스템

### 장기 (6-12개월)
- 스킬 자동 생성 프레임워크
- 사용자별 스킬 커스터마이징
- 스킬 마켓플레이스 통합

## 결론

이 세 가지 핵심 스킬은 로빙의 실용성을 입증하는 대표 사례입니다. 각 스킬은 독립적으로도 가치가 있지만, 통합되었을 때 시너지를 발휘하여 진정한 "디지털 동료"로서의 역할을 수행합니다.