클로드 코드로 마케팅 정보와 논문 요약 받아보는 학습 자동화

전체 시스템 설계
프로젝트 구조
marketing-intelligence-bot/
├── src/
│   ├── collectors/
│   │   ├── __init__.py
│   │   ├── arxiv_collector.py          # 학술 논문 수집
│   │   ├── web_scraper.py              # 마케팅 블로그 수집
│   │   └── rss_collector.py            # RSS 피드 수집
│   ├── analyzers/
│   │   ├── __init__.py
│   │   ├── gemini_analyzer.py          # Gemini로 콘텐츠 분석
│   │   └── content_curator.py          # 콘텐츠 큐레이션
│   ├── notifiers/
│   │   ├── __init__.py
│   │   └── email_notifier.py           # 이메일 발송
│   ├── utils/
│   │   ├── __init__.py
│   │   ├── config.py                   # 설정 관리
│   │   └── logger.py                   # 로깅
│   └── templates/
│       ├── email_template.html         # 이메일 템플릿
│       └── daily_digest.py             # 메시지 포맷팅
├── config/
│   ├── settings.yaml                   # 설정 파일
│   └── sources.yaml                    # 데이터 소스 설정
├── data/
│   └── cache/                          # 캐시 데이터
├── logs/
├── .env                                # 환경 변수
├── .env.example                        # 환경 변수 예시
├── requirements.txt
├── main.py                             # 메인 실행 파일
├── scheduler.py                        # 스케줄러
└── README.md
API 및 서비스 구성 (무료 중심)
필요한 API 목록
pythonREQUIRED_SERVICES = {
    'gemini': {
        'service': 'Google Gemini API',
        'cost': '무료 (월 60회/분, 100만 토큰/일)',
        'purpose': '콘텐츠 분석 및 요약',
        'setup': 'https://ai.google.dev/'
    },
    'arxiv': {
        'service': 'arXiv API',
        'cost': '무료',
        'purpose': '학술 논문 수집',
        'setup': '별도 설정 불필요'
    },
    'gmail_smtp': {
        'service': 'Gmail SMTP',
        'cost': '무료 (일 100통)',
        'purpose': '이메일 발송',
        'setup': 'Google 앱 비밀번호 필요'
    },
    'web_scraping': {
        'service': '직접 구현',
        'cost': '무료',
        'purpose': '마케팅 블로그 수집',
        'setup': 'requests + beautifulsoup4'
    }
}

# 총 월 비용: $0 (완전 무료!)
단계별 구현 계획
Phase 1: 기본 인프라 구축 (1주차)
python# 목표: 기본 시스템 동작 확인
PHASE_1_TASKS = [
    "프로젝트 구조 생성",
    "Gemini API 연동 테스트",
    "arXiv 논문 수집 기능",
    "기본 이메일 발송 기능",
    "환경 설정 및 로깅"
]
Phase 2: 콘텐츠 수집 확장 (2주차)
pythonPHASE_2_TASKS = [
    "마케팅 블로그 스크래핑",
    "RSS 피드 수집기",
    "콘텐츠 중복 제거",
    "데이터 캐싱 시스템"
]
Phase 3: AI 분석 고도화 (3주차)
pythonPHASE_3_TASKS = [
    "Gemini 프롬프트 최적화",
    "콘텐츠 분류 및 우선순위",
    "실무-이론 연결 로직",
    "개인화 큐레이션"
]
Phase 4: 자동화 및 스케줄링 (4주차)
pythonPHASE_4_TASKS = [
    "GitHub Actions 워크플로우",
    "에러 핸들링 및 모니터링",
    "이메일 템플릿 개선",
    "성능 최적화"
]
핵심 컴포넌트 설계
1. Gemini API 연동
python# src/analyzers/gemini_analyzer.py
import google.generativeai as genai
from typing import Dict, List

class GeminiAnalyzer:
    def __init__(self, api_key: str):
        genai.configure(api_key=api_key)
        self.model = genai.GenerativeModel('gemini-pro')
    
    def analyze_marketing_content(self, content: Dict) -> Dict:
        prompt = self.create_marketing_analysis_prompt(content)
        
        response = self.model.generate_content(
            prompt,
            generation_config={
                'temperature': 0.7,
                'top_p': 0.8,
                'top_k': 40,
                'max_output_tokens': 1000,
            }
        )
        
        return self.parse_analysis_result(response.text)
    
    def create_marketing_analysis_prompt(self, content: Dict) -> str:
        return f"""
        다음 마케팅/CRO 관련 콘텐츠를 분석해주세요:

        제목: {content.get('title', '')}
        내용: {content.get('summary', '')[:500]}...
        출처: {content.get('source', '')}

        다음 형식으로 분석해주세요:

        ## 📊 실무 적용도
        [1-5점 점수와 이유]

        ## 💡 핵심 인사이트
        [3줄 요약]

        ## 🚀 즉시 실행 가능한 액션
        [구체적인 실행 방법 2-3개]

        ## 🔬 연결 가능한 이론/연구
        [관련 이론이나 학술적 배경]

        ## 🎯 예상 임팩트
        [어떤 KPI에 어느 정도 영향 예상]
        """
2. 데이터 수집 통합 관리자
python# src/collectors/__init__.py
from .arxiv_collector import ArxivCollector
from .web_scraper import WebScraper
from .rss_collector import RSSCollector

class ContentCollectionManager:
    def __init__(self, config):
        self.arxiv = ArxivCollector()
        self.web_scraper = WebScraper(config['web_sources'])
        self.rss = RSSCollector(config['rss_feeds'])
    
    async def collect_daily_content(self) -> List[Dict]:
        content = []
        
        # 학술 논문 (주 2-3회)
        if self.should_collect_papers():
            papers = await self.arxiv.get_recent_papers([
                'cs.AI', 'cs.HC', 'econ.GN', 'stat.AP'
            ])
            content.extend(papers)
        
        # 실무 콘텐츠 (매일)
        practical_content = await self.web_scraper.scrape_marketing_blogs()
        content.extend(practical_content)
        
        # RSS 피드 (매일)
        rss_content = await self.rss.get_latest_posts()
        content.extend(rss_content)
        
        return self.deduplicate_and_filter(content)
3. 설정 파일 구조
yaml# config/settings.yaml
collection:
  max_daily_items: 20
  paper_frequency: 3  # 주당 횟수
  practical_weight: 0.7  # 실무 콘텐츠 비중
  academic_weight: 0.3   # 학술 콘텐츠 비중

analysis:
  min_relevance_score: 7
  max_summary_length: 800
  focus_areas:
    - growth_marketing
    - performance_marketing
    - ab_testing
    - conversion_optimization

email:
  send_time: "09:00"  # KST
  max_items_per_email: 5
  include_attachments: false

sources:
  marketing_blogs:
    - "https://blog.hubspot.com/marketing"
    - "https://blog.marketo.com"
    - "https://www.optimizely.com/insights"
  
  rss_feeds:
    - "https://feeds.feedburner.com/seoblog"
    - "https://feeds.feedburner.com/conversionxl"
4. 이메일 템플릿 (HTML)
html<!-- src/templates/email_template.html -->
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>마케팅 인텔리전스 데일리</title>
    <style>
        body { font-family: 'Malgun Gothic', sans-serif; line-height: 1.6; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; }
        .insight-card { border-left: 4px solid #667eea; padding: 15px; margin: 20px 0; background: #f8f9fa; }
        .action-items { background: #e8f5e8; padding: 15px; border-radius: 8px; }
        .paper-section { background: #fff3cd; padding: 15px; border-radius: 8px; }
    </style>
</head>
<body>
    <div class="header">
        <h1>🚀 마케팅 인텔리전스 데일리</h1>
        <p>{{ date }} | 실무 인사이트 + 학술 연구</p>
    </div>

    {% for insight in practical_insights %}
    <div class="insight-card">
        <h3>{{ insight.title }}</h3>
        <p><strong>적용도:</strong> {{ insight.applicability_score }}/5</p>
        <p>{{ insight.summary }}</p>
        <div class="action-items">
            <h4>🎯 액션 아이템:</h4>
            <ul>
                {% for action in insight.actions %}
                <li>{{ action }}</li>
                {% endfor %}
            </ul>
        </div>
    </div>
    {% endfor %}

    {% if academic_content %}
    <div class="paper-section">
        <h2>📚 이론적 배경</h2>
        {% for paper in academic_content %}
        <h4>{{ paper.title }}</h4>
        <p>{{ paper.practical_connection }}</p>
        {% endfor %}
    </div>
    {% endif %}
</body>
</html>
5. GitHub Actions 워크플로우
yaml# .github/workflows/daily-digest.yml
name: Daily Marketing Intelligence

on:
  schedule:
    - cron: '0 0 * * *'  # 매일 오전 9시 (KST)
  workflow_dispatch:

jobs:
  send-digest:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'
    
    - name: Cache dependencies
      uses: actions/cache@v3
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
    
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
    
    - name: Run daily digest
      env:
        GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        EMAIL_ADDRESS: ${{ secrets.EMAIL_ADDRESS }}
        EMAIL_PASSWORD: ${{ secrets.EMAIL_PASSWORD }}
        EMAIL_RECIPIENT: ${{ secrets.EMAIL_RECIPIENT }}
      run: |
        python main.py --mode daily
    
    - name: Upload logs
      if: always()
      uses: actions/upload-artifact@v3
      with:
        name: execution-logs
        path: logs/
환경 설정
1. 필요한 API 키 설정
bash# .env 파일
GEMINI_API_KEY=your_gemini_api_key_here
[email protected]
EMAIL_PASSWORD=your_app_password
[email protected]

# 선택적
WEBHOOK_URL=your_monitoring_webhook  # 에러 알림용
2. requirements.txt
google-generativeai>=0.3.0
arxiv>=2.1.0
requests>=2.31.0
beautifulsoup4>=4.12.0
feedparser>=6.0.10
jinja2>=3.1.0
pyyaml>=6.0
python-dotenv>=1.0.0
schedule>=1.2.0
aiohttp>=3.8.0
asyncio
smtplib2>=0.2.0
예상 성능 및 제약사항
Gemini API 무료 티어 제한

분당 요청: 60회
일일 토큰: 100만 토큰
월간 요청: 1500회

예상 사용량 (일간)

콘텐츠 분석: 5-10회 호출
토큰 사용량: 약 2만 토큰
여유로운 사용 가능!

시작하기 위한 체크리스트
1주차 목표:

 Gemini API 키 발급
 Gmail 앱 비밀번호 생성
 기본 프로젝트 구조 생성
 간단한 논문 수집 + 분석 + 이메일 발송 테스트

이 플랜으로 시작하시면 완전 무료로 시스템을 구축할 수 있습니다! 어떤 부분부터 구현해보고 싶으신가요?재시도MK구글 이메일 주소와 비밀번호 입력 만으로 구현 가능해?편집아니요, Gmail 주소와 일반 비밀번호만으로는 안 됩니다. 보안상 추가 설정이 필요해요.
Gmail SMTP 사용을 위한 필수 설정
문제점

Gmail은 보안상 일반 계정 비밀번호로 외부 앱 접근을 차단
"보안 수준이 낮은 앱 허용" 옵션도 2022년부터 완전 제거됨

해결 방법: 앱 비밀번호 사용
단계별 설정 방법
1. Google 계정 2단계 인증 활성화
1. Google 계정 관리 페이지 이동
2. 보안 탭 클릭
3. "2단계 인증" 활성화
4. 휴대폰 인증 완료
2. 앱 비밀번호 생성
1. Google 계정 관리 > 보안
2. "2단계 인증" 섹션에서 "앱 비밀번호" 클릭
3. 앱 선택: "기타(맞춤 이름)"
4. 이름 입력: "Marketing Intelligence Bot"
5. 생성된 16자리 비밀번호 복사
3. 환경 변수 설정
python# .env 파일
[email protected]
EMAIL_PASSWORD=abcd efgh ijkl mnop  # 16자리 앱 비밀번호
[email protected]
더 간단한 대안들
대안 1: SendGrid (무료 티어)
python# 더 안정적이고 설정 간단
SENDGRID_API_KEY=SG.your_key_here
# 월 100통 무료, 그 이후 유료
대안 2: Outlook/Hotmail SMTP
python# Gmail보다 설정이 조금 더 간단할 수 있음
SMTP_SERVER=smtp-mail.outlook.com
SMTP_PORT=587
[email protected]
EMAIL_PASSWORD=your_regular_password  # 2단계 인증 필요시 앱 비밀번호
대안 3: 로컬 개발용 (추천)
python# 개발/테스트 단계에서는 파일로 저장
class LocalEmailNotifier:
    def send_email(self, content, recipient):
        # 실제 발송 대신 로컬 파일에 저장
        with open(f'emails/{datetime.now()}.html', 'w') as f:
            f.write(content)
        print(f"이메일이 emails/ 폴더에 저장되었습니다.")
권장 개발 순서
1단계: 로컬 테스트
python# main.py
def main():
    # 콘텐츠 수집 및 분석
    content = collect_and_analyze()
    
    # 로컬에 HTML 파일로 저장 (실제 이메일 발송 X)
    save_to_local(content)
    
    print("테스트 완료! emails/ 폴더 확인하세요.")
2단계: Gmail SMTP 설정
python# Gmail 앱 비밀번호 설정 후
def main():
    if os.getenv('DEVELOPMENT_MODE') == 'true':
        save_to_local(content)
    else:
        send_via_gmail(content)  # 실제 발송
3단계: 프로덕션 배포
python# GitHub Actions 등에서 실제 발송
간단한 Gmail 설정 체크리스트
필수 단계:

 Google 2단계 인증 활성화
 앱 비밀번호 16자리 생성
 환경 변수에 앱 비밀번호 설정
 SMTP 연결 테스트

설정 테스트 코드:
pythonimport smtplib
from email.mime.text import MIMEText

def test_gmail_connection():
    try:
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(
            os.getenv('EMAIL_ADDRESS'),
            os.getenv('EMAIL_PASSWORD')  # 16자리 앱 비밀번호
        )
        server.quit()
        print("✅ Gmail SMTP 연결 성공!")
        return True
    except Exception as e:
        print(f"❌ Gmail SMTP 연결 실패: {e}")
        return False
추천 방향
개발 단계에서는:

우선 로컬 파일 저장으로 시작
콘텐츠 수집/분석 로직 완성
나중에 Gmail 앱 비밀번호 설정

프로덕션에서는:

Gmail 앱 비밀번호 또는
SendGrid 같은 전용 서비스 사용

Gmail 앱 비밀번호 설정이 번거롭다면, 우선 로컬 파일 저장으로 시작해서 핵심 로직부터 구현해보는 게 어떨까요?재시도MKarxiv api 사용하려면 어떻게 해야해?편집arXiv API는 별도 인증이나 API 키 없이 바로 사용 가능합니다! 매우 간단해요.
arXiv API 사용 방법
1. 라이브러리 설치
bashpip install arxiv
2. 기본 사용법
pythonimport arxiv

# 간단한 검색
search = arxiv.Search(
    query="machine learning",
    max_results=5
)

for paper in search.results():
    print(f"제목: {paper.title}")
    print(f"저자: {[str(author) for author in paper.authors]}")
    print(f"발표일: {paper.published}")
    print(f"요약: {paper.summary[:200]}...")
    print(f"PDF URL: {paper.pdf_url}")
    print("-" * 50)
3. 마케팅 관련 논문 검색을 위한 카테고리
python# 마케팅/CRO와 관련된 arXiv 카테고리들
MARKETING_RELATED_CATEGORIES = {
    'cs.HC': 'Human-Computer Interaction',  # UX/CRO 관련
    'cs.AI': 'Artificial Intelligence',      # 개인화, 추천 시스템
    'cs.LG': 'Machine Learning',             # 예측 모델, A/B 테스트
    'stat.AP': 'Statistics Applications',    # 통계 분석, 실험 설계
    'econ.GN': 'General Economics',          # 행동경제학, 소비자 행동
    'cs.CY': 'Computers and Society',       # 디지털 마케팅 사회적 영향
}

def search_marketing_papers():
    # 여러 카테고리 동시 검색
    query = "cat:cs.HC OR cat:cs.AI OR cat:stat.AP OR cat:econ.GN"
    
    search = arxiv.Search(
        query=query,
        max_results=20,
        sort_by=arxiv.SortCriterion.SubmittedDate,  # 최신순
        sort_order=arxiv.SortOrder.Descending
    )
    
    return list(search.results())
4. 키워드 기반 검색 (더 정확함)
pythondef search_by_keywords():
    # A/B 테스트 관련 논문
    ab_test_query = '"A/B test" OR "randomized controlled trial" OR "conversion rate"'
    
    # CRO 관련 논문
    cro_query = '"conversion optimization" OR "landing page" OR "user experience"'
    
    # 퍼포먼스 마케팅 관련
    performance_query = '"digital marketing" OR "online advertising" OR "click-through rate"'
    
    # 통합 검색
    combined_query = f"({ab_test_query}) OR ({cro_query}) OR ({performance_query})"
    
    search = arxiv.Search(
        query=combined_query,
        max_results=10,
        sort_by=arxiv.SortCriterion.Relevance
    )
    
    return list(search.results())
5. 마케팅용 arXiv 컬렉터 클래스
python# src/collectors/arxiv_collector.py
import arxiv
from datetime import datetime, timedelta
from typing import List, Dict

class MarketingArxivCollector:
    def __init__(self):
        self.categories = ['cs.HC', 'cs.AI', 'stat.AP', 'econ.GN']
        self.keywords = [
            'A/B test', 'conversion rate', 'user experience',
            'digital marketing', 'recommendation system',
            'personalization', 'behavioral economics'
        ]
    
    def collect_recent_papers(self, days_back: int = 7) -> List[Dict]:
        """최근 N일간의 관련 논문 수집"""
        papers = []
        
        # 카테고리별 검색
        for category in self.categories:
            category_papers = self._search_by_category(category, days_back)
            papers.extend(category_papers)
        
        # 키워드별 검색
        keyword_papers = self._search_by_keywords(days_back)
        papers.extend(keyword_papers)
        
        # 중복 제거 및 관련도 순 정렬
        unique_papers = self._deduplicate_and_rank(papers)
        
        return unique_papers[:10]  # 상위 10개만 반환
    
    def _search_by_category(self, category: str, days_back: int) -> List[Dict]:
        search = arxiv.Search(
            query=f"cat:{category}",
            max_results=20,
            sort_by=arxiv.SortCriterion.SubmittedDate
        )
        
        cutoff_date = datetime.now() - timedelta(days=days_back)
        papers = []
        
        for paper in search.results():
            if paper.published >= cutoff_date:
                papers.append(self._format_paper(paper))
        
        return papers
    
    def _search_by_keywords(self, days_back: int) -> List[Dict]:
        keyword_query = ' OR '.join([f'"{keyword}"' for keyword in self.keywords])
        
        search = arxiv.Search(
            query=keyword_query,
            max_results=15,
            sort_by=arxiv.SortCriterion.Relevance
        )
        
        cutoff_date = datetime.now() - timedelta(days=days_back)
        papers = []
        
        for paper in search.results():
            if paper.published >= cutoff_date:
                papers.append(self._format_paper(paper))
        
        return papers
    
    def _format_paper(self, paper) -> Dict:
        return {
            'title': paper.title,
            'authors': [str(author) for author in paper.authors],
            'published': paper.published,
            'summary': paper.summary,
            'pdf_url': paper.pdf_url,
            'arxiv_id': paper.entry_id.split('/')[-1],
            'categories': paper.categories,
            'source': 'arxiv'
        }
    
    def _deduplicate_and_rank(self, papers: List[Dict]) -> List[Dict]:
        # 제목 기준 중복 제거
        seen_titles = set()
        unique_papers = []
        
        for paper in papers:
            title_key = paper['title'].lower().strip()
            if title_key not in seen_titles:
                seen_titles.add(title_key)
                # 마케팅 관련도 점수 계산
                paper['relevance_score'] = self._calculate_relevance(paper)
                unique_papers.append(paper)
        
        # 관련도 순으로 정렬
        return sorted(unique_papers, key=lambda x: x['relevance_score'], reverse=True)
    
    def _calculate_relevance(self, paper: Dict) -> float:
        """마케팅 관련도 점수 계산"""
        score = 0
        text = (paper['title'] + ' ' + paper['summary']).lower()
        
        # 키워드 매칭
        marketing_keywords = {
            'a/b test': 3, 'ab test': 3, 'conversion': 2,
            'marketing': 2, 'user experience': 2, 'ux': 2,
            'recommendation': 1, 'personalization': 1,
            'click': 1, 'revenue': 1, 'customer': 1
        }
        
        for keyword, weight in marketing_keywords.items():
            if keyword in text:
                score += weight
        
        return score

# 사용 예시
if __name__ == "__main__":
    collector = MarketingArxivCollector()
    recent_papers = collector.collect_recent_papers(days_back=7)
    
    for paper in recent_papers:
        print(f"제목: {paper['title']}")
        print(f"관련도: {paper['relevance_score']}")
        print(f"카테고리: {paper['categories']}")
        print("-" * 50)
6. arXiv API의 특징과 제한사항
장점:

✅ 완전 무료
✅ API 키 불필요
✅ 실시간 최신 논문
✅ PDF 직접 다운로드 가능

제한사항:

⚠️ 요청당 최대 응답 시간 3초
⚠️ 동시 요청 제한 (초당 1-2개)
⚠️ 주로 STEM 분야 (마케팅 논문은 제한적)

사용 팁:
pythonimport time

def safe_arxiv_search(query, max_results=10):
    """안전한 arXiv 검색 (율제한 고려)"""
    try:
        search = arxiv.Search(
            query=query,
            max_results=max_results
        )
        
        results = []
        for paper in search.results():
            results.append(paper)
            time.sleep(0.5)  # 요청 간격 조절
        
        return results
    
    except Exception as e:
        print(f"arXiv API 오류: {e}")
        time.sleep(5)  # 오류 시 5초 대기
        return []
7. 테스트 코드
python# 바로 테스트해볼 수 있는 코드
def test_arxiv_connection():
    print("arXiv API 연결 테스트...")
    
    search = arxiv.Search(
        query="machine learning",
        max_results=3
    )
    
    papers = list(search.results())
    
    if papers:
        print(f"✅ 성공! {len(papers)}개 논문 발견")
        for i, paper in enumerate(papers, 1):
            print(f"{i}. {paper.title[:50]}...")
    else:
        print("❌ 논문을 찾을 수 없습니다.")

if __name__ == "__main__":
    test_arxiv_connection()